Change from inet_ntoa to a threadproof tor_inet_ntoa.

svn:r3656

diff --git a/src/common/util.c b/src/common/util.c
index 4b17454e8019d966f00d73d82eb8be5cce11287f..339572e449d52672a58b82822a20736f9891e8d7 100644 (file)
--- a/src/common/util.c
+++ b/src/common/util.c
@@ -1255,6 +1255,17 @@ parse_addr_and_port_range(const char *s, uint32_t *addr_out,
   return -1;
 }
 
+int
+tor_inet_ntoa(struct in_addr *in, char *buf, size_t buf_len)
+{
+  uint32_t a = ntohl(in->s_addr);
+  return tor_snprintf(buf, buf_len, "%d.%d.%d.%d",
+                      (int)(uint8_t)((a>>24)&0xff),
+                      (int)(uint8_t)((a>>16)&0xff),
+                      (int)(uint8_t)((a>>8 )&0xff),
+                      (int)(uint8_t)((a    )&0xff));
+}
+
 /* =====
  * Process helpers
  * ===== */

diff --git a/src/common/util.h b/src/common/util.h
index 2f139515af7d46cccf6551de8e9de15d1c858156..fde2557f582d9e5e3fdf87530e22541199367615 100644 (file)
--- a/src/common/util.h
+++ b/src/common/util.h
@@ -126,6 +126,8 @@ int parse_addr_port(const char *addrport, char **address, uint32_t *addr,
 int parse_addr_and_port_range(const char *s, uint32_t *addr_out,
                               uint32_t *mask_out, uint16_t *port_min_out,
                               uint16_t *port_max_out);
+#define INET_NTOA_BUF_LEN 16
+int tor_inet_ntoa(struct in_addr *in, char *buf, size_t buf_len);
 
 /* Process helpers */
 void start_daemon(const char *desired_cwd);

diff --git a/src/or/buffers.c b/src/or/buffers.c
index 990fc94b1576d3b94a9c9c941ddc7d6f6bb6442d..0abcd9a828ca16c57843e1586e2a39f2e13fab4d 100644 (file)
--- a/src/or/buffers.c
+++ b/src/or/buffers.c
@@ -448,7 +448,7 @@ int fetch_from_buf_http(buf_t *buf,
  */
 int fetch_from_buf_socks(buf_t *buf, socks_request_t *req) {
   unsigned char len;
-  char *tmpbuf=NULL;
+  char tmpbuf[INET_NTOA_BUF_LEN];
   uint32_t destip;
   enum {socks4, socks4a} socks4_prot = socks4a;
   char *next, *startaddr;
@@ -505,7 +505,7 @@ int fetch_from_buf_socks(buf_t *buf, socks_request_t *req) {
 
           destip = ntohl(*(uint32_t*)(buf->mem+4));
           in.s_addr = htonl(destip);
-          tmpbuf = inet_ntoa(in);
+          tor_inet_ntoa(&in,tmpbuf,sizeof(tmpbuf));
           if (strlen(tmpbuf)+1 > MAX_SOCKS_ADDR_LEN) {
             log_fn(LOG_WARN,"socks5 IP takes %d bytes, which doesn't fit in %d. Rejecting.",
                    (int)strlen(tmpbuf)+1,(int)MAX_SOCKS_ADDR_LEN);
@@ -565,7 +565,7 @@ int fetch_from_buf_socks(buf_t *buf, socks_request_t *req) {
       if (destip >> 8) {
         log_fn(LOG_DEBUG,"socks4: destip not in form 0.0.0.x.");
         in.s_addr = htonl(destip);
-        tmpbuf = inet_ntoa(in);
+        tor_inet_ntoa(&in,tmpbuf,sizeof(tmpbuf));
         if (strlen(tmpbuf)+1 > MAX_SOCKS_ADDR_LEN) {
           log_fn(LOG_WARN,"socks4 addr (%d bytes) too long. Rejecting.",
                  (int)strlen(tmpbuf));

diff --git a/src/or/circuitbuild.c b/src/or/circuitbuild.c
index edf76da110d422e4da44453029697b5b84d8c258..b10d0b17329afd1d6d7e77a4a038efa2784ebf02 100644 (file)
--- a/src/or/circuitbuild.c
+++ b/src/or/circuitbuild.c
@@ -503,9 +503,11 @@ int circuit_extend(cell_t *cell, circuit_t *circ) {
      * router twice in a row in the path. I think that's ok.
      */
     struct in_addr in;
+    char tmpbuf[INET_NTOA_BUF_LEN];
     in.s_addr = htonl(circ->n_addr);
+    tor_inet_ntoa(&in,tmpbuf,sizeof(tmpbuf));
     log_fn(LOG_INFO,"Next router (%s:%d) not connected. Connecting.",
-           inet_ntoa(in), circ->n_port);
+           tmpbuf, circ->n_port);
 
     memcpy(circ->onionskin, onionskin, ONIONSKIN_CHALLENGE_LEN);
     circ->state = CIRCUIT_STATE_OR_WAIT;

diff --git a/src/or/config.c b/src/or/config.c
index aeaa53817713b414b89eb44e41d39e840c5474d5..2e69de26024e3881b9ba47da1cd4afea62154bad 100644 (file)
--- a/src/or/config.c
+++ b/src/or/config.c
@@ -928,6 +928,7 @@ resolve_my_address(const char *address, uint32_t *addr)
   struct hostent *rent;
   char hostname[256];
   int explicit_ip=1;
+  char tmpbuf[INET_NTOA_BUF_LEN];
 
   tor_assert(addr);
 
@@ -957,14 +958,15 @@ resolve_my_address(const char *address, uint32_t *addr)
     memcpy(&in.s_addr, rent->h_addr, rent->h_length);
   }
 
+  tor_inet_ntoa(&in,tmpbuf,sizeof(tmpbuf));
   if (!explicit_ip && is_internal_IP(htonl(in.s_addr))) {
     log_fn(LOG_WARN,"Address '%s' resolves to private IP '%s'. "
            "Please set the Address config option to be the IP you want to use.",
-           hostname, inet_ntoa(in));
+           hostname, tmpbuf);
     return -1;
   }
 
-  log_fn(LOG_DEBUG, "Resolved Address to %s.", inet_ntoa(in));
+  log_fn(LOG_DEBUG, "Resolved Address to %s.", tmpbuf);
   *addr = ntohl(in.s_addr);
   return 0;
 }

diff --git a/src/or/connection.c b/src/or/connection.c
index bad34746c2499bd21aeea9e3c413867886b2cb01..ccf629179de42ce1e6d7884e2492887d4aad7164 100644 (file)
--- a/src/or/connection.c
+++ b/src/or/connection.c
@@ -462,6 +462,7 @@ static int connection_handle_listener_read(connection_t *conn, int new_type) {
   struct sockaddr_in remote;
   /* length of the remote address. Must be an int, since accept() needs that. */
   int remotelen = sizeof(struct sockaddr_in);
+  char tmpbuf[INET_NTOA_BUF_LEN];
 
   news = accept(conn->s,(struct sockaddr *)&remote,&remotelen);
   if (!SOCKET_IS_POLLABLE(news)) {
@@ -495,8 +496,9 @@ static int connection_handle_listener_read(connection_t *conn, int new_type) {
   if (new_type == CONN_TYPE_AP) {
     /* check sockspolicy to see if we should accept it */
     if (socks_policy_permits_address(ntohl(remote.sin_addr.s_addr)) == 0) {
+      tor_inet_ntoa(&remote.sin_addr, tmpbuf, sizeof(tmpbuf));
       log_fn(LOG_NOTICE,"Denying socks connection from untrusted address %s.",
-             inet_ntoa(remote.sin_addr));
+             tmpbuf);
       tor_close_socket(news);
       return 0;
     }
@@ -504,8 +506,9 @@ static int connection_handle_listener_read(connection_t *conn, int new_type) {
   if (new_type == CONN_TYPE_DIR) {
     /* check dirpolicy to see if we should accept it */
     if (dir_policy_permits_address(ntohl(remote.sin_addr.s_addr)) == 0) {
+      tor_inet_ntoa(&remote.sin_addr, tmpbuf, sizeof(tmpbuf));
       log_fn(LOG_NOTICE,"Denying dir connection from address %s.",
-             inet_ntoa(remote.sin_addr));
+             tmpbuf);
       tor_close_socket(news);
       return 0;
     }
@@ -514,7 +517,10 @@ static int connection_handle_listener_read(connection_t *conn, int new_type) {
   newconn = connection_new(new_type);
   newconn->s = news;
 
-  newconn->address = tor_strdup(inet_ntoa(remote.sin_addr)); /* remember the remote address */
+  /* remember the remote address */
+  newconn->address = tor_malloc(INET_NTOA_BUF_LEN);
+  tor_inet_ntoa(&remote.sin_addr, newconn->address, INET_NTOA_BUF_LEN);
+
   newconn->addr = ntohl(remote.sin_addr.s_addr);
   newconn->port = ntohs(remote.sin_port);
 

diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c
index 826a91fcc2ba542acff4e2dc2ed8dda6a4c0297d..632a93e497534c413c25100843e4b76163aa1836 100644 (file)
--- a/src/or/connection_edge.c
+++ b/src/or/connection_edge.c
@@ -482,13 +482,16 @@ int client_dns_incr_failures(const char *address)
 void client_dns_set_addressmap(const char *address, uint32_t val)
 {
   struct in_addr in;
+  char *addr;
 
   tor_assert(address); tor_assert(val);
 
   if (tor_inet_aton(address, &in))
     return; /* don't set an addressmap back to ourselves! */
   in.s_addr = htonl(val);
-  addressmap_register(address, strdup(inet_ntoa(in)),
+  addr = tor_malloc(INET_NTOA_BUF_LEN);
+  tor_inet_ntoa(&in,addr,INET_NTOA_BUF_LEN);
+  addressmap_register(address, addr,
                       time(NULL) + MAX_DNS_ENTRY_AGE);
 }
 
@@ -1109,11 +1112,13 @@ connection_exit_connect(connection_t *conn) {
           (r->port_min <= port) && (port <= r->port_max)) {
         struct in_addr in;
         if (r->is_redirect) {
+          char tmpbuf[INET_NTOA_BUF_LEN];
           addr = r->addr_dest;
           port = r->port_dest;
           in.s_addr = htonl(addr);
+          tor_inet_ntoa(&in, tmpbuf, sizeof(tmpbuf));
           log_fn(LOG_DEBUG, "Redirecting connection from %s:%d to %s:%d",
-                 conn->address, conn->port, inet_ntoa(in), port);
+                 conn->address, conn->port, tmpbuf, port);
         }
         break;
       }

diff --git a/src/or/connection_or.c b/src/or/connection_or.c
index aa0e624efc1ee6f9d8df3c0740823d8f251077fc..7286de869e9e1e10c2525f119a8352709387c898 100644 (file)
--- a/src/or/connection_or.c
+++ b/src/or/connection_or.c
@@ -157,7 +157,9 @@ connection_or_init_conn_from_address(connection_t *conn,
   }
   tor_free(conn->address);
   in.s_addr = htonl(addr);
-  conn->address = tor_strdup(inet_ntoa(in));
+
+  conn->address = tor_malloc(INET_NTOA_BUF_LEN);
+  tor_inet_ntoa(&in,conn->address,INET_NTOA_BUF_LEN);
 }
 
 void

diff --git a/src/or/cpuworker.c b/src/or/cpuworker.c
index 62a99d589f5e5abef2e8f4fbb8921052a8df3b15..5b65835ecc7a76a31040e2739b2d124eb8617768 100644 (file)
--- a/src/or/cpuworker.c
+++ b/src/or/cpuworker.c
@@ -67,13 +67,15 @@ static void tag_pack(char *tag, uint32_t addr, uint16_t port, uint16_t circ_id)
  */
 static void tag_unpack(const char *tag, uint32_t *addr, uint16_t *port, uint16_t *circ_id) {
   struct in_addr in;
+  char addrbuf[INET_NTOA_BUF_LEN];
 
   *addr    = *(const uint32_t *)tag;
   *port    = *(const uint16_t *)(tag+4);
   *circ_id = *(const uint16_t *)(tag+6);
 
   in.s_addr = htonl(*addr);
-  log_fn(LOG_DEBUG,"onion was from %s:%d, circ_id %d.", inet_ntoa(in), *port, *circ_id);
+  tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
+  log_fn(LOG_DEBUG,"onion was from %s:%d, circ_id %d.", addrbuf, *port, *circ_id);
 }
 
 /** Called when the onion key has changed and we need to spawn new

diff --git a/src/or/rendservice.c b/src/or/rendservice.c
index 10937609686ba85e8846841dc78444afa65cfcd2..f9c9c3e3780a4737435ad182b8d289d8ef303441 100644 (file)
--- a/src/or/rendservice.c
+++ b/src/or/rendservice.c
@@ -113,10 +113,12 @@ static void add_service(rend_service_t *service)
     smartlist_add(rend_service_list, service);
     log_fn(LOG_DEBUG,"Configuring service with directory %s",service->directory);
     for (i = 0; i < smartlist_len(service->ports); ++i) {
+      char addrbuf[INET_NTOA_BUF_LEN];
       p = smartlist_get(service->ports, i);
       addr.s_addr = htonl(p->real_address);
+      tor_inet_ntoa(&addr, addrbuf, sizeof(addrbuf));
       log_fn(LOG_DEBUG,"Service maps port %d to %s:%d",
-             p->virtual_port, inet_ntoa(addr), p->real_port);
+             p->virtual_port, addrbuf, p->real_port);
     }
   }
 }

diff --git a/src/or/router.c b/src/or/router.c
index 0cb45def30f49b2d061c8dc2c873d764f610ecfb..ebcf7b56c11009ea26edb88260cf0d7fb9caa944 100644 (file)
--- a/src/or/router.c
+++ b/src/or/router.c
@@ -541,6 +541,7 @@ int router_rebuild_descriptor(int force) {
   struct in_addr in;
   int hibernating = we_are_hibernating();
   or_options_t *options = get_options();
+  char addrbuf[INET_NTOA_BUF_LEN];
 
   if (!desc_is_dirty && !force)
     return 0;
@@ -552,7 +553,8 @@ int router_rebuild_descriptor(int force) {
 
   ri = tor_malloc_zero(sizeof(routerinfo_t));
   in.s_addr = htonl(addr);
-  ri->address = tor_strdup(inet_ntoa(in));
+  tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
+  ri->address = tor_strdup(addrbuf);
   ri->nickname = tor_strdup(options->Nickname);
   ri->addr = addr;
   ri->or_port = options->ORPort;
@@ -628,6 +630,7 @@ int router_dump_router_to_string(char *s, size_t maxlen, routerinfo_t *router,
   char published[32];
   char fingerprint[FINGERPRINT_LEN+1];
   struct in_addr in;
+  char addrbuf[INET_NTOA_BUF_LEN];
   size_t onion_pkeylen, identity_pkeylen;
   size_t written;
   int result=0;
@@ -729,16 +732,18 @@ int router_dump_router_to_string(char *s, size_t maxlen, routerinfo_t *router,
   for (tmpe=router->exit_policy; tmpe; tmpe=tmpe->next) {
     in.s_addr = htonl(tmpe->addr);
     /* Write: "accept 1.2.3.4" */
+    tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
     result = tor_snprintf(s+written, maxlen-written, "%s %s",
         tmpe->policy_type == ADDR_POLICY_ACCEPT ? "accept" : "reject",
-        tmpe->msk == 0 ? "*" : inet_ntoa(in));
+        tmpe->msk == 0 ? "*" : addrbuf);
     if (result < 0)
       return -1;
     written += result;
     if (tmpe->msk != 0xFFFFFFFFu && tmpe->msk != 0) {
       /* Write "/255.255.0.0" */
+      tor_inet_ntoa(&in, addrbuf, sizeof(addrbuf));
       in.s_addr = htonl(tmpe->msk);
-      result = tor_snprintf(s+written, maxlen-written, "/%s", inet_ntoa(in));
+      result = tor_snprintf(s+written, maxlen-written, "/%s", addrbuf);
       if (result<0)
         return -1;
       written += result;

diff --git a/src/or/routerparse.c b/src/or/routerparse.c
index 07ecf44cd4108c176073f31ff7335c4289362c61..0cb996c17bcbf58731ddfd4ee858fa26dc5f962f 100644 (file)
--- a/src/or/routerparse.c
+++ b/src/or/routerparse.c
@@ -1054,8 +1054,10 @@ static addr_policy_t *
 router_parse_addr_policy(directory_token_t *tok) {
 
   addr_policy_t *newe;
-  struct in_addr in;
-  char *arg, *address;
+//  struct in_addr in;
+  char *arg;
+//  char *address;
+//  char buf[INET_NTOA_BUF_LEN];
 
   tor_assert(tok->tp == K_REJECT || tok->tp == K_ACCEPT);
 
@@ -1076,13 +1078,14 @@ router_parse_addr_policy(directory_token_t *tok) {
                                 &newe->prt_min, &newe->prt_max))
     goto policy_read_failed;
 
-  in.s_addr = htonl(newe->addr);
-  address = tor_strdup(inet_ntoa(in));
+//  in.s_addr = htonl(newe->addr);
+//  tor_inet_ntoa(&in, buf, sizeof(buf));
+//  address = tor_strdup(buf);
 //  in.s_addr = htonl(newe->msk);
 //  log_fn(LOG_DEBUG,"%s %s/%s:%d-%d",
 //         newe->policy_type == ADDR_POLICY_REJECT ? "reject" : "accept",
 //         address, inet_ntoa(in), newe->prt_min, newe->prt_max);
-  tor_free(address);
+//  tor_free(address);
 
   return newe;
 

diff --git a/src/or/test.c b/src/or/test.c
index cf3505c0a88072f93bc412867896695329606fd2..a30d43e969a7218183bf3375c921c067049ffff8 100644 (file)
--- a/src/or/test.c
+++ b/src/or/test.c
@@ -791,6 +791,14 @@ test_util(void) {
   test_assert(strcmpend("abcdef", "dee")>0);
   test_assert(strcmpend("ab", "abb")<0);
 
+  {
+    char tmpbuf[INET_NTOA_BUF_LEN];
+    struct in_addr in;
+    tor_inet_aton("18.244.0.188",&in);
+    tor_inet_ntoa(&in, tmpbuf, sizeof(tmpbuf));
+    test_streq(tmpbuf, "18.244.0.188");
+  }
+
   /* XXXX test older functions. */
   smartlist_free(sl);
 }

diff --git a/src/tools/tor-resolve.c b/src/tools/tor-resolve.c
index 65a6300cfa1047cede06a0a37a621761ab75349f..090503045e190a9b4e064f36967d85450aa67ddf 100644 (file)
--- a/src/tools/tor-resolve.c
+++ b/src/tools/tor-resolve.c
@@ -174,6 +174,7 @@ main(int argc, char **argv)
   int n_args;
   struct in_addr a;
   uint32_t result;
+  char buf[INET_NTOA_BUF_LEN];
 
   arg = &argv[1];
   n_args = argc-1;
@@ -225,6 +226,7 @@ main(int argc, char **argv)
     return 1;
 
   a.s_addr = htonl(result);
-  printf("%s\n", inet_ntoa(a));
+  tor_inet_ntoa(&a, buf, sizeof(buf));
+  printf("%s\n", buf);
   return 0;
 }