Fix a huge pile of -Wshadow warnings.

These appeared on some of the Jenkins platforms. Apparently some
GCCs care when you shadow globals, and some don't.

5 files changed, 53 insertions, 52 deletions

diff --git a/src/common/compat.c b/src/common/compat.c
index 081490d381..e0807e4c87 100644
--- a/src/common/compat.c
+++ b/src/common/compat.c
@@ -1181,10 +1181,10 @@ tor_open_socket,(int domain, int type, int protocol))
 
 /** Mockable wrapper for connect(). */
 MOCK_IMPL(tor_socket_t,
-tor_connect_socket,(tor_socket_t socket,const struct sockaddr *address,
+tor_connect_socket,(tor_socket_t sock, const struct sockaddr *address,
                      socklen_t address_len))
 {
-  return connect(socket,address,address_len);
+  return connect(sock,address,address_len);
 }
 
 /** As socket(), but creates a nonblocking socket and
@@ -1359,31 +1359,31 @@ get_n_open_sockets(void)
 
 /** Mockable wrapper for getsockname(). */
 MOCK_IMPL(int,
-tor_getsockname,(tor_socket_t socket, struct sockaddr *address,
+tor_getsockname,(tor_socket_t sock, struct sockaddr *address,
                  socklen_t *address_len))
 {
-   return getsockname(socket, address, address_len);
+   return getsockname(sock, address, address_len);
 }
 
 /** Turn <b>socket</b> into a nonblocking socket. Return 0 on success, -1
  * on failure.
  */
 int
-set_socket_nonblocking(tor_socket_t socket)
+set_socket_nonblocking(tor_socket_t sock)
 {
 #if defined(_WIN32)
   unsigned long nonblocking = 1;
-  ioctlsocket(socket, FIONBIO, (unsigned long*) &nonblocking);
+  ioctlsocket(sock, FIONBIO, (unsigned long*) &nonblocking);
 #else
   int flags;
 
-  flags = fcntl(socket, F_GETFL, 0);
+  flags = fcntl(sock, F_GETFL, 0);
   if (flags == -1) {
     log_warn(LD_NET, "Couldn't get file status flags: %s", strerror(errno));
     return -1;
   }
   flags |= O_NONBLOCK;
-  if (fcntl(socket, F_SETFL, flags) == -1) {
+  if (fcntl(sock, F_SETFL, flags) == -1) {
     log_warn(LD_NET, "Couldn't set file status flags: %s", strerror(errno));
     return -1;
   }
diff --git a/src/common/crypto.c b/src/common/crypto.c
index 1c5b5993c9..b87023f071 100644
--- a/src/common/crypto.c
+++ b/src/common/crypto.c
@@ -3099,8 +3099,8 @@ crypto_rand_double(void)
 {
   /* We just use an unsigned int here; we don't really care about getting
    * more than 32 bits of resolution */
-  unsigned int uint;
-  crypto_rand((char*)&uint, sizeof(uint));
+  unsigned int u;
+  crypto_rand((char*)&u, sizeof(u));
 #if SIZEOF_INT == 4
 #define UINT_MAX_AS_DOUBLE 4294967296.0
 #elif SIZEOF_INT == 8
@@ -3108,7 +3108,7 @@ crypto_rand_double(void)
 #else
 #error SIZEOF_INT is neither 4 nor 8
 #endif
-  return ((double)uint) / UINT_MAX_AS_DOUBLE;
+  return ((double)u) / UINT_MAX_AS_DOUBLE;
 }
 
 /** Generate and return a new random hostname starting with <b>prefix</b>,
diff --git a/src/common/log.c b/src/common/log.c
index 51309aa472..cb62a37e52 100644
--- a/src/common/log.c
+++ b/src/common/log.c
@@ -1071,13 +1071,13 @@ mark_logs_temp(void)
  */
 int
 add_file_log(const log_severity_list_t *severity, const char *filename,
-             const int truncate)
+             const int truncate_log)
 {
   int fd;
   logfile_t *lf;
 
   int open_flags = O_WRONLY|O_CREAT;
-  open_flags |= truncate ? O_TRUNC : O_APPEND;
+  open_flags |= truncate_log ? O_TRUNC : O_APPEND;
 
   fd = tor_open_cloexec(filename, open_flags, 0644);
   if (fd<0)
diff --git a/src/common/torgzip.c b/src/common/torgzip.c
index 331bb5a017..3353f0ef61 100644
--- a/src/common/torgzip.c
+++ b/src/common/torgzip.c
@@ -418,13 +418,13 @@ struct tor_zlib_state_t {
  * <b>compress</b>, it's for compression; otherwise it's for
  * decompression. */
 tor_zlib_state_t *
-tor_zlib_new(int compress, compress_method_t method,
+tor_zlib_new(int compress_, compress_method_t method,
              zlib_compression_level_t compression_level)
 {
   tor_zlib_state_t *out;
   int bits, memlevel;
 
- if (! compress) {
+ if (! compress_) {
    /* use this setting for decompression, since we might have the
     * max number of window bits */
    compression_level = HIGH_COMPRESSION;
@@ -434,10 +434,10 @@ tor_zlib_new(int compress, compress_method_t method,
  out->stream.zalloc = Z_NULL;
  out->stream.zfree = Z_NULL;
  out->stream.opaque = NULL;
- out->compress = compress;
+ out->compress = compress_;
  bits = method_bits(method, compression_level);
  memlevel = get_memlevel(compression_level);
- if (compress) {
+ if (compress_) {
    if (deflateInit2(&out->stream, Z_BEST_COMPRESSION, Z_DEFLATED,
                     bits, memlevel,
                     Z_DEFAULT_STRATEGY) != Z_OK)
@@ -446,7 +446,7 @@ tor_zlib_new(int compress, compress_method_t method,
    if (inflateInit2(&out->stream, bits) != Z_OK)
      goto err; // LCOV_EXCL_LINE
  }
- out->allocation = tor_zlib_state_size_precalc(!compress, bits, memlevel);
+ out->allocation = tor_zlib_state_size_precalc(!compress_, bits, memlevel);
 
  total_zlib_allocation += out->allocation;
 
@@ -540,13 +540,13 @@ tor_zlib_free(tor_zlib_state_t *state)
 /** Return an approximate number of bytes used in RAM to hold a state with
  * window bits <b>windowBits</b> and compression level 'memlevel' */
 static size_t
-tor_zlib_state_size_precalc(int inflate, int windowbits, int memlevel)
+tor_zlib_state_size_precalc(int inflate_, int windowbits, int memlevel)
 {
   windowbits &= 15;
 
 #define A_FEW_KILOBYTES 2048
 
-  if (inflate) {
+  if (inflate_) {
     /* From zconf.h:
 
        "The memory requirements for inflate are (in bytes) 1 << windowBits
diff --git a/src/common/util.c b/src/common/util.c
index 2369c5f62a..0c04eb10ae 100644
--- a/src/common/util.c
+++ b/src/common/util.c
@@ -305,17 +305,17 @@ tor_strdup_(const char *s DMALLOC_PARAMS)
 char *
 tor_strndup_(const char *s, size_t n DMALLOC_PARAMS)
 {
-  char *dup;
+  char *duplicate;
   tor_assert(s);
   tor_assert(n < SIZE_T_CEILING);
-  dup = tor_malloc_((n+1) DMALLOC_FN_ARGS);
+  duplicate = tor_malloc_((n+1) DMALLOC_FN_ARGS);
   /* Performance note: Ordinarily we prefer strlcpy to strncpy.  But
    * this function gets called a whole lot, and platform strncpy is
    * much faster than strlcpy when strlen(s) is much longer than n.
    */
-  strncpy(dup, s, n);
-  dup[n]='\0';
-  return dup;
+  strncpy(duplicate, s, n);
+  duplicate[n]='\0';
+  return duplicate;
 }
 
 /** Allocate a chunk of <b>len</b> bytes, with the same contents as the
@@ -323,12 +323,12 @@ tor_strndup_(const char *s, size_t n DMALLOC_PARAMS)
 void *
 tor_memdup_(const void *mem, size_t len DMALLOC_PARAMS)
 {
-  char *dup;
+  char *duplicate;
   tor_assert(len < SIZE_T_CEILING);
   tor_assert(mem);
-  dup = tor_malloc_(len DMALLOC_FN_ARGS);
-  memcpy(dup, mem, len);
-  return dup;
+  duplicate = tor_malloc_(len DMALLOC_FN_ARGS);
+  memcpy(duplicate, mem, len);
+  return duplicate;
 }
 
 /** As tor_memdup(), but add an extra 0 byte at the end of the resulting
@@ -336,13 +336,13 @@ tor_memdup_(const void *mem, size_t len DMALLOC_PARAMS)
 void *
 tor_memdup_nulterm_(const void *mem, size_t len DMALLOC_PARAMS)
 {
-  char *dup;
+  char *duplicate;
   tor_assert(len < SIZE_T_CEILING+1);
   tor_assert(mem);
-  dup = tor_malloc_(len+1 DMALLOC_FN_ARGS);
-  memcpy(dup, mem, len);
-  dup[len] = '\0';
-  return dup;
+  duplicate = tor_malloc_(len+1 DMALLOC_FN_ARGS);
+  memcpy(duplicate, mem, len);
+  duplicate[len] = '\0';
+  return duplicate;
 }
 
 /** Helper for places that need to take a function pointer to the right
@@ -556,7 +556,7 @@ sample_laplace_distribution(double mu, double b, double p)
  * The epsilon value must be between ]0.0, 1.0]. delta_f must be greater
  * than 0. */
 int64_t
-add_laplace_noise(int64_t signal, double random, double delta_f,
+add_laplace_noise(int64_t signal_, double random_, double delta_f,
                   double epsilon)
 {
   int64_t noise;
@@ -569,15 +569,15 @@ add_laplace_noise(int64_t signal, double random, double delta_f,
   /* Just add noise, no further signal */
   noise = sample_laplace_distribution(0.0,
                                       delta_f / epsilon,
-                                      random);
+                                      random_);
 
   /* Clip (signal + noise) to [INT64_MIN, INT64_MAX] */
-  if (noise > 0 && INT64_MAX - noise < signal)
+  if (noise > 0 && INT64_MAX - noise < signal_)
     return INT64_MAX;
-  else if (noise < 0 && INT64_MIN - noise > signal)
+  else if (noise < 0 && INT64_MIN - noise > signal_)
     return INT64_MIN;
   else
-    return signal + noise;
+    return signal_ + noise;
 }
 
 /* Helper: return greatest common divisor of a,b */
@@ -638,12 +638,12 @@ n_bits_set_u8(uint8_t v)
 void
 tor_strstrip(char *s, const char *strip)
 {
-  char *read = s;
-  while (*read) {
-    if (strchr(strip, *read)) {
-      ++read;
+  char *readp = s;
+  while (*readp) {
+    if (strchr(strip, *readp)) {
+      ++readp;
     } else {
-      *s++ = *read++;
+      *s++ = *readp++;
     }
   }
   *s = '\0';
@@ -1559,11 +1559,12 @@ tv_to_msec(const struct timeval *tv)
 #define IS_LEAPYEAR(y) (!(y % 4) && ((y % 100) || !(y % 400)))
 /** Helper: Return the number of leap-days between Jan 1, y1 and Jan 1, y2. */
 static int
-n_leapdays(int y1, int y2)
+n_leapdays(int year1, int year2)
 {
-  --y1;
-  --y2;
-  return (y2/4 - y1/4) - (y2/100 - y1/100) + (y2/400 - y1/400);
+  --year1;
+  --year2;
+  return (year2/4 - year1/4) - (year2/100 - year1/100)
+    + (year2/400 - year1/400);
 }
 /** Number of days per month in non-leap year; used by tor_timegm and
  * parse_rfc1123_time. */
@@ -5688,7 +5689,7 @@ tor_weak_random_range(tor_weak_rng_t *rng, int32_t top)
 int64_t
 clamp_double_to_int64(double number)
 {
-  int exp;
+  int exponent;
 
   /* NaN is a special case that can't be used with the logic below. */
   if (isnan(number)) {
@@ -5702,14 +5703,14 @@ clamp_double_to_int64(double number)
    * magnitude of number is strictly less than 2^exp.
    *
    * If number is infinite, the call to frexp is legal but the contents of
-   * exp are unspecified. */
-  frexp(number, &exp);
+   * are exponent unspecified. */
+  frexp(number, &exponent);
 
   /* If the magnitude of number is strictly less than 2^63, the truncated
    * version of number is guaranteed to be representable. The only
    * representable integer for which this is not the case is INT64_MIN, but
    * it is covered by the logic below. */
-  if (isfinite(number) && exp <= 63) {
+  if (isfinite(number) && exponent <= 63) {
     return (int64_t)number;
   }