Big cleanup in network address and dns functions:

  * removed t_fullhostent insanity
  * removed (struct sockaddr*) casts
  * use SOCaddr everywhere rather than raw struct hostent*

10 files changed, 199 insertions, 376 deletions

diff --git a/src/htsbasenet.h b/src/htsbasenet.h
index a9578c4..a752db5 100644
--- a/src/htsbasenet.h
+++ b/src/htsbasenet.h
@@ -54,12 +54,9 @@ Please visit our Website: http://www.httrack.com
 
 #endif
 
-typedef struct hostent FAR t_hostent;
-
 #else
 #define HTS_USESCOPEID
 #define INVALID_SOCKET -1
-typedef struct hostent t_hostent;
 #endif
 
 #if HTS_USEOPENSSL
diff --git a/src/htscatchurl.c b/src/htscatchurl.c
index 0ed89d5..e5da40b 100644
--- a/src/htscatchurl.c
+++ b/src/htscatchurl.c
@@ -77,40 +77,25 @@ HTSEXT_API T_SOC catch_url_init_std(int *port_prox, char *adr_prox) {
 // 1- Init the URL catcher
 
 // catch_url_init(&port,&return_host);
-HTSEXT_API T_SOC catch_url_init(int *port, char *adr) {
+HTSEXT_API T_SOC catch_url_init(int *port, /* 128 bytes */ char *adr) {
   T_SOC soc = INVALID_SOCKET;
-  char h_loc[256 + 2];
+  char h_loc[256];
 
-  if (gethostname(h_loc, 256) == 0) {   // host name
+  if (gethostname(h_loc, sizeof(h_loc)) == 0) {   // host name
     SOCaddr server;
-    int server_size = sizeof(server);
-    t_hostent *hp_loc;
-    t_fullhostent buffer;
-
-    // effacer structure
-    memset(&server, 0, sizeof(server));
-
-    if ((hp_loc = vxgethostbyname(h_loc, &buffer))) {   // notre host      
-
-      // copie adresse
-      SOCaddr_copyaddr(server, server_size, hp_loc->h_addr_list[0],
-                       hp_loc->h_length);
-
+    if (hts_dns_resolve_nocache(h_loc, &server) != NULL) {   // notre host
       if ((soc =
            (T_SOC) socket(SOCaddr_sinfamily(server), SOCK_STREAM,
                           0)) != INVALID_SOCKET) {
         SOCaddr_initport(server, *port);
-        if (bind(soc, (struct sockaddr *) &server, server_size) == 0) {
+        if (bind(soc, &SOCaddr_sockaddr(server), SOCaddr_size(server)) == 0) {
           SOCaddr server2;
-          SOClen len;
+          SOClen len = SOCaddr_capacity(server2);
 
-          len = sizeof(server2);
-          // effacer structure
-          memset(&server2, 0, sizeof(server2));
-          if (getsockname(soc, (struct sockaddr *) &server2, &len) == 0) {
+          if (getsockname(soc, &SOCaddr_sockaddr(server2), &len) == 0) {
             *port = ntohs(SOCaddr_sinport(server));     // récupérer port
-            if (listen(soc, 10) >= 0) { // au pif le 10
-              SOCaddr_inetntoa(adr, 128, server2, len);
+            if (listen(soc, 1) >= 0) {
+              SOCaddr_inetntoa(adr, 128, server2);
             } else {
 #ifdef _WIN32
               closesocket(soc);
@@ -168,14 +153,12 @@ HTSEXT_API int catch_url(T_SOC soc, char *url, char *method, char *data) {
     /* INFOS */
     {
       SOCaddr server2;
-      SOClen len = sizeof(server2);
+      SOClen len = SOCaddr_capacity(server2);
 
-      // effacer structure
-      memset(&server2, 0, sizeof(server2));
-      if (getpeername(soc, (struct sockaddr *) &server2, &len) == 0) {
+      if (getpeername(soc, &SOCaddr_sockaddr(server2), &len) == 0) {
         char dot[256 + 2];
 
-        SOCaddr_inetntoa(dot, 256, server2, sizeof(server2));
+        SOCaddr_inetntoa(dot, sizeof(dot), server2);
         sprintf(url, "%s:%d", dot, ntohs(SOCaddr_sinport(server2)));
       }
     }
diff --git a/src/htsftp.c b/src/htsftp.c
index 5ea7f82..34bb40f 100644
--- a/src/htsftp.c
+++ b/src/htsftp.c
@@ -147,7 +147,6 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
   int timeout_onfly = 8;        // attente réponse supplémentaire
   int transfer_list = 0;        // directory
   int rest_understood = 0;      // rest command understood
-  t_fullhostent fullhostent_buffer;     // buffer pour resolver
 
   //
   T_SOC soc_ctl = INVALID_SOCKET;
@@ -249,8 +248,6 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
   // connexion
   {
     SOCaddr server;
-    int server_size = sizeof(server);
-    t_hostent *hp;
     char *a;
     char _adr[256];
     const char *error = "unknown error";
@@ -270,8 +267,7 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
 
     // récupérer adresse résolue
     strcpybuff(back->info, "host name");
-    hp = hts_gethostbyname2(opt, _adr, &fullhostent_buffer, &error);
-    if (hp == NULL) {
+    if (hts_dns_resolve2(opt, _adr, &server, &error) == NULL) {
       snprintf(back->r.msg, sizeof(back->r.msg),
                "Unable to get server's address: %s", error);
       // back->status=STATUS_FTP_READY;    // fini
@@ -280,12 +276,8 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
     }
     _CHECK_HALT_FTP;
 
-    // copie adresse
-    SOCaddr_copyaddr(server, server_size, hp->h_addr_list[0], hp->h_length);
     // copie adresse pour cnx data
-    SOCaddr_copyaddr(server_data, server_data_size, hp->h_addr_list[0],
-                     hp->h_length);
-    // memcpy(&server.sin_addr, hp->h_addr, hp->h_length);
+    SOCaddr_copy_SOCaddr(server_data, server);
 
     // créer ("attachement") une socket (point d'accès) internet,en flot
     soc_ctl = (T_SOC) socket(SOCaddr_sinfamily(server), SOCK_STREAM, 0);
@@ -302,12 +294,7 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
     // connexion (bloquante, on est en thread)
     strcpybuff(back->info, "connect");
 
-#ifdef _WIN32
-    if (connect(soc_ctl, (const struct sockaddr FAR *) &server, server_size) !=
-        0) {
-#else
-    if (connect(soc_ctl, (struct sockaddr *) &server, server_size) == -1) {
-#endif
+    if (connect(soc_ctl, &SOCaddr_sockaddr(server), SOCaddr_size(server)) != 0) {
       strcpybuff(back->r.msg, "Unable to connect to the server");
       // back->status=STATUS_FTP_READY;    // fini
       back->r.statuscode = STATUSCODE_INVALID;
@@ -419,7 +406,7 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
         // Pré-REST
         //
 #if FTP_PASV
-        if (SOCaddr_getproto(server, server_size) == '1') {
+        if (SOCaddr_getproto(server) == '1') {
           strcpybuff(back->info, "pasv");
           snprintf(line, sizeof(line), "PASV");
           send_line(soc_ctl, line);
@@ -581,7 +568,6 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
         if (port_pasv) {
           SOCaddr server;
           int server_size = sizeof(server);
-          t_hostent *hp;
           const char *error = "unknown error";
 
           // effacer structure
@@ -592,16 +578,9 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
 
           // résoudre
           if (adr_ip[0]) {
-            hp = hts_gethostbyname2(opt, adr_ip, &fullhostent_buffer, &error);
-            if (hp) {
-              SOCaddr_copyaddr(server, server_size, hp->h_addr_list[0],
-                               hp->h_length);
-            } else {
-              server_size = 0;
-            }
+            hts_dns_resolve2(opt, adr_ip, &server, &error);
           } else {
-            memcpy(&server, &server_data, sizeof(server_data));
-            server_size = server_data_size;
+            SOCaddr_copy_SOCaddr(server, server_data);
           }
 
           // infos
@@ -615,15 +594,7 @@ int run_launch_ftp(FTPDownloadStruct * pStruct) {
             if (soc_dat != INVALID_SOCKET) {
               // structure: connexion au domaine internet, port 80 (ou autre)
               SOCaddr_initport(server, port_pasv);
-              // server.sin_port = htons((unsigned short int) port_pasv);
-#ifdef _WIN32
-              if (connect
-                  (soc_dat, (const struct sockaddr FAR *) &server,
-                   server_size) == 0) {
-#else
-              if (connect(soc_dat, (struct sockaddr *) &server, server_size) !=
-                  -1) {
-#endif
+              if (connect(soc_dat, &SOCaddr_sockaddr(server), SOCaddr_size(server)) == 0) {
                 strcpybuff(back->info, "retr");
                 strcpybuff(line, line_retr);
                 send_line(soc_ctl, line);
@@ -856,33 +827,19 @@ T_SOC get_datasocket(char *to_send, size_t to_send_size) {
   to_send[0] = '\0';
   if (gethostname(h_loc, 256) == 0) {   // host name
     SOCaddr server;
-    int server_size = sizeof(server);
-    t_hostent *hp_loc;
-    t_fullhostent buffer;
-
-    // effacer structure
-    memset(&server, 0, sizeof(server));
-
-    if ((hp_loc = vxgethostbyname(h_loc, &buffer))) {   // notre host
-
-      // copie adresse
-      SOCaddr_copyaddr(server, server_size, hp_loc->h_addr_list[0],
-                       hp_loc->h_length);
 
+    if (hts_dns_resolve_nocache(h_loc, &server) != NULL) {   // notre host
       if ((soc =
            (T_SOC) socket(SOCaddr_sinfamily(server), SOCK_STREAM,
                           0)) != INVALID_SOCKET) {
 
-        if (bind(soc, (struct sockaddr *) &server, server_size) == 0) {
+        if (bind(soc, &SOCaddr_sockaddr(server), SOCaddr_size(server)) == 0) {
           SOCaddr server2;
-          SOClen len;
+          SOClen len = SOCaddr_capacity(server2);
 
-          len = sizeof(server2);
-          // effacer structure
-          memset(&server2, 0, sizeof(server2));
-          if (getsockname(soc, (struct sockaddr *) &server2, &len) == 0) {
+          if (getsockname(soc, &SOCaddr_sockaddr(server2), &len) == 0) {
             // *port=ntohs(server.sin_port);  // récupérer port
-            if (listen(soc, 10) >= 0) { // au pif le 10
+            if (listen(soc, 1) >= 0) {
 #if HTS_INET6==0
               unsigned short int a, n1, n2;
 
@@ -895,7 +852,7 @@ T_SOC get_datasocket(char *to_send, size_t to_send_size) {
                 char dot[256 + 2];
                 char *a;
 
-                SOCaddr_inetntoa(dot, 256, server2, sizeof(server2));
+                SOCaddr_inetntoa(dot, 256, server2);
                 //
                 dots[0] = '\0';
                 strncatbuff(dots, dot, 128);
@@ -913,9 +870,9 @@ T_SOC get_datasocket(char *to_send, size_t to_send_size) {
               {
                 char dot[256 + 2];
 
-                SOCaddr_inetntoa(dot, 256, server2, len);
+                SOCaddr_inetntoa(dot, 256, server2);
                 snprintf(to_send, to_send_size, "EPRT |%c|%s|%d|",
-                         SOCaddr_getproto(server2, len), dot,
+                         SOCaddr_getproto(server2), dot,
                          SOCaddr_sinport(server2));
               }
 #endif
@@ -1093,7 +1050,7 @@ int check_socket(T_SOC soc) {
   tv.tv_sec = 0;
   tv.tv_usec = 0;
   // poll!     
-  select(soc + 1, &fds, NULL, &fds_e, &tv);
+  select((int) soc + 1, &fds, NULL, &fds_e, &tv);
   if (FD_ISSET(soc, &fds_e)) {  // error detected
     return -1;
   } else if (FD_ISSET(soc, &fds)) {
@@ -1116,7 +1073,7 @@ int check_socket_connect(T_SOC soc) {
   tv.tv_sec = 0;
   tv.tv_usec = 0;
   // poll!     
-  select(soc + 1, NULL, &fds, &fds_e, &tv);
+  select((int) soc + 1, NULL, &fds, &fds_e, &tv);
   if (FD_ISSET(soc, &fds_e)) {  // error detected
     return -1;
   } else if (FD_ISSET(soc, &fds)) {
diff --git a/src/htslib.c b/src/htslib.c
index fdd080e..886d8e3 100644
--- a/src/htslib.c
+++ b/src/htslib.c
@@ -2126,27 +2126,16 @@ htsblk http_test(httrackp * opt, char *adr, char *fil, char *loc) {
 // peut ouvrir avec des connect() non bloquants: waitconnect=0/1
 T_SOC newhttp(httrackp * opt, const char *_iadr, htsblk * retour, int port,
               int waitconnect) {
-  t_fullhostent fullhostent_buffer;     // buffer pour resolver
   T_SOC soc;                    // descipteur de la socket
-  char *iadr;
 
-  // unsigned short int port;
-
-  // si iadr="#" alors c'est une fausse URL, mais un vrai fichier
-  // local.
-  // utile pour les tests!
-  //## if (iadr[0]!=lOCAL_CHAR) {
   if (strcmp(_iadr, "file://") != 0) {  /* non fichier */
     SOCaddr server;
-    int server_size = sizeof(server);
-    t_hostent *hp;
     const char *error = "unknown error";
 
-    // effacer structure
-    memset(&server, 0, sizeof(server));
-
     // tester un éventuel id:pass et virer id:pass@ si détecté
-    iadr = jump_identification(_iadr);
+    const char *const iadr = jump_identification(_iadr);
+
+    SOCaddr_clear(server);
 
 #if HDEBUG
     printf("gethostbyname\n");
@@ -2164,7 +2153,8 @@ T_SOC newhttp(httrackp * opt, const char *_iadr, htsblk * retour, int port,
 #else
       port = 80;                // port par défaut
 #endif
-      if (a) {
+
+      if (a != NULL) {
         char BIGSTK iadr2[HTS_URLMAXSIZE * 2];
         int i = -1;
 
@@ -2173,25 +2163,24 @@ T_SOC newhttp(httrackp * opt, const char *_iadr, htsblk * retour, int port,
         if (i != -1) {
           port = (unsigned short int) i;
         }
+
         // adresse véritable (sans :xx)
         strncatbuff(iadr2, iadr, (int) (a - iadr));
 
         // adresse sans le :xx
-        hp = hts_gethostbyname2(opt, iadr2, &fullhostent_buffer, &error);
+        hts_dns_resolve2(opt, iadr2, &server, &error);
 
       } else {
 
         // adresse normale (port par défaut par la suite)
-        hp = hts_gethostbyname2(opt, iadr, &fullhostent_buffer, &error);
+        hts_dns_resolve2(opt, iadr, &server, &error);
       }
 
-    } else                      // port défini
-      hp = hts_gethostbyname2(opt, iadr, &fullhostent_buffer, &error);
+    } else {                    // port défini
+      hts_dns_resolve2(opt, iadr, &server, &error);
+    }
 
-    // Conversion iadr -> adresse
-    // structure recevant le nom de l'hôte, etc
-    //struct    hostent         *hp;
-    if (hp == NULL) {
+    if (!SOCaddr_is_valid(server)) {
 #if DEBUG
       printf("erreur gethostbyname\n");
 #endif
@@ -2206,13 +2195,10 @@ T_SOC newhttp(httrackp * opt, const char *_iadr, htsblk * retour, int port,
       }
       return INVALID_SOCKET;
     }
-    // copie adresse
-    SOCaddr_copyaddr(server, server_size, hp->h_addr_list[0], hp->h_length);
+
     // make a copy for external clients
-    retour->address_size = sizeof(retour->address);
-    SOCaddr_copyaddr(retour->address, retour->address_size, hp->h_addr_list[0],
-                     hp->h_length);
-    // memcpy(&SOCaddr_sinaddr(server), hp->h_addr_list[0], hp->h_length);
+    SOCaddr_copy_SOCaddr(retour->address, server);
+    retour->address_size = SOCaddr_size(retour->address);
 
     // créer ("attachement") une socket (point d'accès) internet,en flot
 #if HDEBUG
@@ -2246,14 +2232,13 @@ T_SOC newhttp(httrackp * opt, const char *_iadr, htsblk * retour, int port,
     }
     // bind this address
     if (retour != NULL && strnotempty(retour->req.proxy.bindhost)) {
-      t_fullhostent bind_buffer;
       const char *error = "unknown error";
+      SOCaddr bind_addr;
 
-      hp = hts_gethostbyname2(opt, retour->req.proxy.bindhost, &bind_buffer,
-                              &error);
-      if (hp == NULL
-          || bind(soc, (struct sockaddr *) hp->h_addr_list[0],
-                  hp->h_length) != 0) {
+      if (hts_dns_resolve2(opt, retour->req.proxy.bindhost,
+                             &bind_addr, &error) == NULL
+          || bind(soc, &SOCaddr_sockaddr(bind_addr), 
+                  SOCaddr_size(bind_addr)) != 0) {
         if (retour && retour->msg) {
 #ifdef _WIN32
           snprintf(retour->msg, sizeof(retour->msg),
@@ -2305,25 +2290,20 @@ T_SOC newhttp(httrackp * opt, const char *_iadr, htsblk * retour, int port,
 #if HTS_WIDE_DEBUG
     DEBUG_W("connect\n");
 #endif
-#ifdef _WIN32
-    if (connect(soc, (const struct sockaddr FAR *) &server, server_size) != 0) {
-#else
-    if (connect(soc, (struct sockaddr *) &server, server_size) == -1) {
-#endif
-
+    if (connect(soc, &SOCaddr_sockaddr(server), SOCaddr_size(server)) != 0) {
       // bloquant
       if (waitconnect) {
 #if HDEBUG
         printf("unable to connect!\n");
 #endif
-        if (retour && retour->msg) {
+        if (retour != NULL && retour->msg) {
 #ifdef _WIN32
-          int last_errno = WSAGetLastError();
+          const int last_errno = WSAGetLastError();
 
           sprintf(retour->msg, "Unable to connect to the server: %s",
                   strerror(last_errno));
 #else
-          int last_errno = errno;
+          const int last_errno = errno;
 
           sprintf(retour->msg, "Unable to connect to the server: %s",
                   strerror(last_errno));
@@ -2991,7 +2971,7 @@ int sendc(htsblk * r, const char *s) {
 }
 
 // Remplace read
-int finput(int fd, char *s, int max) {
+int finput(T_SOC fd, char *s, int max) {
   char c;
   int j = 0;
 
@@ -4568,7 +4548,6 @@ int hts_read(htsblk * r, char *buff, int size) {
 
 // -- Gestion cache DNS --
 // 'RX98
-#if HTS_DNSCACHE
 
 // 'capsule' contenant uniquement le cache
 t_dnscache *_hts_cache(httrackp * opt) {
@@ -4602,63 +4581,47 @@ void hts_cache_free(t_dnscache *const root) {
 // routine pour le cache - retour optionnel à donner à chaque fois
 // NULL: nom non encore testé dans le cache
 // si h_length==0 alors le nom n'existe pas dans le dns
-static t_hostent *hts_ghbn(const t_dnscache *cache, const char *const iadr, t_hostent *retour) {
+static SOCaddr* hts_ghbn(const t_dnscache *cache, const char *const iadr, SOCaddr *const addr) {
+  assertf(addr != NULL);
   for(; cache != NULL; cache = cache->n) {
     assertf(cache != NULL);
     assertf(iadr != NULL);
     if (cache->iadr != NULL && strcmp(cache->iadr, iadr) == 0) {       // ok trouvé
       if (cache->host_length > 0) {     // entrée valide
-        if (retour->h_addr_list[0])
-          memcpy(retour->h_addr_list[0], cache->host_addr, cache->host_length);
-        retour->h_length = cache->host_length;
+        SOCaddr_copyaddr2(*addr, cache->host_addr, cache->host_length);
+        return addr;
       } else if (cache->host_length == 0) {     // en cours
         return NULL;
       } else {                  // erreur dans le dns, déja vérifié
-        if (retour->h_addr_list[0])
-          retour->h_addr_list[0][0] = '\0';
-        retour->h_length = 0;   // erreur, n'existe pas
+        SOCaddr_clear(*addr);
+        return addr;
       }
-      return retour;
     }
   }
   return NULL;
 }
 
-static t_hostent *vxgethostbyname2_(const char *const hostname,
-                                    void *const v_buffer, const char **error) {
-  t_fullhostent *buffer = (t_fullhostent *) v_buffer;
-
-  /* Clear */
-  fullhostent_init(buffer);
-
+static SOCaddr* hts_dns_resolve_nocache2_(const char *const hostname,
+                                          SOCaddr *const addr, 
+                                          const char **error) {
   {
 #if HTS_INET6==0
-    /*
-       ipV4 resolver
-     */
-    t_hostent *hp = gethostbyname(hostname);
+    /* IPv4 resolver */
+    struct hostent *const hp = gethostbyname(hostname);
 
     if (hp != NULL) {
-      if ((hp->h_length)
-          && (((unsigned int) hp->h_length) <= buffer->addr_maxlen)) {
-        memcpy(buffer->hp.h_addr_list[0], hp->h_addr_list[0], hp->h_length);
-        buffer->hp.h_length = hp->h_length;
-        return &(buffer->hp);
-      }
+      SOCaddr_copyaddr2(addr, hp->h_addr_list[0], hp->h_length);
+      return SOCaddr_is_valid(addr) ? &addr : NULL;
+    } else {
+      SOCaddr_clear(*addr);
     }
 #else
-    /*
-       ipV6 resolver
-     */
-    /*
-       int error_num=0;
-       t_hostent* hp=getipnodebyname(hostname, AF_INET6, AI_DEFAULT, &error_num);
-       oops, deprecated :(
-     */
+    /* IPv6 resolver */
     struct addrinfo *res = NULL;
     struct addrinfo hints;
     int gerr;
 
+    SOCaddr_clear(*addr);
     memset(&hints, 0, sizeof(hints));
     if (IPV6_resolver == 1)     // V4 only (for bogus V6 entries)
       hints.ai_family = PF_INET;
@@ -4669,13 +4632,9 @@ static t_hostent *vxgethostbyname2_(const char *const hostname,
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;
     if ( ( gerr = getaddrinfo(hostname, NULL, &hints, &res) ) == 0) {
-      if (res) {
-        if ((res->ai_addr) && (res->ai_addrlen)
-            && (res->ai_addrlen <= buffer->addr_maxlen)) {
-          memcpy(buffer->hp.h_addr_list[0], res->ai_addr, res->ai_addrlen);
-          buffer->hp.h_length = (short) res->ai_addrlen;
-          freeaddrinfo(res);
-          return &(buffer->hp);
+      if (res != NULL) {
+        if (res->ai_addr != NULL && res->ai_addrlen != 0) {
+          SOCaddr_copyaddr2(*addr, res->ai_addr, res->ai_addrlen);
         }
       }
     } else {
@@ -4688,11 +4647,12 @@ static t_hostent *vxgethostbyname2_(const char *const hostname,
     }
 #endif
   }
-  return NULL;
+
+  return SOCaddr_is_valid(*addr) ? addr : NULL;
 }
 
-HTSEXT_API t_hostent *vxgethostbyname2(const char *const hostname, 
-                                       void *const v_buffer, const char **error) {
+HTSEXT_API SOCaddr* hts_dns_resolve_nocache2(const char *const hostname, 
+                                     SOCaddr *const addr, const char **error) {
   /* Protection */
   if (!strnotempty(hostname)) {
     return NULL;
@@ -4703,43 +4663,40 @@ HTSEXT_API t_hostent *vxgethostbyname2(const char *const hostname,
      The resolver doesn't seem to handle IP6 addresses in brackets
    */
   if ((hostname[0] == '[') && (hostname[strlen(hostname) - 1] == ']')) {
-    t_hostent *ret;
+    SOCaddr *ret;
     size_t size = strlen(hostname);
     char *copy = malloct(size + 1);
     assertf(copy != NULL);
     copy[0] = '\0';
     strncat(copy, hostname + 1, size - 2);
-    ret =  vxgethostbyname2_(copy, v_buffer, error);
+    ret =  hts_dns_resolve_nocache2_(copy, addr, error);
     freet(copy);
     return ret;
   } else {
-    return vxgethostbyname2_(hostname, v_buffer, error);
+    return hts_dns_resolve_nocache2_(hostname, addr, error);
   }
 }
 
-HTSEXT_API t_hostent *vxgethostbyname(const char *const hostname, void *v_buffer) {
-  return vxgethostbyname2(hostname, v_buffer, NULL);
+HTSEXT_API SOCaddr* hts_dns_resolve_nocache(const char *const hostname, SOCaddr *const addr) {
+  return hts_dns_resolve_nocache2(hostname, addr, NULL);
 }
 
 HTSEXT_API int check_hostname_dns(const char *const hostname) {
-  t_fullhostent buffer;
-  return vxgethostbyname(hostname, &buffer) != NULL;
+  SOCaddr buffer;
+  return hts_dns_resolve_nocache(hostname, &buffer) != NULL;
 }
 
 // Needs locking
 // cache dns interne à HTS // ** FREE A FAIRE sur la chaine
-static t_hostent *hts_gethostbyname_(httrackp * opt, const char *_iadr, void *v_buffer, const char **error) {
+static SOCaddr* hts_dns_resolve_(httrackp * opt, const char *_iadr,
+                                   SOCaddr *const addr, const char **error) {
   char BIGSTK iadr[HTS_URLMAXSIZE * 2];
-  t_fullhostent *buffer = (t_fullhostent *) v_buffer;
   t_dnscache *cache = _hts_cache(opt);  // adresse du cache
-  t_hostent *hp;
+  SOCaddr *sa;
 
   assertf(opt != NULL);
   assertf(_iadr != NULL);
-  assertf(v_buffer != NULL);
-
-  /* Clear */
-  fullhostent_init(buffer);
+  assertf(addr != NULL);
 
   strcpybuff(iadr, jump_identification(_iadr));
   // couper éventuel :
@@ -4751,91 +4708,55 @@ static t_hostent *hts_gethostbyname_(httrackp * opt, const char *_iadr, void *v_
   }
 
   /* get IP from the dns cache */
-  hp = hts_ghbn(cache, iadr, &buffer->hp);
-  if (hp) {
-    if (hp->h_length > 0)
-      return hp;
-    else
-      return NULL;              // entrée erronée (erreur DNS) dans le DNS
+  sa = hts_ghbn(cache, iadr, addr);
+  if (sa != NULL) {
+    return SOCaddr_is_valid(*sa) ? sa : NULL;
   } else {                      // non présent dans le cache dns, tester
     // find queue
     for(; cache->n != NULL; cache = cache->n) ;
 
-#if HTS_WIDE_DEBUG
-    DEBUG_W("gethostbyname\n");
-#endif
-#if HDEBUG
-    printf("gethostbyname (not in cache)\n");
-#endif
-    {
-      unsigned long inetaddr;
-
-#ifdef _WIN32
-      if ((inetaddr = inet_addr(iadr)) == INADDR_NONE) {
-#else
-      if ((inetaddr = inet_addr(iadr)) == (in_addr_t) - 1) {
-#endif
 #if DEBUGDNS
-        printf("resolving (not cached) %s\n", iadr);
+    printf("resolving (not cached) %s\n", iadr);
 #endif
-        hp = vxgethostbyname2(iadr, buffer, error);     // calculer IP host
-      } else {                  // numérique, convertir sans passer par le dns
-        buffer->hp.h_addr_list[0] = (char *) &inetaddr;
-        buffer->hp.h_length = 4;
-        hp = &buffer->hp;
-      }
-    }
+
+    sa = hts_dns_resolve_nocache2(iadr, addr, error);     // calculer IP host
+
 #if HTS_WIDE_DEBUG
     DEBUG_W("gethostbyname done\n");
 #endif
+
+    /* attempt to store new entry */
     cache->n = (t_dnscache *) calloct(1, sizeof(t_dnscache));
     if (cache->n != NULL) {
       strcpybuff(cache->n->iadr, iadr);
-      if (hp != NULL) {
-        memcpy(cache->n->host_addr, hp->h_addr_list[0], hp->h_length);
-        cache->n->host_length = hp->h_length;
+      if (sa != NULL) {
+        cache->n->host_length = SOCaddr_size(*sa);
+        assertf(cache->n->host_length < sizeof(cache->n->host_addr));
+        memcpy(cache->n->host_addr, &SOCaddr_sockaddr(*sa), cache->n->host_length);
       } else {
         cache->n->host_addr[0] = '\0';
         cache->n->host_length = 0;      // non existant dans le dns
       }
       cache->n->n = NULL;
-      return hp;
-    } else {                    // on peut pas noter, mais on peut renvoyer le résultat
-      return hp;
+      return sa;
     }
+
+    /* return result if any */
+    return sa;
   }                             // retour hp du cache
 }
 
-t_hostent *hts_gethostbyname2(httrackp * opt, const char *_iadr, void *v_buffer, const char **error) {
-  t_hostent *ret;
+SOCaddr* hts_dns_resolve2(httrackp * opt, const char *_iadr, SOCaddr *const addr, const char **error) {
+  SOCaddr *ret;
   hts_mutexlock(&opt->state.lock);
-  ret = hts_gethostbyname_(opt, _iadr, v_buffer, error);
+  ret = hts_dns_resolve_(opt, _iadr, addr, error);
   hts_mutexrelease(&opt->state.lock);
   return ret;
 }
 
-t_hostent *hts_gethostbyname(httrackp * opt, const char *_iadr, void *v_buffer) {
-  return hts_gethostbyname2(opt ,_iadr, v_buffer, NULL);
-}
-
-#else
-static HTS_INLINE t_hostent *hts_gethostbyname(httrackp * opt, char *iadr,
-                                               t_fullhostent * buffer) {
-  t_hostent *retour;
-
-#if HTS_WIDE_DEBUG
-  DEBUG_W("gethostbyname (2)\n");
-#endif
-#if DEBUGDNS
-  printf("blocking method gethostbyname() in progress for %s\n", iadr);
-#endif
-  retour = vxgethostbyname(jump_identification(iadr),);
-#if HTS_WIDE_DEBUG
-  DEBUG_W("gethostbyname (2) done\n");
-#endif
-  return retour;
+SOCaddr* hts_dns_resolve(httrackp * opt, const char *_iadr, SOCaddr *const addr) {
+  return hts_dns_resolve2(opt, _iadr, addr, NULL);
 }
-#endif
 
 // --- Tracage des mallocs() ---
 #ifdef HTS_TRACE_MALLOC
diff --git a/src/htslib.h b/src/htslib.h
index 2b75dc4..7139cbe 100644
--- a/src/htslib.h
+++ b/src/htslib.h
@@ -158,7 +158,7 @@ struct htsblk {
   short int is_file;            // ce n'est pas une socket mais un descripteur de fichier si 1
   T_SOC soc;                    // ID socket
   SOCaddr address;              // IP address
-  int address_size;             // IP address structure length
+  int address_size;             // IP address structure length (unused internally)
   FILE *fp;                     // fichier pour file://
 #if HTS_USEOPENSSL
   short int ssl;                // is this connection a SSL one? (https)
@@ -273,12 +273,16 @@ void treatfirstline(htsblk * retour, char *rcvd);
 
 // sous-fonctions
 LLint http_xfread1(htsblk * r, int bufl);
-HTS_INLINE t_hostent *hts_gethostbyname2(httrackp * opt, const char *iadr,
-                                        void *v_buffer, const char **error);
-HTS_INLINE t_hostent *hts_gethostbyname(httrackp * opt, const char *iadr,
-                                        void *v_buffer);
-HTSEXT_API t_hostent *vxgethostbyname2(const char *const hostname, void *v_buffer, const char **error);
-HTSEXT_API t_hostent *vxgethostbyname(const char *const hostname, void *v_buffer);
+HTS_INLINE SOCaddr* hts_dns_resolve2(httrackp * opt, const char *iadr,
+                                     SOCaddr *const addr, 
+                                     const char **error);
+HTS_INLINE SOCaddr* hts_dns_resolve(httrackp * opt, const char *iadr,
+                                    SOCaddr *const addr);
+HTSEXT_API SOCaddr* hts_dns_resolve_nocache2(const char *const hostname, 
+                                              SOCaddr *const addr,
+                                              const char **error);
+HTSEXT_API SOCaddr* hts_dns_resolve_nocache(const char *const hostname, 
+                                             SOCaddr *const addr);
 HTSEXT_API int check_hostname_dns(const char *const hostname);
 
 int ftp_available(void);
@@ -303,7 +307,7 @@ HTS_INLINE void time_rfc822(char *s, struct tm *A);
 HTS_INLINE void time_rfc822_local(char *s, struct tm *A);
 
 HTS_INLINE int sendc(htsblk * r, const char *s);
-int finput(int fd, char *s, int max);
+int finput(T_SOC fd, char *s, int max);
 int binput(char *buff, char *s, int max);
 int linput(FILE * fp, char *s, int max);
 int linputsoc(T_SOC soc, char *s, int max);
diff --git a/src/htsname.c b/src/htsname.c
index 892324e..8e25e2e 100644
--- a/src/htsname.c
+++ b/src/htsname.c
@@ -1697,9 +1697,9 @@ void url_savename_refname(const char *adr, const char *fil, char *filename) {
   MD5_CTX ctx;
 
   MD5Init(&ctx, 0);
-  MD5Update(&ctx, (const unsigned char *) adr, strlen(adr));
+  MD5Update(&ctx, (const unsigned char *) adr, (int) strlen(adr));
   MD5Update(&ctx, (const unsigned char *) ",", 1);
-  MD5Update(&ctx, (const unsigned char *) fil, strlen(fil));
+  MD5Update(&ctx, (const unsigned char *) fil, (int) strlen(fil));
   MD5Final(bindigest, &ctx);
   sprintf(filename,
           CACHE_REFNAME "/" "%02x%02x%02x%02x%02x%02x%02x%02x"
diff --git a/src/htsnet.h b/src/htsnet.h
index 0cd6da3..fa143a4 100644
--- a/src/htsnet.h
+++ b/src/htsnet.h
@@ -135,10 +135,20 @@ static HTS_INLINE HTS_UNUSED socklen_t SOCaddr_size_(const SOCaddr*const addr,
   }
 }
 
+static HTS_INLINE HTS_UNUSED void SOCaddr_clear_(SOCaddr*const addr,
+                                                 const char *file, const int line) {
+  assertf_(addr != NULL, file, line);
+  addr->m_addr.sa.sa_family = AF_UNSPEC;
+}
+
 /* Ipv4/6 structure members */
 #define SOCaddr_sinfamily(server)   ((server).m_addr.sa.sa_family)
 #define SOCaddr_sinport(server)     (*SOCaddr_sinport_(&(server), __FILE__, __LINE__))
-#define SOCaddr_size(server)        (*SOCaddr_size_(&(server, __FILE__, __LINE__)))
+#define SOCaddr_size(server)        (SOCaddr_size_(&(server), __FILE__, __LINE__))
+#define SOCaddr_is_valid(server)    (SOCaddr_size_(&(server), __FILE__, __LINE__) != 0 )
+#define SOCaddr_clear(server)       SOCaddr_clear_(&(server), __FILE__, __LINE__)
+#define SOCaddr_sockaddr(server)    ((server).m_addr.sa)
+#define SOCaddr_capacity(server)    sizeof((server).m_addr)
 
 /* AF_xx */
 #if HTS_INET6 != 0
@@ -160,8 +170,8 @@ static HTS_INLINE HTS_UNUSED socklen_t SOCaddr_initany_(SOCaddr*const addr,
   return SOCaddr_size_(addr, file, line);
 }
 
-#define SOCaddr_initany(server, server_len) do { \
-  server_len = (int) SOCaddr_initany_(&(server), __FILE__, __LINE__); \
+#define SOCaddr_initany(server) do { \
+  SOCaddr_initany_(&(server), __FILE__, __LINE__); \
 } while(0)
 
 /*
@@ -203,6 +213,14 @@ static HTS_UNUSED socklen_t SOCaddr_copyaddr_(SOCaddr*const server,
   server_len = (int) SOCaddr_copyaddr_(&(server), hpaddr, hpsize, __FILE__, __LINE__); \
 } while(0)
 
+#define SOCaddr_copyaddr2(server, hpaddr, hpsize) do { \
+  (void) SOCaddr_copyaddr_(&(server), hpaddr, hpsize, __FILE__, __LINE__); \
+} while(0)
+
+#define SOCaddr_copy_SOCaddr(dest, src) do { \
+  SOCaddr_copyaddr_(&(dest), &(src).m_addr.sa, SOCaddr_size(src), __FILE__, __LINE__); \
+} while(0)
+
 /* Get dotted address */
 
 static HTS_UNUSED void SOCaddr_inetntoa_(char *namebuf, size_t namebuflen, 
@@ -225,34 +243,13 @@ static HTS_UNUSED void SOCaddr_inetntoa_(char *namebuf, size_t namebuflen,
   }
 }
 
-#define SOCaddr_inetntoa(namebuf, namebuflen, ss, sslen) \
+#define SOCaddr_inetntoa(namebuf, namebuflen, ss) \
   SOCaddr_inetntoa_(namebuf, namebuflen, &(ss), __FILE__, __LINE__)
 
 /* Get protocol ID */
-#define SOCaddr_getproto(ss, sslen) ( (sslen) == sizeof(struct sockaddr_in) ? '1' : '2')
+#define SOCaddr_getproto(ss) ( SOCaddr_size(ss) == sizeof(struct sockaddr_in) ? '1' : '2')
 
 /* Socket length type */
 typedef socklen_t SOClen;
 
-/* Buffer structure to copy various hostent structures */
-#ifndef HTS_DEF_FWSTRUCT_t_fullhostent
-#define HTS_DEF_FWSTRUCT_t_fullhostent
-typedef struct t_fullhostent t_fullhostent;
-#endif
-struct t_fullhostent {
-  t_hostent hp;
-  char *list[2];
-  char addr[HTS_MAXADDRLEN];    /* various struct sockaddr structures */
-  unsigned int addr_maxlen;
-};
-
-/* Initialize a t_fullhostent structure */
-#define fullhostent_init(h) do { \
-memset((h), 0, sizeof(t_fullhostent)); \
-(h)->hp.h_addr_list = (char **) & ((h)->list); \
-(h)->list[0] = (char *) & ((h)->addr); \
-(h)->list[1] = NULL; \
-(h)->addr_maxlen = HTS_MAXADDRLEN; \
-} while(0)
-
 #endif
diff --git a/src/htsserver.c b/src/htsserver.c
index 65329f3..22db179 100644
--- a/src/htsserver.c
+++ b/src/htsserver.c
@@ -162,16 +162,15 @@ T_SOC smallserver_init_std(int *port_prox, char *adr_prox, int defaultPort) {
 // 1- Init the URL catcher
 
 // get hostname. return 1 upon success.
-static int gethost(const char *hostname, SOCaddr * server, size_t server_size) {
+static int gethost(const char *hostname, SOCaddr * server) {
   if (hostname != NULL && *hostname != '\0') {
 #if HTS_INET6==0
     /* ipV4 resolver */
-    t_hostent *hp = gethostbyname(hostname);
+    struct hostent *hp = gethostbyname(hostname);
 
     if (hp != NULL) {
       if (hp->h_length) {
-        SOCaddr_copyaddr(*server, server_size, hp->h_addr_list[0],
-          hp->h_length);
+        SOCaddr_copyaddr2(*server, hp->h_addr_list[0], hp->h_length);
         return 1;
       }
     }
@@ -187,7 +186,7 @@ static int gethost(const char *hostname, SOCaddr * server, size_t server_size) {
     if (getaddrinfo(hostname, NULL, &hints, &res) == 0) {
       if (res) {
         if ((res->ai_addr) && (res->ai_addrlen)) {
-          SOCaddr_copyaddr(*server, server_size, res->ai_addr, res->ai_addrlen);
+          SOCaddr_copyaddr2(*server, res->ai_addr, res->ai_addrlen);
           freeaddrinfo(res);
           return 1;
         }
@@ -204,7 +203,7 @@ static int gethost(const char *hostname, SOCaddr * server, size_t server_size) {
 static int my_getlocalhost(char *h_loc, size_t size) {
   SOCaddr addr;
   strcpy(h_loc, "localhost");
-  if (gethost(h_loc, &addr, sizeof(addr)) == 1) {
+  if (gethost(h_loc, &addr) == 1) {
     return 0;
   }
   // come on ...
@@ -220,7 +219,7 @@ static int my_gethostname(char *h_loc, size_t size) {
   h_loc[0] = '\0';
   if (gethostname(h_loc, (int) size) == 0) {    // host name
     SOCaddr addr;
-    if (gethost(h_loc, &addr, sizeof(addr)) == 1) {
+    if (gethost(h_loc, &addr) == 1) {
       return 0;
     } else {
       return my_getlocalhost(h_loc, size);
@@ -247,54 +246,16 @@ T_SOC smallserver_init(int *port, char *adr) {
 
   if (my_gethostname(h_loc, 256) == 0) {   // host name
     SOCaddr server;
-    int server_size = sizeof(server);
-
-    /*t_hostent* hp_loc;
-       t_fullhostent buffer; */
-
-    // effacer structure
-    memset(&server, 0, sizeof(server));
-
-                                                                /*if ( (hp_loc=vxgethostbyname(h_loc, &buffer)) ) */
-    {
-      // copie adresse
-      // NO (bind all)
-      // SOCaddr_copyaddr(server, server_size, hp_loc->h_addr_list[0], hp_loc->h_length);
-
-      SOCaddr_initany(server, server_size);
-      if ((soc =
-           (T_SOC) socket(SOCaddr_sinfamily(server), SOCK_STREAM,
-                          0)) != INVALID_SOCKET) {
-        SOCaddr_initport(server, *port);
-        if (bind(soc, (struct sockaddr *) &server, server_size) == 0) {
-          /*SOClen len;
-             SOCaddr server2;
-             len=sizeof(server2); */
-          // effacer structure
-          /*memset(&server2, 0, sizeof(server2));
-             if (getsockname(soc,(struct sockaddr*) &server2,&len) == 0) {
-             *port=ntohs(SOCaddr_sinport(server));  // récupérer port */
-          if (listen(soc, 10) >= 0) {   // au pif le 10
-            // SOCaddr_inetntoa(adr, 128, server2, len);
-            strcpy(adr, h_loc);
-          } else {
-#ifdef _WIN32
-            closesocket(soc);
-#else
-            close(soc);
-#endif
-            soc = INVALID_SOCKET;
-          }
-
-          /*} else {
-             #ifdef _WIN32
-             closesocket(soc);
-             #else
-             close(soc);
-             #endif
-             soc=INVALID_SOCKET;
-             } */
 
+    SOCaddr_initany(server);
+    if ((soc =
+         (T_SOC) socket(SOCaddr_sinfamily(server), SOCK_STREAM,
+                        0)) != INVALID_SOCKET) {
+      SOCaddr_initport(server, *port);
+      if (bind(soc, &SOCaddr_sockaddr(server), SOCaddr_size(server)) == 0) {
+        if (listen(soc, 1) >= 0) {
+          // SOCaddr_inetntoa(adr, 128, server2);
+          strcpy(adr, h_loc);
         } else {
 #ifdef _WIN32
           closesocket(soc);
@@ -303,6 +264,13 @@ T_SOC smallserver_init(int *port, char *adr) {
 #endif
           soc = INVALID_SOCKET;
         }
+      } else {
+#ifdef _WIN32
+        closesocket(soc);
+#else
+        close(soc);
+#endif
+        soc = INVALID_SOCKET;
       }
     }
   }
@@ -1848,7 +1816,7 @@ static int check_readinput(htsblk * r) {
     FD_SET(r->soc, &fds);
     tv.tv_sec = 0;
     tv.tv_usec = 0;
-    select(r->soc + 1, &fds, NULL, NULL, &tv);
+    select((int) r->soc + 1, &fds, NULL, NULL, &tv);
     if (FD_ISSET(r->soc, &fds))
       return 1;
     else
diff --git a/src/htsserver.h b/src/htsserver.h
index c5db213..28c956c 100644
--- a/src/htsserver.h
+++ b/src/htsserver.h
@@ -147,7 +147,7 @@ HTS_UNUSED static int check_readinput_t(T_SOC soc, int timeout) {
     FD_SET(soc, &fds);
     tv.tv_sec = timeout;
     tv.tv_usec = 0;
-    select(soc + 1, &fds, NULL, NULL, &tv);
+    select((int) soc + 1, &fds, NULL, NULL, &tv);
     if (FD_ISSET(soc, &fds))
       return 1;
     else
diff --git a/src/proxy/proxytrack.c b/src/proxy/proxytrack.c
index dabb761..f2fc4d0 100644
--- a/src/proxy/proxytrack.c
+++ b/src/proxy/proxytrack.c
@@ -226,18 +226,17 @@ static int linputsoc_t(T_SOC soc, char *s, int max, int timeout) {
   return -1;
 }
 
-static int gethost(const char *hostname, SOCaddr * server, size_t server_size) {
+static int gethost(const char *hostname, SOCaddr * server) {
   if (hostname != NULL && *hostname != '\0') {
 #if HTS_INET6==0
     /*
        ipV4 resolver
      */
-    t_hostent *hp = gethostbyname(hostname);
+    struct hostent *hp = gethostbyname(hostname);
 
     if (hp != NULL) {
       if (hp->h_length) {
-        SOCaddr_copyaddr(*server, server_size, hp->h_addr_list[0],
-                         hp->h_length);
+        SOCaddr_copyaddr2(*server, hp->h_addr_list[0], hp->h_length);
         return 1;
       }
     }
@@ -256,13 +255,13 @@ static int gethost(const char *hostname, SOCaddr * server, size_t server_size) {
       hints.ai_family = PF_INET6;
     else
 #endif
-      hints.ai_family = PF_UNSPEC;
+    hints.ai_family = PF_UNSPEC;
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;
     if (getaddrinfo(hostname, NULL, &hints, &res) == 0) {
       if (res) {
         if ((res->ai_addr) && (res->ai_addrlen)) {
-          SOCaddr_copyaddr(*server, server_size, res->ai_addr, res->ai_addrlen);
+          SOCaddr_copyaddr2(*server, res->ai_addr, res->ai_addrlen);
           freeaddrinfo(res);
           return 1;
         }
@@ -276,7 +275,7 @@ static int gethost(const char *hostname, SOCaddr * server, size_t server_size) {
   return 0;
 }
 
-static String getip(SOCaddr * server, int serverLen) {
+static String getip(SOCaddr * server) {
   String s = STRING_EMPTY;
 
 #if HTS_INET6==0
@@ -291,7 +290,7 @@ static String getip(SOCaddr * server, int serverLen) {
     proxytrack_print_log(CRITICAL, "memory exhausted");
     return s;
   }
-  SOCaddr_inetntoa(dotted, sizeMax, *server, serverLen);
+  SOCaddr_inetntoa(dotted, sizeMax, *server);
   sprintf(dotted + strlen(dotted), ":%d", port);
   StringAttach(&s, &dotted);
   return s;
@@ -299,18 +298,15 @@ static String getip(SOCaddr * server, int serverLen) {
 
 static T_SOC smallserver_init(const char *adr, int port, int family) {
   SOCaddr server;
-  size_t server_size = sizeof(server);
-
-  memset(&server, 0, sizeof(server));
-  SOCaddr_initany(server, server_size);
-  if (gethost(adr, &server, server_size)) {     // host name
+  SOCaddr_initany(server);
+  if (gethost(adr, &server)) {     // host name
     T_SOC soc = INVALID_SOCKET;
 
     if ((soc =
          (T_SOC) socket(SOCaddr_sinfamily(server), family,
                         0)) != INVALID_SOCKET) {
       SOCaddr_initport(server, port);
-      if (bind(soc, (struct sockaddr *) &server, (int) server_size) == 0) {
+      if (bind(soc, &SOCaddr_sockaddr(server), SOCaddr_size(server)) == 0) {
         if (family != SOCK_STREAM || listen(soc, 10) >= 0) {
           return soc;
         } else {
@@ -1320,12 +1316,12 @@ static void proxytrack_process_HTTP(PT_Indexes indexes, T_SOC soc_c) {
       /* */
       String ip = STRING_EMPTY;
       SOCaddr serverClient;
-      SOClen lenServerClient = (int) sizeof(serverClient);
+      SOClen lenServerClient = SOCaddr_capacity(serverClient);
 
       memset(&serverClient, 0, sizeof(serverClient));
       if (getsockname
-          (soc_c, (struct sockaddr *) &serverClient, &lenServerClient) == 0) {
-        ip = getip(&serverClient, lenServerClient);
+          (soc_c, &SOCaddr_sockaddr(serverClient), &lenServerClient) == 0) {
+        ip = getip(&serverClient);
       } else {
         StringCopy(ip, "unknown");
       }
@@ -1571,14 +1567,14 @@ static int proxytrack_start_ICP(PT_Indexes indexes, T_SOC soc) {
     return -1;
   }
   while(soc != INVALID_SOCKET) {
-    struct sockaddr clientAddr;
-    SOClen clientAddrLen = sizeof(struct sockaddr);
+    SOCaddr clientAddr;
+    SOClen clientAddrLen = SOCaddr_capacity(clientAddr);
     int n;
 
     memset(&clientAddr, 0, sizeof(clientAddr));
-    n =
-      recvfrom(soc, (char *) buffer, bufferSize, 0, &clientAddr,
-               &clientAddrLen);
+    n = recvfrom(soc, (char *) buffer, bufferSize, 0, 
+                 &SOCaddr_sockaddr(clientAddr),
+                 &clientAddrLen);
     if (n != -1) {
       const char *LogRequest = "ERROR";
       const char *LogReply = "ERROR";
@@ -1621,11 +1617,11 @@ static int proxytrack_start_ICP(PT_Indexes indexes, T_SOC soc) {
                   UrlRequestSize = (unsigned int) strlen((char *) UrlRequest);
                   LogRequest = "ICP_OP_QUERY";
                   if (indexes == NULL) {
-                    ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_DENIED,
+                    ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_DENIED,
                               Version, 0, Request_Number, 0, 0, 0, UrlRequest);
                     LogReply = "ICP_OP_DENIED";
                   } else if (PT_LookupIndex(indexes, (char*) UrlRequest)) {
-                    ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_HIT,
+                    ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_HIT,
                               Version, 0, Request_Number, 0, 0, 0, UrlRequest);
                     LogReply = "ICP_OP_HIT";
                   } else {
@@ -1637,7 +1633,7 @@ static int proxytrack_start_ICP(PT_Indexes indexes, T_SOC soc) {
                       if (UrlRedirect != NULL) {
                         sprintf(UrlRedirect, "%s/", UrlRequest);
                         if (PT_LookupIndex(indexes, UrlRedirect)) {     /* We'll generate a redirect */
-                          ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_HIT,
+                          ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_HIT,
                                     Version, 0, Request_Number, 0, 0, 0,
                                     UrlRequest);
                           LogReply = "ICP_OP_HIT";
@@ -1648,7 +1644,7 @@ static int proxytrack_start_ICP(PT_Indexes indexes, T_SOC soc) {
                       }
                     }
                     /* We won't retrive the cache MISS online, no way! */
-                    ICP_reply(&clientAddr, clientAddrLen, soc,
+                    ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc,
                               ICP_OP_MISS_NOFETCH, Version, 0, Request_Number,
                               0, 0, 0, UrlRequest);
                     LogReply = "ICP_OP_MISS_NOFETCH";
@@ -1660,24 +1656,24 @@ static int proxytrack_start_ICP(PT_Indexes indexes, T_SOC soc) {
                   UrlRequest = &Payload[4];
                   LogRequest = "ICP_OP_QUERY";
                   LogReply = "ICP_OP_QUERY";
-                  ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_SECHO,
+                  ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_SECHO,
                             Version, 0, Request_Number, 0, 0, 0, UrlRequest);
                 }
                 break;
               default:
                 LogRequest = "NOTIMPLEMENTED";
                 LogReply = "ICP_OP_ERR";
-                ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_ERR, Version,
+                ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_ERR, Version,
                           0, Request_Number, 0, 0, 0, NULL);
                 break;
               }
             } else {
-              ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_ERR, 2, 0,
+              ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_ERR, 2, 0,
                         Request_Number, 0, 0, 0, NULL);
             }
           }                     /* Ignored (RFC2186) */
         } else {
-          ICP_reply(&clientAddr, clientAddrLen, soc, ICP_OP_ERR, Version, 0,
+          ICP_reply(&SOCaddr_sockaddr(clientAddr), clientAddrLen, soc, ICP_OP_ERR, Version, 0,
                     Request_Number, 0, 0, 0, NULL);
         }
       }
@@ -1691,7 +1687,7 @@ static int proxytrack_start_ICP(PT_Indexes indexes, T_SOC soc) {
         SOCaddr_copyaddr(serverClient, lenServerClient, &clientAddr,
                          clientAddrLen);
         if (lenServerClient > 0) {
-          ip = getip(&serverClient, lenServerClient);
+          ip = getip(&clientAddr);
         } else {
           StringCopy(ip, "unknown");
         }