prefix static functions with s_

Author: sjaeckel

helper.pl

@@ -65,8 +65,8 @@ sub check_source {
           $file !~ m|src/math/.+_desc.c$| &&
           $file !~ m|src/pk/ec25519/tweetnacl.c$| &&
           $file !~ m|src/stream/sober128/sober128_stream.c$| &&
-          $l =~ /^static(\s+[a-zA-Z0-9_]+)+\s+([^_][a-zA-Z0-9_]+)\s*\(/) {
-        push @{$troubles->{staticfunc_name}}, "$lineno($2)";
+          $l =~ /^static(\s+[a-zA-Z0-9_]+)+\s+([^s][a-zA-Z0-9_]+)\s*\(/) {
+        push @{$troubles->{staticfunc_name}}, "$2";
       }
       if ($file =~ m|src/.*\.[ch]$| && $l =~ /^\s*#\s*define\s+(_[A-Z_][a-zA-Z0-9_]*)\b/) {
         my $n = $1;

src/encauth/gcm/gcm_gf_mult.c

@@ -52,7 +52,7 @@ const unsigned char gcm_shift_table[256*2] = {
 
 #ifndef LTC_FAST
 /* right shift */
-static void _gcm_rightshift(unsigned char *a)
+static void s_gcm_rightshift(unsigned char *a)
 {
    int x;
    for (x = 15; x > 0; x--) {
@@ -86,7 +86,7 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
           }
        }
        z     = V[15] & 0x01;
-       _gcm_rightshift(V);
+       s_gcm_rightshift(V);
        V[0] ^= poly[z];
    }
    XMEMCPY(c, Z, 16);

src/encauth/ocb3/ocb3_add_aad.c

@@ -15,7 +15,7 @@
    @param aad_block  [in] AAD data (block_len size)
    @return CRYPT_OK if successful
 */
-static int _ocb3_int_aad_add_block(ocb3_state *ocb, const unsigned char *aad_block)
+static int s_ocb3_int_aad_add_block(ocb3_state *ocb, const unsigned char *aad_block)
 {
    unsigned char tmp[MAXBLOCKSIZE];
    int err;
@@ -59,7 +59,7 @@ int ocb3_add_aad(ocb3_state *ocb, const unsigned char *aad, unsigned long aadlen
      ocb->adata_buffer_bytes += l;
 
      if (ocb->adata_buffer_bytes == ocb->block_len) {
-       if ((err = _ocb3_int_aad_add_block(ocb, ocb->adata_buffer)) != CRYPT_OK) {
+       if ((err = s_ocb3_int_aad_add_block(ocb, ocb->adata_buffer)) != CRYPT_OK) {
          return err;
        }
        ocb->adata_buffer_bytes = 0;
@@ -80,7 +80,7 @@ int ocb3_add_aad(ocb3_state *ocb, const unsigned char *aad, unsigned long aadlen
    last_block_len = datalen - full_blocks_len;
 
    for (x=0; x<full_blocks; x++) {
-     if ((err = _ocb3_int_aad_add_block(ocb, data+x*ocb->block_len)) != CRYPT_OK) {
+     if ((err = s_ocb3_int_aad_add_block(ocb, data+x*ocb->block_len)) != CRYPT_OK) {
        return err;
      }
    }

src/encauth/ocb3/ocb3_init.c

@@ -9,7 +9,7 @@
 
 #ifdef LTC_OCB3_MODE
 
-static void _ocb3_int_calc_offset_zero(ocb3_state *ocb, const unsigned char *nonce, unsigned long noncelen, unsigned long taglen)
+static void s_ocb3_int_calc_offset_zero(ocb3_state *ocb, const unsigned char *nonce, unsigned long noncelen, unsigned long taglen)
 {
    int x, y, bottom;
    int idx, shift;
@@ -166,7 +166,7 @@ int ocb3_init(ocb3_state *ocb, int cipher,
    }
 
    /* initialize ocb->Offset_current = Offset_0 */
-   _ocb3_int_calc_offset_zero(ocb, nonce, noncelen, taglen);
+   s_ocb3_int_calc_offset_zero(ocb, nonce, noncelen, taglen);
 
    /* initialize checksum to all zeros */
    zeromem(ocb->checksum, ocb->block_len);

src/mac/pelican/pelican.c

@@ -45,7 +45,7 @@ int pelican_init(pelican_state *pelmac, const unsigned char *key, unsigned long
     return CRYPT_OK;
 }
 
-static void _four_rounds(pelican_state *pelmac)
+static void s_four_rounds(pelican_state *pelmac)
 {
     ulong32 s0, s1, s2, s3, t0, t1, t2, t3;
     int r;
@@ -108,7 +108,7 @@ int pelican_process(pelican_state *pelmac, const unsigned char *in, unsigned lon
          for (x = 0; x < 16; x += sizeof(LTC_FAST_TYPE)) {
             *(LTC_FAST_TYPE_PTR_CAST((unsigned char *)pelmac->state + x)) ^= *(LTC_FAST_TYPE_PTR_CAST((unsigned char *)in + x));
          }
-         _four_rounds(pelmac);
+         s_four_rounds(pelmac);
          in    += 16;
          inlen -= 16;
       }
@@ -118,7 +118,7 @@ int pelican_process(pelican_state *pelmac, const unsigned char *in, unsigned lon
    while (inlen--) {
        pelmac->state[pelmac->buflen++] ^= *in++;
        if (pelmac->buflen == 16) {
-          _four_rounds(pelmac);
+          s_four_rounds(pelmac);
           pelmac->buflen = 0;
        }
    }
@@ -142,7 +142,7 @@ int pelican_done(pelican_state *pelmac, unsigned char *out)
    }
 
    if  (pelmac->buflen == 16) {
-       _four_rounds(pelmac);
+       s_four_rounds(pelmac);
        pelmac->buflen = 0;
    }
    pelmac->state[pelmac->buflen++] ^= 0x80;

src/mac/poly1305/poly1305.c

@@ -11,7 +11,7 @@
 #ifdef LTC_POLY1305
 
 /* internal only */
-static void _poly1305_block(poly1305_state *st, const unsigned char *in, unsigned long inlen)
+static void s_poly1305_block(poly1305_state *st, const unsigned char *in, unsigned long inlen)
 {
    const unsigned long hibit = (st->final) ? 0 : (1UL << 24); /* 1 << 128 */
    ulong32 r0,r1,r2,r3,r4;
@@ -135,14 +135,14 @@ int poly1305_process(poly1305_state *st, const unsigned char *in, unsigned long
       in += want;
       st->leftover += want;
       if (st->leftover < 16) return CRYPT_OK;
-      _poly1305_block(st, st->buffer, 16);
+      s_poly1305_block(st, st->buffer, 16);
       st->leftover = 0;
    }
 
    /* process full blocks */
    if (inlen >= 16) {
       unsigned long want = (inlen & ~(16 - 1));
-      _poly1305_block(st, in, want);
+      s_poly1305_block(st, in, want);
       in += want;
       inlen -= want;
    }
@@ -180,7 +180,7 @@ int poly1305_done(poly1305_state *st, unsigned char *mac, unsigned long *maclen)
       st->buffer[i++] = 1;
       for (; i < 16; i++) st->buffer[i] = 0;
       st->final = 1;
-      _poly1305_block(st, st->buffer, 16);
+      s_poly1305_block(st, st->buffer, 16);
    }
 
    /* fully carry h */

src/math/fp/ltc_ecc_fp_mulmod.c

@@ -566,7 +566,7 @@ static const struct {
 };
 
 /* find a hole and free as required, return -1 if no hole found */
-static int _find_hole(void)
+static int s_find_hole(void)
 {
    unsigned x;
    int      y, z;
@@ -602,7 +602,7 @@ static int _find_hole(void)
 }
 
 /* determine if a base is already in the cache and if so, where */
-static int _find_base(ecc_point *g)
+static int s_find_base(ecc_point *g)
 {
    int x;
    for (x = 0; x < FP_ENTRIES; x++) {
@@ -620,7 +620,7 @@ static int _find_base(ecc_point *g)
 }
 
 /* add a new base to the cache */
-static int _add_entry(int idx, ecc_point *g)
+static int s_add_entry(int idx, ecc_point *g)
 {
    unsigned x, y;
 
@@ -662,7 +662,7 @@ static int _add_entry(int idx, ecc_point *g)
  * The algorithm builds patterns in increasing bit order by first making all
  * single bit input patterns, then all two bit input patterns and so on
  */
-static int _build_lut(int idx, void *a, void *modulus, void *mp, void *mu)
+static int s_build_lut(int idx, void *a, void *modulus, void *mp, void *mu)
 {
    unsigned x, y, err, bitlen, lut_gap;
    void    *tmp;
@@ -769,7 +769,7 @@ static int _build_lut(int idx, void *a, void *modulus, void *mp, void *mu)
 }
 
 /* perform a fixed point ECC mulmod */
-static int _accel_fp_mul(int idx, void *k, ecc_point *R, void *a, void *modulus, void *mp, int map)
+static int s_accel_fp_mul(int idx, void *k, ecc_point *R, void *a, void *modulus, void *mp, int map)
 {
    unsigned char kb[128];
    int      x;
@@ -892,7 +892,7 @@ static int _accel_fp_mul(int idx, void *k, ecc_point *R, void *a, void *modulus,
 
 #ifdef LTC_ECC_SHAMIR
 /* perform a fixed point ECC mulmod */
-static int _accel_fp_mul2add(int idx1, int idx2,
+static int ss_accel_fp_mul2add(int idx1, int idx2,
                             void *kA, void *kB,
                             ecc_point *R, void *a, void *modulus, void *mp)
 {
@@ -1115,13 +1115,13 @@ int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
    mu = NULL;
    LTC_MUTEX_LOCK(&ltc_ecc_fp_lock);
       /* find point */
-      idx1 = _find_base(A);
+      idx1 = s_find_base(A);
 
       /* no entry? */
       if (idx1 == -1) {
          /* find hole and add it */
-         if ((idx1 = _find_hole()) >= 0) {
-            if ((err = _add_entry(idx1, A)) != CRYPT_OK) {
+         if ((idx1 = s_find_hole()) >= 0) {
+            if ((err = s_add_entry(idx1, A)) != CRYPT_OK) {
                goto LBL_ERR;
             }
          }
@@ -1132,13 +1132,13 @@ int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
       }
 
       /* find point */
-      idx2 = _find_base(B);
+      idx2 = s_find_base(B);
 
       /* no entry? */
       if (idx2 == -1) {
          /* find hole and add it */
-         if ((idx2 = _find_hole()) >= 0) {
-            if ((err = _add_entry(idx2, B)) != CRYPT_OK) {
+         if ((idx2 = s_find_hole()) >= 0) {
+            if ((err = s_add_entry(idx2, B)) != CRYPT_OK) {
                goto LBL_ERR;
             }
          }
@@ -1162,7 +1162,7 @@ int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
          }
 
          /* build the LUT */
-         if ((err = _build_lut(idx1, a, modulus, mp, mu)) != CRYPT_OK) {
+         if ((err = s_build_lut(idx1, a, modulus, mp, mu)) != CRYPT_OK) {
              goto LBL_ERR;;
          }
       }
@@ -1183,7 +1183,7 @@ int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
          }
 
          /* build the LUT */
-         if ((err = _build_lut(idx2, a, modulus, mp, mu)) != CRYPT_OK) {
+         if ((err = s_build_lut(idx2, a, modulus, mp, mu)) != CRYPT_OK) {
              goto LBL_ERR;;
          }
       }
@@ -1194,7 +1194,7 @@ int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
             /* compute mp */
             if ((err = mp_montgomery_setup(modulus, &mp)) != CRYPT_OK) { goto LBL_ERR; }
          }
-         err = _accel_fp_mul2add(idx1, idx2, kA, kB, C, a, modulus, mp);
+         err = ss_accel_fp_mul2add(idx1, idx2, kA, kB, C, a, modulus, mp);
       } else {
          err = ltc_ecc_mul2add(A, kA, B, kB, C, a, modulus);
       }
@@ -1228,15 +1228,15 @@ int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *a, void *modulu
    mu = NULL;
    LTC_MUTEX_LOCK(&ltc_ecc_fp_lock);
       /* find point */
-      idx = _find_base(G);
+      idx = s_find_base(G);
 
       /* no entry? */
       if (idx == -1) {
          /* find hole and add it */
-         idx = _find_hole();
+         idx = s_find_hole();
 
          if (idx >= 0) {
-            if ((err = _add_entry(idx, G)) != CRYPT_OK) {
+            if ((err = s_add_entry(idx, G)) != CRYPT_OK) {
                goto LBL_ERR;
             }
          }
@@ -1261,7 +1261,7 @@ int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *a, void *modulu
          }
 
          /* build the LUT */
-         if ((err = _build_lut(idx, a, modulus, mp, mu)) != CRYPT_OK) {
+         if ((err = s_build_lut(idx, a, modulus, mp, mu)) != CRYPT_OK) {
              goto LBL_ERR;;
          }
       }
@@ -1271,7 +1271,7 @@ int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *a, void *modulu
             /* compute mp */
             if ((err = mp_montgomery_setup(modulus, &mp)) != CRYPT_OK) { goto LBL_ERR; }
          }
-         err = _accel_fp_mul(idx, k, R, a, modulus, mp, map);
+         err = s_accel_fp_mul(idx, k, R, a, modulus, mp, map);
       } else {
          err = ltc_ecc_mulmod(k, G, R, a, modulus, map);
       }
@@ -1287,7 +1287,7 @@ int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *a, void *modulu
 }
 
 /* helper function for freeing the cache ... must be called with the cache mutex locked */
-static void _ltc_ecc_fp_free_cache(void)
+static void s_ltc_ecc_fp_free_cache(void)
 {
    unsigned x, y;
    for (x = 0; x < FP_ENTRIES; x++) {
@@ -1312,7 +1312,7 @@ static void _ltc_ecc_fp_free_cache(void)
 void ltc_ecc_fp_free(void)
 {
    LTC_MUTEX_LOCK(&ltc_ecc_fp_lock);
-   _ltc_ecc_fp_free_cache();
+   s_ltc_ecc_fp_free_cache();
    LTC_MUTEX_UNLOCK(&ltc_ecc_fp_lock);
 }
 
@@ -1331,19 +1331,19 @@ ltc_ecc_fp_add_point(ecc_point *g, void *modulus, int lock)
    void *mu = NULL;
 
    LTC_MUTEX_LOCK(&ltc_ecc_fp_lock);
-   if ((idx = _find_base(g)) >= 0) {
+   if ((idx = s_find_base(g)) >= 0) {
       /* it is already in the cache ... just check that the LUT is initialized */
       if(fp_cache[idx].lru_count >= 2) {
          LTC_MUTEX_UNLOCK(&ltc_ecc_fp_lock);
          return CRYPT_OK;
       }
    }
 
-   if(idx == -1 && (idx = _find_hole()) == -1) {
+   if(idx == -1 && (idx = s_find_hole()) == -1) {
       err = CRYPT_BUFFER_OVERFLOW;
       goto LBL_ERR;
    }
-   if ((err = _add_entry(idx, g)) != CRYPT_OK) {
+   if ((err = s_add_entry(idx, g)) != CRYPT_OK) {
       goto LBL_ERR;
    }
    /* compute mp */
@@ -1360,7 +1360,7 @@ ltc_ecc_fp_add_point(ecc_point *g, void *modulus, int lock)
    }
 
    /* build the LUT */
-   if ((err = _build_lut(idx, a, modulus, mp, mu)) != CRYPT_OK) {
+   if ((err = s_build_lut(idx, a, modulus, mp, mu)) != CRYPT_OK) {
        goto LBL_ERR;
    }
    fp_cache[idx].lru_count = 2;
@@ -1498,7 +1498,7 @@ int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen)
    /*
     * start with an empty cache
     */
-   _ltc_ecc_fp_free_cache();
+   s_ltc_ecc_fp_free_cache();
 
    /*
     * decode the input packet: It consists of a sequence with a few
@@ -1568,7 +1568,7 @@ int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen)
 ERR_OUT:
    if(asn1_list)
       XFREE(asn1_list);
-   _ltc_ecc_fp_free_cache();
+   s_ltc_ecc_fp_free_cache();
    LTC_MUTEX_UNLOCK(&ltc_ecc_fp_lock);
    return err;
 }