variation b

Author: czurnieden

bn_deprecated.c

@@ -232,20 +232,16 @@ mp_err mp_n_root(const mp_int *a, mp_digit b, mp_int *c)
 #ifdef BN_MP_TORADIX_N_C
 mp_err mp_toradix_n(const mp_int *a, char *str, int radix, int maxlen)
 {
-   size_t length[1];
    if (maxlen < 0) {
       return MP_VAL;
    }
-   *length = (size_t)maxlen;
-   return mp_to_radix(a, str, length, radix);
+   return mp_to_radix(a, &str, maxlen, NULL, radix);
 }
 #endif
 #ifdef BN_MP_TORADIX_C
 mp_err mp_toradix(const mp_int *a, char *str, int radix)
 {
-   size_t length[1];
-   *length = SIZE_MAX;
-   return mp_to_radix(a, str, length, radix);
+   return mp_to_radix(a, &str, 0u, NULL, radix);
 }
 #endif
 #endif

bn_mp_fwrite.c

@@ -6,33 +6,22 @@
 #ifndef MP_NO_FILE
 mp_err mp_fwrite(const mp_int *a, int radix, FILE *stream)
 {
-   char *buf;
+   /* To avoid "uninitialized" warnings */
+   char *buf = NULL;
    mp_err err;
-   int len;
-   /* TODO: that's a bit awkward */
-   size_t length[1];
+   size_t written;
 
-   if ((err = mp_radix_size(a, radix, &len)) != MP_OKAY) {
-      return err;
-   }
-
-   *length = (size_t)len;
-
-   buf = (char *) MP_MALLOC(*length);
-   if (buf == NULL) {
-      return MP_MEM;
-   }
-   if ((err = mp_to_radix(a, buf, length, radix)) != MP_OKAY) {
+   if ((err = mp_to_radix(a, &buf, 0u, &written, radix)) != MP_OKAY) {
       goto LBL_ERR;
    }
-   if (fwrite(buf, *length, 1uL, stream) != 1uL) {
+   if (fwrite(buf, written, 1uL, stream) != 1uL) {
       err = MP_ERR;
       goto LBL_ERR;
    }
-   err = MP_OKAY;
 
 LBL_ERR:
-   MP_FREE_BUFFER(buf, *length);
+   /* "written" can be small than the allocated buffer! */
+   MP_FREE_BUFFER(buf, written);
    return err;
 }
 #endif

bn_mp_radix_size.c

@@ -4,7 +4,7 @@
 /* SPDX-License-Identifier: Unlicense */
 
 /* returns size of ASCII reprensentation */
-mp_err mp_radix_size(const mp_int *a, int radix, int *size)
+mp_err mp_radix_size(const mp_int *a, int radix, size_t *size)
 {
    mp_err  err;
    int     digs;

bn_mp_to_radix.c

@@ -5,57 +5,132 @@
 
 /* stores a bignum as a ASCII string in a given radix (2..64)
  *
- * Stores upto maxlen-1 chars and always a NULL byte
+ * Stores upto "size - 1" chars and always a NULL byte, puts the number of characters
+ * written, including the '\0', in "written".
+ * For "size == 0u" the whole number in "a" will get converted.
  */
-mp_err mp_to_radix(const mp_int *a, char *str, size_t *maxlen, int radix)
+mp_err mp_to_radix(const mp_int *a, char **str, size_t size, size_t *written, int radix)
 {
-   int     digs;
+   size_t digs;
    mp_err  err;
    mp_int  t;
    mp_digit d;
-   char   *_s = str;
+   char   *_s, *tmp;
+   size_t len;
 
-   /* check range of the maxlen, radix */
-   if ((*maxlen < 2u) || (radix < 2) || (radix > 64)) {
+   /* check range of radix and size*/
+   /* "size" includes the NUL byte so must be at least two if it isn't zero which
+       starts the automatic length-evaluation */
+   if ((size == 1u) || (radix < 2) || (radix > 64)) {
       return MP_VAL;
    }
-
    /* quick out if its zero */
    if (MP_IS_ZERO(a)) {
-      *str++ = '0';
-      *str = '\0';
+      if (size == 0u) {
+         if (*str != NULL) {
+            /* No MP_REALLOC because the old size is unknown */
+            tmp = realloc(*str, 2u);
+            if (tmp == NULL) {
+               return MP_MEM;
+            }
+            *str = tmp;
+         } else {
+            *str = MP_MALLOC(2u);
+            if (*str == NULL) {
+               return MP_MEM;
+            }
+         }
+      }
+      **str = '0';
+      (*str)++;
+      **str = '\0';
+      if (written != NULL) {
+         *written = 2u;
+      }
       return MP_OKAY;
    }
 
    if ((err = mp_init_copy(&t, a)) != MP_OKAY) {
       return err;
    }
 
+   if (size == 0u) {
+      /* TODO: is not in this PR */
+      if (MP_HAS(MP_RADIX_SIZEINBASE)) {
+         /* if ((err = mp_radix_sizeinbase(&t, base, &len)) != MP_OKAY)      goto LBL_ERR; */
+      } else {
+         /* TODO: exchange with direct use of mp_ilogb later? */
+         if ((err = mp_radix_size(&t, radix, &len)) != MP_OKAY)        goto LBL_ERR;
+      }
+      if (t.sign == MP_NEG) {
+         /* TODO: check for overflow? */
+         len++;
+      }
+      if (*str != NULL) {
+         /* No MP_REALLOC because the old size is unknown */
+         tmp = realloc(*str, len);
+         if (tmp == NULL) {
+            return MP_MEM;
+         }
+         *str = tmp;
+      } else {
+         *str = MP_MALLOC(len);
+         if (*str == NULL) {
+            return MP_MEM;
+         }
+      }
+      size = len;
+   } else {
+      len = size;
+      if (t.sign == MP_NEG) {
+         len++;
+      }
+      if (*str != NULL) {
+         tmp = realloc(*str, len);
+         if (tmp == NULL) {
+            return MP_MEM;
+         }
+         *str = tmp;
+      } else {
+         *str = MP_MALLOC(len);
+         if (*str == NULL) {
+            return MP_MEM;
+         }
+      }
+   }
+
+   _s = *str;
+
    /* if it is negative output a - */
    if (t.sign == MP_NEG) {
       /* we have to reverse our digits later... but not the - sign!! */
       ++_s;
 
       /* store the flag and mark the number as positive */
-      *str++ = '-';
+      **str = '-';
+      (*str)++;
       t.sign = MP_ZPOS;
 
       /* subtract a char */
-      --maxlen;
+      --len;
    }
 
    digs = 0;
    while (!MP_IS_ZERO(&t)) {
-      if (--(*maxlen) < 1u) {
+      if (--len < 1u) {
          /* no more room */
          err = MP_VAL;
          break;
       }
       if ((err = mp_div_d(&t, (mp_digit)radix, &t, &d)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      *str++ = mp_s_rmap[d];
+      **str = mp_s_rmap[d];
+      (*str)++;
       ++digs;
+      if (digs == size) {
+         break;
+      }
    }
 
    /* reverse the digits of the string.  In this case _s points
@@ -64,9 +139,12 @@ mp_err mp_to_radix(const mp_int *a, char *str, size_t *maxlen, int radix)
    s_mp_reverse((unsigned char *)_s, digs);
 
    /* append a NULL so the string is properly terminated */
-   *str = '\0';
-   digs++;
-   *maxlen = (size_t)digs;
+   **str = '\0';
+   /* rewind */
+   *str = _s;
+   if (written != NULL) {
+      *written = digs + 1;
+   }
 
 LBL_ERR:
    mp_clear(&t);

demo/main.c

@@ -5,22 +5,15 @@ int unit_tests(int argc, char **argv);
 
 void ndraw(mp_int *a, const char *name)
 {
-   char *buf;
-   int size;
-   size_t length[1];
-
-   mp_radix_size(a, 10, &size);
-   *length = (size_t)size;
-   buf = (char *)malloc(*length);
-   if (buf == NULL) {
-      fprintf(stderr, "\nndraw: malloc(%d) failed\n", size);
-      exit(EXIT_FAILURE);
-   }
+   char *buf = NULL;
+   size_t written;
+
+
 
    printf("%s: ", name);
-   mp_to_radix(a, buf, length, 10);
+   mp_to_radix(a, &buf, 0u, &written, 10);
    printf("%s\n", buf);
-   mp_to_radix(a, buf, length, 16);
+   mp_to_radix(a, &buf, 0u, &written,  16);
    printf("0x%s\n", buf);
 
    free(buf);

demo/test.c

@@ -1187,8 +1187,8 @@ static int test_mp_montgomery_reduce(void)
 {
    mp_digit mp;
    int ix, i, n;
-   char buf[4096];
-   size_t length[1];
+   char *buf = NULL;
+   /* size_t written; */
 
    mp_int a, b, c, d, e;
    if (mp_init_multi(&a, &b, &c, &d, &e, NULL)!= MP_OKAY) {
@@ -1222,17 +1222,18 @@ static int test_mp_montgomery_reduce(void)
             if (mp_cmp(&c, &d) != MP_EQ) {
 /* *INDENT-OFF* */
                printf("d = e mod a, c = e MOD a\n");
-               *length = sizeof(buf);
-               mp_to_radix(&a, buf, length, 10); printf("a = %s, length = %zu\n", buf, *length);
-               mp_to_radix(&e, buf, length, 10); printf("e = %s, length = %zu\n", buf, *length);
-               mp_to_radix(&d, buf, length, 10); printf("d = %s, length = %zu\n", buf, *length);
-               mp_to_radix(&c, buf, length, 10); printf("c = %s, length = %zu\n", buf, *length);
 /*
-               mp_to_decimal(&a, buf, sizeof(buf)); printf("a = %s\n", buf);
-               mp_to_decimal(&e, buf, sizeof(buf)); printf("e = %s\n", buf);
-               mp_to_decimal(&d, buf, sizeof(buf)); printf("d = %s\n", buf);
-               mp_to_decimal(&c, buf, sizeof(buf)); printf("c = %s\n", buf);
+               mp_to_radix(&a, &buf, 0u, &written, 10); printf("a = %s, written = %zu\n", buf, written);
+               mp_to_radix(&e, &buf, 0u, &written, 10); printf("e = %s, written = %zu\n", buf, written);
+               mp_to_radix(&d, &buf, 0u, &written, 10); printf("d = %s, written = %zu\n", buf, written);
+               mp_to_radix(&c, &buf, 0u, &written, 10); printf("c = %s, written = %zu\n", buf, written);
 */
+
+               mp_to_decimal(&a, &buf, 0u); printf("a = %s\n", buf);
+               mp_to_decimal(&e, &buf, 0u); printf("e = %s\n", buf);
+               mp_to_decimal(&d, &buf, 0u); printf("d = %s\n", buf);
+               mp_to_decimal(&c, &buf, 0u); printf("c = %s\n", buf);
+
                printf("compare no compare!\n"); goto LBL_ERR;
 /* *INDENT-ON* */
             }
@@ -1246,46 +1247,47 @@ static int test_mp_montgomery_reduce(void)
    }
 
    printf("\n\n");
+   free(buf);
 
    mp_clear_multi(&a, &b, &c, &d, &e, NULL);
    return EXIT_SUCCESS;
 LBL_ERR:
+   free(buf);
    mp_clear_multi(&a, &b, &c, &d, &e, NULL);
    return EXIT_FAILURE;
 
 }
 
 static int test_mp_read_radix(void)
 {
-   char buf[4096];
-   size_t length[1];
+   char *buf = NULL;
+   size_t written;
 
    mp_int a;
    if (mp_init_multi(&a, NULL)!= MP_OKAY) {
       return EXIT_FAILURE;
    }
 
    mp_read_radix(&a, "123456", 10);
-   *length = 3u;
-   mp_to_radix(&a, buf, length, 10);
-   printf("a == %s, length = %zu\n", buf, *length);
-   *length = 4u;
-   mp_to_radix(&a, buf, length, 10);
-   printf("a == %s, length = %zu\n", buf, *length);
-   *length = 30u;
-   mp_to_radix(&a, buf, length, 10);
-   printf("a == %s, length = %zu\n", buf, *length);
+
+   mp_to_radix(&a, &buf, 3u, &written, 10);
+   printf("a == %s, length = %zu\n", buf, written);
+   mp_to_radix(&a, &buf, 4u, &written, 10);
+   printf("a == %s, length = %zu\n", buf, written);
+   mp_to_radix(&a, &buf, 30u, &written, 10);
+   printf("a == %s, length = %zu\n", buf, written);
 
    while (0) {
-      char *s = fgets(buf, sizeof(buf), stdin);
-      if (s != buf) break;
-      mp_read_radix(&a, buf, 10);
+      char line_buffer[4096];
+      char *s = fgets(line_buffer, sizeof(line_buffer), stdin);
+      if (s != line_buffer) break;
+      mp_read_radix(&a, line_buffer, 10);
       mp_prime_next_prime(&a, 5, 1);
-      *length = sizeof(buf);
-      mp_to_radix(&a, buf, length, 10);
+      mp_to_radix(&a, &buf, 0u, NULL, 10);
       printf("%s, %lu\n", buf, (unsigned long)a.dp[0] & 3uL);
    }
 
+   free(buf);
    mp_clear_multi(&a, NULL);
    return EXIT_SUCCESS;
 }
@@ -1838,6 +1840,7 @@ static int test_mp_decr(void)
    All numbers as strings to simplifiy things, especially for the
    low-mp branch.
 */
+
 static int test_mp_root_u32(void)
 {
    mp_int a, c, r;