Changeset 295 for trunk/src

Timestamp:

Oct 31, 2010, 10:36:04 AM (14 years ago)

Author:

katerina

Message:

Support for IPv6 (ticket #222).

Location:

trunk/src

Files:

• cutest_sh_tools.c (modified) (2 diffs)
• sh_audit.c (modified) (1 diff)
• sh_calls.c (modified) (10 diffs)
• sh_forward.c (modified) (41 diffs)
• sh_getopt.c (modified) (1 diff)
• sh_ipvx.c (added)
• sh_login_track.c (modified) (2 diffs)
• sh_mail.c (modified) (8 diffs)
• sh_port2proc.c (modified) (12 diffs)
• sh_portcheck.c (modified) (63 diffs)
• sh_registry.c (modified) (5 diffs)
• sh_socket.c (modified) (2 diffs)
• sh_tools.c (modified) (9 diffs)
• sh_unix.c (modified) (8 diffs)
• sh_utmp.c (modified) (4 diffs)

trunk/src/cutest_sh_tools.c

@@ -6 +6 @@
 #include "samhain.h"
 #include "sh_tools.h"
+#include "sh_ipvx.h"
 
 void Test_sh_tools_safe_name_01(CuTest *tc) {
@@ -106 +107 @@
   char* input  = strdup("hello world");
 
-  CuAssertTrue(tc, !is_numeric(input));
+  CuAssertTrue(tc, !sh_ipvx_is_numeric(input));
 
   input  = strdup("127.0.0.1");
-  CuAssertTrue(tc, is_numeric(input));
+  CuAssertTrue(tc, sh_ipvx_is_numeric(input));
   input  = strdup("127.0.0.de");
-  CuAssertTrue(tc, !is_numeric(input));
+  CuAssertTrue(tc, !sh_ipvx_is_numeric(input));
   input  = strdup("127");
-  CuAssertTrue(tc, is_numeric(input));
+  CuAssertTrue(tc, sh_ipvx_is_numeric(input));
 }
 

trunk/src/sh_audit.c

@@ -276 +276 @@
   for (i = 0; i < 4; ++i)
     {
-      if (0 == access(_(actl_paths[i]), F_OK))
-        {
-          if (0 == access(_(actl_paths[i]), X_OK))
+      if (0 == access(_(actl_paths[i]), F_OK))/* flawfinder: ignore */
+        {
+          if (0 == access(_(actl_paths[i]), X_OK))/* flawfinder: ignore */
             {
               actl_pnum = i;

trunk/src/sh_calls.c

@@ -51 +51 @@
 #include "sh_error.h"
 #include "sh_calls.h"
+#include "sh_ipvx.h"
 
 #undef  FIL__
@@ -134 +135 @@
 }
 
-static struct in_addr bind_addr;
+static struct sh_sockaddr bind_addr;
 static int        use_bind_addr = 0;
 
@@ -147 +148 @@
     reject = 1;
 
-  if (0 == /*@-unrecog@*/inet_aton(str, &bind_addr)/*@+unrecog@*/) 
-    {
-      return -1;
-    }
+#if defined(USE_IPVX)
+  if (0 == sh_ipvx_aton(str, &bind_addr)) 
+    return -1;
+#else
+  if (0 == inet_aton(str, &(bind_addr.sin.sin_addr))) 
+    return -1;
+#endif
+
   use_bind_addr = 1;
   return 0;
@@ -161 +166 @@
   int error;
   long int val_retry = 0;
-  static struct sockaddr_in new_addr;
   char errbuf[SH_ERRBUF_SIZE];
 
@@ -170 +174 @@
   if (0 != use_bind_addr) 
     {
-      memcpy(&new_addr.sin_addr, &bind_addr, sizeof(struct in_addr));
-      new_addr.sin_family = AF_INET;
-      
-      val_retry = /*@-unrecog@*/bind(sockfd, 
-                                     (struct sockaddr*)&new_addr, 
-                                     sizeof(struct sockaddr_in))/*@+unrecog@*/;
+      int slen = SH_SS_LEN(bind_addr);
+
+      val_retry = bind(sockfd, sh_ipvx_sockaddr_cast(&bind_addr), slen);
     }
 
@@ -181 +182 @@
     {
       do {
-        val_retry = 
-          /*@-unrecog@*/connect(sockfd, serv_addr, addrlen)/*@+unrecog@*/;
+        val_retry = connect(sockfd, serv_addr, addrlen);
       } while (val_retry < 0 && (errno == EINTR || errno == EINPROGRESS));
     }
@@ -188 +188 @@
   error = errno;
   if (val_retry != 0) {
-    /* ugly cast back to struct sockaddr_in :-(
-     */
+    long eport;
+    char eaddr[SH_IP_BUF];
+
+    struct sh_sockaddr ss;
+    sh_ipvx_save(&ss, serv_addr->sa_family, serv_addr);
+    sh_ipvx_ntoa(eaddr, sizeof(eaddr), &ss);
+    
+    if (serv_addr->sa_family == AF_INET)
+      eport = (long) ntohs(((struct sockaddr_in *)serv_addr)->sin_port);
+    else
+      eport = (long) ntohs(((struct sockaddr_in6 *)serv_addr)->sin6_port);
+
     sh_error_handle ((-1), file, line, error, MSG_ERR_CONNECT, 
                      sh_error_message(error, errbuf, sizeof(errbuf)),
-                     (long) sockfd,
-                     /*@-unrecog -type@*/
-                     (long) ntohs(((struct sockaddr_in *)serv_addr)->sin_port),
-                     /*@+unrecog +type@*/
-#ifdef HAVE_INET_ATON
-                     /*@-unrecog -type@*/
-                     inet_ntoa( ((struct sockaddr_in *)serv_addr)->sin_addr )
-                     /*@+unrecog +type@*/
-#else
-                     _("unknown")
-#endif
-                     );
+                     (long) sockfd, eport, eaddr);
   }
   errno = error;    
@@ -210 +209 @@
 
 long int retry_accept(const char * file, int line, int fd, 
-                      struct sockaddr *serv_addr, int * addrlen)
+                      struct sh_sockaddr *serv_addr, int * addrlen)
 {
   int  error;
   long int val_retry = -1;
   char errbuf[SH_ERRBUF_SIZE];
-
-  ACCEPT_TYPE_ARG3 my_addrlen = (ACCEPT_TYPE_ARG3) *addrlen;
+  struct sockaddr_storage ss;
+
+  ACCEPT_TYPE_ARG3 my_addrlen = sizeof(ss);
 
   errno              = 0;
@@ -223 +223 @@
 
   do {
-    val_retry = /*@-unrecog@*/accept(fd, serv_addr, &my_addrlen)/*@+unrecog@*/;
+    val_retry = accept(fd, (struct sockaddr *)&ss, &my_addrlen);
   } while (val_retry < 0 && errno == EINTR);
+
   *addrlen = (int) my_addrlen;
   error = errno;
@@ -232 +233 @@
                        (long) fd );
   }
-  errno = error;    
+  errno = error;
+
+  sh_ipvx_save(serv_addr, ss.ss_family, (struct sockaddr *) &ss);
+
   SL_RETURN(val_retry, _("retry_accept"));
 }

trunk/src/sh_forward.c

@@ -121 +121 @@
 #endif
 
+#include "sh_ipvx.h"
 #include "samhain.h"
 #include "sh_tiger.h"
@@ -239 +240 @@
        * --> last part must be kept
        */
-      if (0 != is_numeric(name))
+      if (0 != sh_ipvx_is_numeric(name))
         {
           SL_RETURN( name, _("sh_strip_domain"));
@@ -2187 +2188 @@
   char            FileType[5];
 
-  struct sockaddr_in addr_peer;
+  struct sh_sockaddr addr_peer;
 } sh_conn_t;
 
@@ -2592 +2593 @@
 #endif
 
-int check_addr (const char * claim, struct sockaddr_in addr_peer)
+int check_addr (const char * claim, struct sh_sockaddr * addr_peer)
 {
   char               h_name[MAXHOSTNAMELEN + 1];
   char               h_peer[MAXHOSTNAMELEN + 1];
-  char               h_peer_IP[16];
-  char               tmp_peer_IP[16];
-  struct hostent   * he;
-  char            ** p = NULL;
-  int                i;
-  int                flag = 0;
+  char               h_peer_IP[SH_IP_BUF];
+  char               tmp_peer_IP[SH_IP_BUF];
+  char             * canonical;
+  char               numeric[SH_IP_BUF];
 
   SL_ENTER(_("check_addr"));
@@ -2614 +2613 @@
   /* Make sure we have the canonical name for the client
    */
-  he = sh_gethostbyname (claim);
-
-  if (he != NULL && he->h_name != NULL)
-    {
-      if (NULL == strchr(he->h_name, '.') && he->h_addr_list != NULL)
-        {
-          he = sh_gethostbyaddr(he->h_addr_list[0], 
-                                he->h_length, 
-                                he->h_addrtype);
-        }
-    }
+  canonical = sh_ipvx_canonical(claim, numeric, sizeof(numeric));
 
   /* copy canonical name into h_name
    */
-  if (he != NULL && he->h_name != NULL)
-    {
-      sl_strlcpy(h_name, he->h_name, MAXHOSTNAMELEN + 1);
+  if (canonical != NULL)
+    {
+      sl_strlcpy(h_name, canonical, MAXHOSTNAMELEN + 1);
+      SH_FREE(canonical);
     }
   else
@@ -2642 +2632 @@
   /* get canonical name of socket peer
    */
-  he = sh_gethostbyaddr ((char *) &(addr_peer.sin_addr), 
-                         sizeof(addr_peer.sin_addr),
-                         AF_INET);
-
-  if (he != NULL && he->h_name != NULL)
-    {
-      if (0 == sl_strcmp(he->h_name, _("localhost")))
+  canonical = sh_ipvx_addrtoname(addr_peer);
+
+  if (canonical)
+    {
+      if (0 == sl_strcmp(canonical, _("localhost")))
         sl_strlcpy(h_peer, sh.host.name, MAXHOSTNAMELEN + 1);
       else
-        sl_strlcpy(h_peer, he->h_name, MAXHOSTNAMELEN + 1);
+        sl_strlcpy(h_peer, canonical, MAXHOSTNAMELEN + 1);
+      SH_FREE(canonical);
     }
   else
     {
-      sl_strlcpy(tmp_peer_IP,
-                 inet_ntoa (*(struct in_addr *) &(addr_peer.sin_addr)),
-                 16);
+      sh_ipvx_ntoa (tmp_peer_IP, sizeof(tmp_peer_IP), addr_peer);
       sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_RESPEER,
                       claim, tmp_peer_IP);
@@ -2663 +2650 @@
     }
 
-  sl_strlcpy(h_peer_IP, 
-             inet_ntoa (*(struct in_addr *) he->h_addr),
-             16);
+  sh_ipvx_ntoa (h_peer_IP, sizeof(h_peer_IP), addr_peer);
 
 #if 0
@@ -2676 +2661 @@
   /* reverse lookup
    */
-  if (0 != sl_strncmp(_("127."), 
-                      inet_ntoa (*(struct in_addr *) &(addr_peer.sin_addr)),
-                      4))
-    {
-      he = sh_gethostbyname(h_peer);
-      
-      if (he != NULL)
-        {
-          for (p = he->h_addr_list; *p; ++p)
-            {
-              if (0 == memcmp (*p, &(addr_peer.sin_addr), 
-                               sizeof(addr_peer.sin_addr))) 
-                break;
-            }
-        }
-      if (he == NULL || *p == NULL) 
-        {
-          sl_strlcpy(tmp_peer_IP,
-                     inet_ntoa (*(struct in_addr *) &(addr_peer.sin_addr)),
-                     16);
-          sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_LOOKERS,
-                          claim, h_peer, tmp_peer_IP);
-          SL_RETURN ((0), _("check_addr"));
-        }
-    }
-
-  sh_tolower(h_peer);
-  sh_tolower(h_name);
+  if (0 == sh_ipvx_reverse_check_ok (h_peer, ServerPort, addr_peer))
+    {
+      sh_ipvx_ntoa (tmp_peer_IP, sizeof(tmp_peer_IP), addr_peer);
+
+      sh_error_handle(lookup_err, FIL__, __LINE__, 0, MSG_TCP_LOOKERS,
+                      claim, h_peer, tmp_peer_IP);
+      SL_RETURN ((0), _("check_addr"));
+    }
+
+  /* Check whether claim and peer are identical
+   */
+
+  sh_tolower(h_peer); /* Canonical name of what the peer is     */
+  sh_tolower(h_name); /* Canonical name of what the peer claims */
 
   if ((0 == sl_strcmp(h_peer, h_name)) || (0 == sl_strcmp(h_peer_IP, h_name)))
@@ -2709 +2680 @@
       SL_RETURN ((0), _("check_addr"));
     }
+#if !defined(USE_IPVX)
   else
     {
-      i = 0;
+      struct hostent   * he = sh_gethostbyname(h_peer);
+      int                i = 0;
+      int                flag = 0;
+
       while (he->h_aliases[i] != NULL)
         {
@@ -2725 +2700 @@
                         claim, h_peer);
     }
+#endif
 
   SL_RETURN ((0), _("check_addr"));
@@ -2742 +2718 @@
 {
   client_t * this_client;
-  char       peer_ip[16];
+  char       peer_ip[SH_IP_BUF];
+  char       numerical[SH_IP_BUF];
   char       peer_name[MAXHOSTNAMELEN+1];
   char     * search_string;
-  struct sockaddr_in peer_addr;
-  struct hostent   * he;
-  char    ** p = NULL;
+
+  struct sh_sockaddr peer_addr;
+  char             * canonical;
 
   SL_ENTER(_("search_register"));
@@ -2753 +2730 @@
   if (UseSocketPeer == S_TRUE)
     {
-      peer_addr = conn->addr_peer;
-      sl_strlcpy(peer_ip, 
-                 inet_ntoa (*(struct in_addr *) &(peer_addr.sin_addr)), 16);
+      memcpy(&peer_addr, &(conn->addr_peer), sizeof(struct sh_sockaddr));
+      sh_ipvx_ntoa (peer_ip, sizeof(peer_ip), &peer_addr);
 
       /* get canonical name of socket peer
        */
-      he = sh_gethostbyaddr ((char *) &(peer_addr.sin_addr), 
-                             sizeof(peer_addr.sin_addr),
-                             AF_INET);
-
-      if (he != NULL && he->h_name != NULL)
-        {
-          if (0 == sl_strcmp(he->h_name, _("localhost")))
+      canonical = sh_ipvx_canonical(peer_ip, numerical, sizeof(numerical));
+
+      if (canonical != NULL)
+        {
+          if (0 == sl_strcmp(canonical, _("localhost")))
             sl_strlcpy(peer_name, sh.host.name, MAXHOSTNAMELEN + 1);
           else
-            sl_strlcpy(peer_name, he->h_name, MAXHOSTNAMELEN + 1);
-
-          /* Reverse lookup 
-           */
-          if (0 != sl_strncmp(peer_ip, _("127."), 4))
-            {
-              he = sh_gethostbyname(peer_name);
-              
-              if (he != NULL)
-              {
-                for (p = he->h_addr_list; *p; ++p)
-                  {
-                    if (0 == memcmp (*p, &(peer_addr.sin_addr), 
-                                     sizeof(peer_addr.sin_addr))) 
-                      break;
-                  }
-              }
-              if (he == NULL || *p == NULL) 
-              {
-                /*
-                sh_error_handle(lookup_err, FIL__, __LINE__, 0, 
-                                MSG_TCP_LOOKERS,
-                                conn->buf[pos], peer_name, peer_ip);
-                */
-                sl_strlcpy(peer_name, peer_ip, MAXHOSTNAMELEN + 1);
-              }
-            }
-        }
-      else
+            sl_strlcpy(peer_name, canonical,    MAXHOSTNAMELEN + 1);
+          SH_FREE(canonical);
+        }
+
+      if (0 == sh_ipvx_reverse_check_ok (peer_name, ServerPort, &peer_addr))
         {
           sl_strlcpy(peer_name, peer_ip, MAXHOSTNAMELEN + 1);
         }
+
       search_string = peer_name;
     }
@@ -2806 +2757 @@
       search_string = &(conn->buf[pos]);
 
-      if (0 != check_addr (search_string, conn->addr_peer))
+      if (0 != check_addr (search_string, &(conn->addr_peer)))
         {
           sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_BADCONN,
@@ -3662 +3613 @@
                    */
 #if defined(SH_WITH_SERVER) && defined(HAVE_LIBPRELUDE)
-                  sh_error_set_peer_ip( inet_ntoa (*(struct in_addr *) &(conn->addr_peer.sin_addr)) );                        
+                  {
+                    char peer_ip[SH_IP_BUF];
+                    sh_ipvx_ntoa(peer_ip, sizeof(peer_ip), conn->addr_peer); 
+                    sh_error_set_peer_ip( peer_ip );
+                  }                        
 #endif
                   sh_error_set_peer(sh_strip_domain (conn->peer));
@@ -4684 +4639 @@
   int                errflag;
   int                rc;
-  struct sockaddr_in addr;
+  struct sh_sockaddr addr;
 #ifdef SH_USE_LIBWRAP
   struct request_info request;
@@ -4697 +4652 @@
   SL_ENTER(_("sh_forward_accept"));
 
-  rc = retry_accept(FIL__, __LINE__, sock, 
-                    (struct sockaddr *) &addr, &addrlen);
+  rc = retry_accept(FIL__, __LINE__, sock, &addr, &addrlen);
 
   if (rc >= 0)
@@ -4714 +4668 @@
 
 #ifdef SH_USE_LIBWRAP
-      sl_strlcpy(daemon, SH_INSTALL_NAME, 128);
+      sl_strlcpy(daemon, SH_INSTALL_NAME, sizeof(daemon));
       request_init(&request, RQ_DAEMON, daemon, RQ_FILE, rc, 0);
       fromhost(&request);
       if (!hosts_access(&request)) 
         {
-          sl_strlcpy(errbuf, _("Refused connection from "), 128);
-          sl_strlcat(errbuf,   eval_client(&request), 128);
+          sl_strlcpy(errbuf, _("Refused connection from "), sizeof(errbuf));
+          sl_strlcat(errbuf,   eval_client(&request), sizeof(errbuf));
 
           sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
@@ -4731 +4685 @@
 #endif
 
-      memcpy (&(newconn->addr_peer), &addr, sizeof(struct sockaddr_in));
+      memcpy (&(newconn->addr_peer), &addr, sizeof(struct sh_sockaddr));
 
       /* prepare for usage of connection
@@ -4781 +4735 @@
 }
 
-static struct in_addr server_interface;
+static struct sh_sockaddr server_interface;
 static int            use_server_interface = 0;
 
@@ -4791 +4745 @@
       return 0;
     }
-  if (0 == /*@-unrecog@*/inet_aton(str, &server_interface)/*@+unrecog@*/) 
+
+  if (0 == sh_ipvx_aton(str, &server_interface)) 
     {
       use_server_interface = 0;
       return -1;
     }
+
   use_server_interface = 1;
   return 0;
@@ -4882 +4838 @@
 #ifdef INET_SYSLOG
 #define INET_SUSPEND_TIME 180           /* equal to 3 minutes */
-#define SH_MINSOCK 3
+#define SH_MINSOCK_DEFAULT 3
 int create_syslog_socket (int flag);
 static int recv_syslog_socket   (int fd);
-static int syslog_sock = -1;
+static int syslog_sock[SH_SOCKMAX] = { -1 };
+static int syslog_sock_n = 0;
 #else
-#define SH_MINSOCK 2
-#endif
-
+#define SH_MINSOCK_DEFAULT 2
+#endif
+
+static int SH_MINSOCK = SH_MINSOCK_DEFAULT;
 extern int pf_unix_fd;
 
 /* the tcp socket, and the function to establish it
  */
-static int sh_tcp_sock = -1;
+static int sh_tcp_sock[SH_SOCKMAX] = { -1 };
+static int sh_tcp_sock_n = 0;
+
+static int do_socket(int domain, int type, int protocol,
+                     struct sockaddr * sa, int salen)
+{
+  int sock = -1;
+  int errnum = 0;
+  int flag   = 1; /* non-zero to enable an option */
+
+  /* create the socket, bind() it and listen()
+   */
+  if ((sock = socket(domain, type, protocol)) < 0 )
+    {
+      errnum = errno; 
+      sh_forward_printerr (_("socket"), errnum, server_port, __LINE__);
+      return -1;
+    }
+  (void) retry_fcntl( FIL__, __LINE__, sock, F_SETFD, 1 );
+ 
+  if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+                  (void *) &flag, sizeof(flag)) < 0 )
+    {
+      errnum = errno;
+      sh_forward_printerr (_("setsockopt"), errnum, server_port, __LINE__);
+      sl_close_fd (FIL__, __LINE__, sock);
+      return -1;
+    }
+  
+  if ( bind(sock, (struct sockaddr *) sa, salen) < 0) 
+    {
+      if (errno != EADDRINUSE)
+        {
+          errnum = errno;
+          sh_forward_printerr (_("bind"), errnum, server_port, __LINE__);
+          sl_close_fd (FIL__, __LINE__, sock);
+          return -1;
+        }
+      else
+        {
+          sl_close_fd (FIL__, __LINE__, sock);
+          return -2;
+        }
+    }
+  
+  if ( retry_fcntl( FIL__, __LINE__, sock, F_SETFL, O_NONBLOCK ) < 0 )
+    {
+      errnum = errno;
+      sh_forward_printerr (_("fcntl"), errnum, server_port, __LINE__);
+      sl_close_fd (FIL__, __LINE__, sock);
+      return -1;
+    }
+  
+  if ( listen(sock, 64) < 0)
+    {
+      errnum = errno;
+      sh_forward_printerr (_("listen"), errnum, server_port, __LINE__);
+      sl_close_fd (FIL__, __LINE__, sock);
+      return -1;
+    }
+
+  return sock;
+}
 
 int sh_create_tcp_socket (void)
 {
+#if defined(USE_IPVX)
+  struct addrinfo *ai;
+  struct addrinfo *p;
+  struct addrinfo hints;
+  char            port[32];
+#else
   struct sockaddr_in addr;
   int addrlen      = sizeof(addr);
+#endif
 
   int sock   = -1;
-  int errnum = 0;
-  int flag   = 1; /* non-zero to enable an option */
 
   SL_ENTER(_("sh_create_tcp_socket"));
@@ -4909 +4934 @@
   sh_forward_printerr (NULL, 0, server_port, __LINE__);
 
-  /* create the socket, bind() it and listen()
-   */
-  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
-    {
-      errnum = errno; 
-      sh_forward_printerr (_("socket"), errnum, server_port, __LINE__);
-      SL_RETURN((-1), _("sl_create_tcp_socket"));
-    }
-  (void) retry_fcntl( FIL__, __LINE__, sock, F_SETFD, 1 );
-  
-  if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
-                  (void *) &flag, sizeof(flag)) < 0 )
-    {
-      errnum = errno;
-      sh_forward_printerr (_("setsockopt"), errnum, server_port, __LINE__);
-      SL_RETURN((-1), _("sl_create_tcp_socket"));
-    }
-  
-  addr.sin_family      = AF_INET;
-  addr.sin_port        = htons(server_port);
+#if defined(USE_IPVX)
+  if (use_server_interface == 0)
+    {
+      memset (&hints, '\0', sizeof (hints));
+      hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+      hints.ai_socktype = SOCK_STREAM;
+      sl_snprintf(port, sizeof(port), "%d", server_port);
+
+      if (getaddrinfo (NULL, port, &hints, &ai) != 0)
+        {
+          int errnum = errno;
+          sh_forward_printerr (_("getaddrinfo"), errnum, server_port, __LINE__);
+          sl_close_fd (FIL__, __LINE__, sock);
+          SL_RETURN((-1), _("sl_create_tcp_socket"));
+        }
+      
+      p = ai;
+      
+      while (p != NULL && sh_tcp_sock_n < SH_SOCKMAX)
+        {
+          sock = do_socket(p->ai_family, p->ai_socktype, p->ai_protocol,
+                           p->ai_addr, p->ai_addrlen);
+          
+          if (sock >= 0) {
+            if (sh_tcp_sock_n < SH_SOCKMAX) {
+              sh_tcp_sock[sh_tcp_sock_n] = sock;
+              ++sh_tcp_sock_n;
+            }
+            else {
+              sl_close_fd (FIL__, __LINE__, sock);
+            }    
+          } else if (sock == -1) {
+            freeaddrinfo (ai);
+            goto end;
+          }
+          p = p->ai_next;
+        }
+      
+      freeaddrinfo (ai);
+    }
+  else
+    {
+      sh_ipvx_set_port(&server_interface, server_port);
+
+      sock = do_socket(server_interface.ss_family, SOCK_STREAM, 0, 
+                       sh_ipvx_sockaddr_cast(&server_interface), 
+                       SH_SS_LEN(server_interface));
+      
+      if (sock >= 0) {
+        sh_tcp_sock[0] = sock;
+        sh_tcp_sock_n  = 1;
+      }
+    }          
+#else
   if (use_server_interface == 0)
     addr.sin_addr.s_addr = INADDR_ANY;
   else
-    memcpy(&addr.sin_addr, &server_interface, sizeof(struct in_addr));
+    memcpy(&addr, sh_ipvx_sockaddr_cast(&server_interface), addrlen);
+  addr.sin_family      = AF_INET;
+  addr.sin_port        = htons(server_port);
   
-  if ( bind(sock, (struct sockaddr *) &addr, addrlen) < 0) 
-    {
-      errnum = errno;
-      sh_forward_printerr (_("bind"), errnum, server_port, __LINE__);
-      SL_RETURN((-1), _("sl_create_tcp_socket"));
-    }
-  
-  if ( retry_fcntl( FIL__, __LINE__, sock, F_SETFL, O_NONBLOCK ) < 0 )
-    {
-      errnum = errno;
-      sh_forward_printerr (_("fcntl"), errnum, server_port, __LINE__);
-      SL_RETURN((-1), _("sl_create_tcp_socket"));
-    }
-  
-  if ( listen(sock, 5) < 0)
-    {
-      errnum = errno;
-      sh_forward_printerr (_("listen"), errnum, server_port, __LINE__);
-      SL_RETURN((-1), _("sl_create_tcp_socket"));
-    }
-
-  sh_tcp_sock = sock;
-
-  SL_RETURN((sock), _("sl_create_tcp_socket"));
+  sock = do_socket(AF_INET, SOCK_STREAM, 0, (struct sockaddr *) &addr, addrlen);
+
+  if (sock >= 0) {
+      sh_tcp_sock[0] = sock;
+      sh_tcp_sock_n  = 1;
+  }
+
+#endif
+
+#if defined(USE_IPVX)
+ end:
+#endif
+  if (sh_tcp_sock_n > 1)
+    SH_MINSOCK += (sh_tcp_sock_n - 1);
+
+  SL_RETURN((sh_tcp_sock_n), _("sl_create_tcp_socket"));
 }
 
@@ -4984 +5037 @@
   int                nowconn;
   int                status;
-  int                high_fd;
+  int                high_fd = -1;
   register int       i;
   long               dummy = 0;
@@ -5000 +5053 @@
 
   int setsize_fd;
+
+  int sock_tcp[2];
+  int sock_unix;
+#ifdef INET_SYSLOG
+  int sock_log[2];
+#endif
   
   SL_ENTER(_("sh_receive"));
@@ -5015 +5074 @@
       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
     }
-  sock = sh_tcp_sock;
+
+  sock = sh_tcp_sock[0];
 
   /* ****************************************************************
@@ -5031 +5091 @@
    */
   maxconn    = get_open_max() - 6;
+
   /* ugly fix for FreeBSD compiler warning; casting FD_SETSIZE in the
    * conditional expression does not suppress the warning... */
@@ -5079 +5140 @@
   /* conns[0] is the listen() socket. Always in read mode.
    */
-  conns[0].fd    = sock;
-  conns[0].state = CONN_READING;
-  high_fd = sock;
+  sock = 0;
+
+  sock_tcp[0] = 0;
+  while (sock < sh_tcp_sock_n)
+    {
+      conns[sock].fd    = sh_tcp_sock[sock];
+      conns[sock].state = CONN_READING;
+      high_fd = (sh_tcp_sock[sock] > high_fd) ? sh_tcp_sock[sock] : high_fd;
+      ++sock;
+    }
+  sock_tcp[1] = sock;
   
-  conns[1].fd    = pf_unix_fd;
-  conns[1].state = CONN_READING;
+  conns[sock].fd    = pf_unix_fd;
+  conns[sock].state = CONN_READING;
   high_fd = (pf_unix_fd > high_fd) ? pf_unix_fd : high_fd;
-  
+
+  sock_unix = sock;
+
+  ++sock;
+
 #ifdef INET_SYSLOG
-  conns[2].fd = -1;
+  conns[sock].fd = -1;
+
   if ( sh_forward_printerr_final(1) < 0)
     {
@@ -5095 +5169 @@
       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
     }
-  sock = syslog_sock;
-
-  if (sock >= 0)
-    {
-      conns[2].fd    = sock;
-      conns[2].state = CONN_READING;
-      high_fd = (high_fd > conns[2].fd) ? high_fd : conns[2].fd;
+
+  sock_log[0] = sock;
+  sock_log[1] = sock;
+
+  if (syslog_sock_n > 0)
+    {
+      int s2;
+      for (s2 = 0; s2 < syslog_sock_n; ++s2)
+        {
+          conns[sock].fd    = syslog_sock[s2];
+          conns[sock].state = CONN_READING;
+          high_fd = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd;
+          ++sock;
+        }
+      sock_log[1] = sock;
+
     }
 #endif
@@ -5153 +5236 @@
 
             (void) sh_readconf_read ();
+
             for (i = SH_MINSOCK; i < maxconn; ++i)
               if (conns[i].state != CONN_FREE   && 
@@ -5230 +5314 @@
       FD_ZERO( &readset );
       FD_ZERO( &writeset );
-      FD_SET(conns[0].fd, &readset );
-      high_fd   = conns[0].fd;
-
-      if (conns[1].fd > -1)
-        {
-          FD_SET(conns[1].fd, &readset );
-          high_fd   = (high_fd > conns[1].fd) ? high_fd : conns[1].fd;
+      high_fd = conns[0].fd;
+
+      for (sock = sock_tcp[0]; sock < sock_tcp[1]; ++sock)
+        {
+          FD_SET(conns[sock].fd, &readset );
+          high_fd   = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd;
+        }
+
+      if (conns[sock_unix].fd > -1)
+        {
+          FD_SET(conns[sock_unix].fd, &readset );
+          high_fd   = (high_fd > conns[sock_unix].fd) ? high_fd : conns[sock_unix].fd;
         }
 
 #ifdef INET_SYSLOG
-      if (conns[2].fd > -1)
-        {
-          FD_SET(conns[2].fd, &readset );
-          high_fd   = (high_fd > conns[2].fd) ? high_fd : conns[2].fd;
+      for (sock = sock_log[0]; sock < sock_log[1]; ++sock)
+        {
+          if (conns[sock].fd > -1)
+            {
+              FD_SET(conns[sock].fd, &readset );
+              high_fd   = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd;
+            }
         }
 #endif
@@ -5405 +5497 @@
       /* New connection.
        */
-      if ( FD_ISSET(conns[0].fd , &readset )) /* a new connection   */
-        {
-          --num_sel;
-          status = 0;
-          if (nowconn < maxconn && sig_terminate == 0 && sig_termfast == 0)
+      for (sock = sock_tcp[0]; sock < sock_tcp[1]; ++sock)
+        {
+          if ( FD_ISSET(conns[sock].fd , &readset )) /* a new connection   */
             {
-              i = SH_MINSOCK;
-              while (i < maxconn)
+              --num_sel;
+              status = 0;
+              if (nowconn < maxconn && sig_terminate == 0 && sig_termfast == 0)
                 {
-                  if (conns[i].state == CONN_FREE)
+                  /* Find a free slot to accept the connection
+                   */
+                  i = SH_MINSOCK;
+                  while (i < maxconn)
                     {
-                      status = sh_forward_accept (conns[0].fd, &conns[i]);
-                      if (status == 0)
+                      if (conns[i].state == CONN_FREE)
                         {
-                          high_fd = 
-                            (high_fd > conns[i].fd ? high_fd : conns[i].fd);
-                          ++server_status.conn_open;
-                          ++server_status.conn_total;
-                          server_status.last = time (NULL);
+                          /* Here we run the accept() and copy the peer to
+                           * the free slot. 
+                           */
+                          status = sh_forward_accept(conns[sock].fd, &conns[i]);
+                          
+                          if (status == 0)
+                            {
+                              high_fd = 
+                                (high_fd > conns[i].fd ? high_fd : conns[i].fd);
+                              ++server_status.conn_open;
+                              ++server_status.conn_total;
+                              server_status.last = time (NULL);
+                            }
+                          break;
                         }
-                      break;
+                      ++i;
                     }
-                  ++i;
                 }
+              /* This re-runs select to accept data on the new
+               * connection, rather than first dealing with old
+               * connections.
+               */
+              if (status == 0) 
+                continue;
             }
-          if (status == 0) 
-            continue;
         }
       
       /* check for commands on the socket
        */
-      if (conns[1].fd > (-1) && FD_ISSET(conns[1].fd , &readset ))
+      if (conns[sock_unix].fd > (-1) && FD_ISSET(conns[sock_unix].fd , &readset ))
         {
           sh_socket_poll();
@@ -5442 +5547 @@
 
 #ifdef INET_SYSLOG
-      if (conns[2].fd > (-1) && FD_ISSET(conns[2].fd , &readset ))
-        {
-          recv_syslog_socket (conns[2].fd);
+      for (sock = sock_log[0]; sock < sock_log[1]; ++sock)
+        {
+          if (conns[sock].fd > (-1) && FD_ISSET(conns[sock].fd , &readset ))
+            {
+              recv_syslog_socket (conns[sock].fd);
+            }
         }
 #endif
@@ -5503 +5611 @@
 
 #ifdef INET_SYSLOG
-
-#ifdef HAVE_INET_ATON
-static char * my_inet_ntoa(struct in_addr in)
-{
-  return inet_ntoa(in);
-}
-#else
-static char * my_inet_ntoa(struct in_addr in)
-{
-  unsigned char a, b, c, d;
-  static char   foo[16];
-  char          bar[4];
-  memcpy (bar, &(in.s_addr), 4); /* memory alignment (?) */
-  memcpy (&a, &bar[0], 1);
-  memcpy (&b, &bar[1], 1);
-  memcpy (&c, &bar[2], 1);
-  memcpy (&d, &bar[3], 1);
-  sprintf(foo, "%d.%d.%d.%d",                       /* known to fit  */
-          (int) a, (int) b, (int) c, (int) d);
-  return foo;
-}
-#endif
-
 
 /* Unlike Linux / FreeBSD, most systems don't define the stuff below
@@ -5675 +5760 @@
   char errbuf[SH_ERRBUF_SIZE];
 
+  struct sh_sockaddr ss;
+  struct sockaddr * sa = (struct sockaddr *) &from;
+  char   namebuf[SH_BUFSIZE];
+
   /* The 6th argument in recvfrom is *socklen_t in Linux and *BSD, 
    * but *int everywhere else. Because socklen_t is unsigned int, there
@@ -5696 +5785 @@
   res = recvfrom(fd,  buf,  1047, 0, (struct sockaddr *) &from, &fromlen);
 
+  sh_ipvx_save(&ss, sa->sa_family, &from);
+  sh_ipvx_ntoa(namebuf, sizeof(namebuf), &ss);
+
   if (res > 0)
     {
@@ -5715 +5807 @@
           sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
                           sh_error_message(res, errbuf, sizeof(errbuf)), 
-                          my_inet_ntoa(from.sin_addr));
+                          namebuf);
           SL_RETURN( (-1), _("recv_syslog_socket"));
         }      
 
-      TPT(( 0, FIL__, __LINE__, _("msg=<UDP message from %s>\n"),
-            my_inet_ntoa(from.sin_addr)));
+      TPT(( 0, FIL__, __LINE__, _("msg=<UDP message from %s>\n"), namebuf ));
+
       ptr = bptr;
       i = 0;
@@ -5775 +5867 @@
       sh_error_handle((-1), FIL__, __LINE__, res, MSG_ERR_SYSLOG,
                       sh_error_message(res, errbuf, sizeof(errbuf)), 
-                      my_inet_ntoa(from.sin_addr));
+                      namebuf);
 
       /* don't accept anything the next 2 seconds
@@ -5790 +5882 @@
 }
 
-/* callerFlag == S_TRUE means override the enable_syslog_socket flag
- */
-int create_syslog_socket (int callerFlag)
+static int do_syslog_socket(int domain, int type, int protocol,
+                            struct sockaddr * sa, int salen)
 {
   int                flag = 1;  /* non-zero to enable an option */
@@ -5798 +5889 @@
   int errnum;
   int res;
+
+  /* create the socket, bind() it and listen()
+   */
+  sock = socket(domain, type, protocol);
+
+  if (sock < 0)
+    {
+      errnum = errno; 
+      sh_forward_printerr (_("syslog socket"), errnum, 514, __LINE__);
+      return -1;
+    }
+  (void) retry_fcntl( FIL__, __LINE__, sock, F_SETFD, 1 );
+  
+  if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+                  (void *) &flag, sizeof(flag)) < 0 )
+    {
+      errnum = errno;
+      sh_forward_printerr (_("syslog setsockopt SO_REUSEADDR"), 
+                           errnum, 514, __LINE__);
+      return -1;
+    }
+
+#if defined(SO_BSDCOMPAT)
+  if ( setsockopt(sock, SOL_SOCKET, SO_BSDCOMPAT,
+                  (void *) &flag, sizeof(flag)) < 0 )
+    {
+      errnum = errno;
+      sh_forward_printerr (_("syslog setsockopt SO_BSDCOMPAT"), 
+                           errnum, 514, __LINE__);
+      return -1;
+    }
+#endif
+  
+  res = bind(sock, sa, salen);
+
+  if ( res < 0) 
+    {
+      errnum = errno;
+      sh_forward_printerr (_("syslog bind"), errnum, 514, __LINE__);
+      sl_close_fd(FIL__, __LINE__, sock);
+      return -1;
+    }
+  return sock;
+}
+
+/* callerFlag == S_TRUE means override the enable_syslog_socket flag
+ */
+int create_syslog_socket (int callerFlag)
+{
+  int sock;
+
+#if defined(USE_IPVX)
+  struct addrinfo *ai;
+  struct addrinfo *p;
+  struct addrinfo hints;
+#else
   struct sockaddr_in addr;
   int addrlen      = sizeof(addr);
+#endif
 
   SL_ENTER(_("create_syslog_socket"));
@@ -5811 +5959 @@
           TPT(( 0, FIL__, __LINE__, _("msg=<close syslog socket>\n")));
           sl_close_fd(FIL__, __LINE__, syslog_sock);
-          syslog_sock = -1;
+          syslog_sock[0] = -1;
         }
       SL_RETURN((-1), _("create_syslog_socket"));
@@ -5818 +5966 @@
   sh_forward_printerr (NULL, 0, 514, __LINE__);
 
-  /* create the socket, bind() it and listen()
-   */
-  sock = socket(AF_INET, SOCK_DGRAM, 0);
-
-  if (sock < 0)
-    {
-      errnum = errno; 
-      sh_forward_printerr (_("syslog socket"), errnum, 514, __LINE__);
-      SL_RETURN((-1), _("create_syslog_socket"));
-    }
-  (void) retry_fcntl( FIL__, __LINE__, sock, F_SETFD, 1 );
-  
-  if ( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
-                  (void *) &flag, sizeof(flag)) < 0 )
-    {
-      errnum = errno;
-      sh_forward_printerr (_("syslog setsockopt SO_REUSEADDR"), 
-                           errnum, 514, __LINE__);
-      SL_RETURN((-1), _("create_syslog_socket"));
-    }
-
-#if defined(SO_BSDCOMPAT)
-  if ( setsockopt(sock, SOL_SOCKET, SO_BSDCOMPAT,
-                  (void *) &flag, sizeof(flag)) < 0 )
-    {
-      errnum = errno;
-      sh_forward_printerr (_("syslog setsockopt SO_BSDCOMPAT"), 
-                           errnum, 514, __LINE__);
-      SL_RETURN((-1), _("create_syslog_socket"));
-    }
-#endif
-  
+#if !defined(USE_IPVX)
+
   memset(&addr, 0, sizeof(addr));
   addr.sin_family      = AF_INET;
   addr.sin_port        = htons(514);
   
-  res = bind(sock, (struct sockaddr *) &addr, addrlen);
-
-  if ( res < 0) 
+  do_syslog_socket(AF_INET, SOCK_DGRAM, 0, (struct sockaddr *) &addr, addrlen);
+
+  if (sock >= 0) {
+    syslog_sock[0] = sock;
+    syslog_sock_n  = 1;
+  }
+
+#else
+  memset (&hints, '\0', sizeof (hints));
+  hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+  hints.ai_socktype = SOCK_DGRAM;
+  if (getaddrinfo (NULL, "syslog", &hints, &ai) != 0)
     {
       errnum = errno;
-      sh_forward_printerr (_("syslog bind"), errnum, 514, __LINE__);
-      sl_close_fd(FIL__, __LINE__, sock);
+      sh_forward_printerr (_("getaddrinfo"), errnum, 514, __LINE__);
+      sl_close_fd (FIL__, __LINE__, sock);
       SL_RETURN((-1), _("create_syslog_socket"));
     }
-
-  syslog_sock = sock;
-
-  SL_RETURN((sock), _("create_syslog_socket"));
+  
+  p = ai;
+
+  while (p != NULL && syslog_sock_n < SH_SOCKMAX)
+    {
+      sock = do_syslog_socket(p->ai_family, p->ai_socktype, p->ai_protocol,
+                              p->ai_addr, p->ai_addrlen);
+      
+      if (sock >= 0) {
+        if (syslog_sock_n < SH_SOCKMAX) {
+          syslog_sock[syslog_sock_n] = sock;
+          ++syslog_sock_n;
+        }
+        else {
+          sl_close_fd (FIL__, __LINE__, sock);
+        }    
+      } else if (sock == -1) {
+        freeaddrinfo (ai);
+        goto end;
+      }
+      p = p->ai_next;
+    }
+  freeaddrinfo (ai);
+#endif
+
+ end:
+  if (syslog_sock_n > 1)
+    SH_MINSOCK += (syslog_sock_n - 1);
+
+  SL_RETURN((syslog_sock_n), _("create_syslog_socket"));
 }
 /* #ifdef INET_SYSLOG */

trunk/src/sh_getopt.c

@@ -400 +400 @@
           SH_DEFAULT_PORT, DEFAULT_IDENT); 
   ++num;
+#endif
+#if defined(USE_IPVX)
+  fputs (_(", IPv6 supported"), stdout);
 #endif
 

trunk/src/sh_login_track.c

@@ -33 +33 @@
 #include "sh_string.h"
 #include "sh_tools.h"
+#include "sh_ipvx.h"
 #include "sh_error_min.h"
 
@@ -809 +810 @@
   char *p, *q;
   
-  if (is_numeric(host))
+  if (sh_ipvx_is_numeric(host))
     {
       p = sh_util_strdup(host);

trunk/src/sh_mail.c

@@ -62 +62 @@
 #include "sh_mail_int.h"
 #include "sh_nmail.h"
+#include "sh_ipvx.h"
 
 #undef  FIL__
@@ -1113 +1114 @@
   (void) fflush(connFile);
 
-  if (0 != is_numeric(sh.host.name))
+  if (0 != sh_ipvx_is_numeric(sh.host.name))
     {
       sl_snprintf(error_msg, sizeof(error_msg), "HELO [%s]", 
@@ -1125 +1126 @@
   report_smtp(error_msg);
 
-  if (0 != is_numeric(sh.host.name))
+  if (0 != sh_ipvx_is_numeric(sh.host.name))
     fprintf(connFile, _("HELO [%s]%c%c"), sh.host.name, 13, 10);
   else
@@ -1150 +1151 @@
     {
       (void) sl_strlcat (this_address, "@", 256);
-      if (0 != is_numeric(sh.host.name))
+      if (0 != sh_ipvx_is_numeric(sh.host.name))
         (void) sl_strlcat (this_address, _("example.com"), 256);
       else
@@ -1866 +1867 @@
   mx     * result;
   dnsrep * retval;
+  char   * address = NULL;
   char     errmsg[128];
-  size_t   len;
 
   SL_ENTER(_("return_mx"));
@@ -1884 +1885 @@
   else
     {
+      char numeric[SH_IP_BUF];
+
       if (domain != NULL)
         {
@@ -1904 +1907 @@
         }
 
-      SH_MUTEX_LOCK(mutex_resolv);
-
+      retval = NULL;
       host   = NULL;
-      retval = NULL;
 
       if (domain != NULL)
-        host = /*@-unrecog@*/sh_gethostbyname (domain)/*@+unrecog@*/;
-
-      if (host)
+        address = sh_ipvx_canonical(domain, numeric, sizeof(numeric));
+
+      if (address)
         {
           result       = SH_ALLOC (sizeof (mx));
@@ -1919 +1920 @@
           retval->count = 1;
           result->pref  = 0;
-          /*@-type@*/
-          len = strlen (host->h_name) + 1;
-          result->address = SH_ALLOC (len);
-          sl_strlcpy (result->address, host->h_name, len);
-          /*@+type@*/
-        }
-      SH_MUTEX_UNLOCK(mutex_resolv);
-
-      if (!host)
+
+          result->address = address;
+        }
+      else
         {
 #ifdef FIL__

trunk/src/sh_port2proc.c

@@ -62 +62 @@
 #include "sh_error_min.h"
 #include "sh_pthread.h"
+#include "sh_ipvx.h"
 
 #define FIL__  _("sh_port2proc.c")
@@ -325 +326 @@
 /* returns the command and fills the 'user' array 
  */
-static char * port2proc_query(char * file, int proto, 
-                              struct in_addr * saddr, int sport, 
+static char * port2proc_query(char * file, int proto, int domain,
+                              struct sh_sockaddr * saddr, int sport, 
                               unsigned long * pid, char * user, size_t userlen)
 {
@@ -338 +339 @@
   {
     char errmsg[256];
+    char siface[SH_IP_BUF];
+    sh_ipvx_ntoa(siface, sizeof(siface), saddr);
     sl_snprintf(errmsg, sizeof(errmsg), 
                 "query, file=%s, proto=%d, port=%d, iface=%s\n",
-                file, proto, sport, inet_ntoa(*saddr));
+                file, proto, sport, siface);
     fprintf(stderr, "%s", errmsg);
   }
@@ -347 +350 @@
   if (fd)
     {
-      unsigned int n, iface, port, inode, istatus;
+      unsigned int n, i, port, niface, inode, istatus;
       char line[512];
+      char iface[SH_IP_BUF];
 
       while (NULL != fgets(line, sizeof(line), fd))
@@ -360 +364 @@
 
           if (5 == sscanf(line, 
-                          "%u: %X:%X %*X:%*X %X %*X:%*X %*X:%*X %*X %*d %*d %u %*s",
-                          &n, &iface, &port, &istatus, &inode))
+                          "%u: %s:%X %*X:%*X %X %*X:%*X %*X:%*X %*X %*d %*d %u %*s",
+                          &n, iface, &port, &istatus, &inode))
             {
-              struct in_addr haddr;
-
-              haddr.s_addr = (unsigned long)iface;
+              struct sockaddr_in  addr4;
+              struct sockaddr_in6 addr6;
+              struct sh_sockaddr  ss;
+              
+              niface = 0;
+
+              switch (domain) 
+                {
+                case AF_INET:
+                  addr4.sin_addr.s_addr = (int) strtol(iface, NULL, 16);
+                  niface = (unsigned int) addr4.sin_addr.s_addr;
+                  sh_ipvx_save(&ss, AF_INET, (struct sockaddr *)&addr4);
+                  break;
+
+                case AF_INET6:
+                  sscanf(iface, 
+                         "%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx", 
+                         &addr6.sin6_addr.s6_addr[3], &addr6.sin6_addr.s6_addr[2], &addr6.sin6_addr.s6_addr[1], &addr6.sin6_addr.s6_addr[0], 
+                         &addr6.sin6_addr.s6_addr[7], &addr6.sin6_addr.s6_addr[6], &addr6.sin6_addr.s6_addr[5], &addr6.sin6_addr.s6_addr[4], 
+                         &addr6.sin6_addr.s6_addr[11], &addr6.sin6_addr.s6_addr[10], &addr6.sin6_addr.s6_addr[9], &addr6.sin6_addr.s6_addr[8], 
+                         &addr6.sin6_addr.s6_addr[15], &addr6.sin6_addr.s6_addr[14], &addr6.sin6_addr.s6_addr[13], &addr6.sin6_addr.s6_addr[12]);
+                  
+                  for (i = 0; i < 16; ++i)
+                    {
+                      if (0 != (unsigned int) addr6.sin6_addr.s6_addr[i]) 
+                        ++niface;
+                    }
+                  sh_ipvx_save(&ss, AF_INET6, (struct sockaddr *)&addr6);
+                  break;
+                }
 
 #ifdef DEBUG_P2P
               {
-                char a[32];
-                char b[32];
-
-                sl_strlcpy(a, inet_ntoa(haddr), sizeof(a));
-                sl_strlcpy(b, inet_ntoa(*saddr), sizeof(b));
+                char a[SH_IP_BUF];
+                char b[SH_IP_BUF];
+
+                sh_ipvx_ntoa(a, sizeof(a), &ss);
+                sh_ipvx_ntoa(b, sizeof(b), &ss);
 
                 fprintf(stderr, " -> inode %u, iface/port %s,%u, status %u, searching %s,%u, %u\n", 
@@ -392 +423 @@
 #endif
 
-              if ((proto == IPPROTO_UDP || iface == 0 || haddr.s_addr == saddr->s_addr) && port == (unsigned int)sport)
+              if ((proto == IPPROTO_UDP || niface == 0 || 0 == sh_ipvx_cmp(&ss, saddr)) && 
+                  port == (unsigned int)sport)
                 {
                   struct sock_store * new = socklist;
@@ -445 +477 @@
 /* returns the command and fills the 'user' array 
  */
-char * sh_port2proc_query(int proto, struct in_addr * saddr, int sport, 
+char * sh_port2proc_query(int proto, struct sh_sockaddr * saddr, int sport, 
                           unsigned long * pid, char * user, size_t userlen)
 {
   char file[32];
-
+  char * ret;
+ 
   if (proto == IPPROTO_TCP)
     {
       sl_strlcpy(file, _("/proc/net/tcp"), sizeof(file));
-      return port2proc_query(file, proto, saddr, sport, pid, user, userlen);
+      ret = port2proc_query(file, proto, AF_INET, saddr, sport, pid, user, userlen);
+
+      if (ret[0] == '-' && ret[1] == '\0')
+        {
+          SH_FREE(ret);
+          sl_strlcpy(file, _("/proc/net/tcp6"), sizeof(file));
+          ret = port2proc_query(file, proto, AF_INET6, saddr, sport, pid, user, userlen);
+        }
+      return ret;
     }
   else
@@ -459 +500 @@
       char * ret;
       sl_strlcpy(file, _("/proc/net/udp"), sizeof(file));
-      ret = port2proc_query(file, proto, saddr, sport, pid, user, userlen);
+      ret = port2proc_query(file, proto, AF_INET, saddr, sport, pid, user, userlen);
+
       if (ret[0] == '-' && ret[1] == '\0')
         {
           SH_FREE(ret);
           sl_strlcpy(file, _("/proc/net/udp6"), sizeof(file));
-          ret = port2proc_query(file, proto, saddr, sport, pid, user, userlen);
+          ret = port2proc_query(file, proto, AF_INET6, saddr, sport, pid, user, userlen);
         }
       return ret;
@@ -541 +583 @@
 
 static int       opt_4 = 1;         /* Show IPv4 sockets */
-static int       opt_6 = 0;         /* Show IPv6 sockets */
+static int       opt_6 = 1;         /* Show IPv6 sockets */
 static int       opt_c = 0;         /* Show connected sockets */
 static int       opt_l = 1;         /* Show listening sockets */
@@ -852 +894 @@
 }
 
-char * sh_port2proc_query(int proto, struct in_addr * saddr, int sport,
+char * sh_port2proc_query(int proto, struct sh_sockaddr * saddr, int sport,
                           unsigned long * pid, char * user, size_t userlen)
 {
   int n, hash;
   struct xfile *xf;
-  struct in_addr * haddr;
+  struct in_addr  * haddr;
+  struct in6_addr * haddr6;
   struct sock * s;
+  struct in6_addr   anyaddr = IN6ADDR_ANY_INIT; 
 
   *pid = 0;
@@ -886 +930 @@
       continue;
 
-    if (s->family != AF_INET /* && s->family != AF_INET6 */)
+    if (s->family != AF_INET && s->family != AF_INET6)
       continue;
 
-    if (sport != ntohs(((struct sockaddr_in *)(&s->laddr))->sin_port))
+    if (s->family == AF_INET &&
+        (sport != ntohs(((struct sockaddr_in *)(&s->laddr))->sin_port)))
       continue;
 
-    haddr = &((struct sockaddr_in *)(&s->laddr))->sin_addr;
+    if (s->family == AF_INET6 &&
+        (sport != ntohs(((struct sockaddr_in6 *)(&s->laddr))->sin6_port)))
+      continue;
+
+    if (s->family == AF_INET)
+      haddr  = &((struct sockaddr_in  *)(&s->laddr))->sin_addr;
+    if (s->family == AF_INET6)
+      haddr6 = &((struct sockaddr_in6 *)(&s->laddr))->sin6_addr;
+    
 
     /* fprintf(stderr, "FIXME: %s\n", inet_ntoa(*haddr)); */
     /* fprintf(stderr, "FIXME: %s\n", inet_ntoa(*saddr)); */
 
-    if (haddr->s_addr == saddr->s_addr || inet_lnaof(*saddr) == INADDR_ANY || inet_lnaof(*haddr) == INADDR_ANY)
+    if ( (s->family == AF_INET && 
+          (haddr->s_addr == (saddr->sin).sin_addr.s_addr || 
+           sh_ipvx_isany(saddr) || 
+           inet_lnaof(*haddr) == INADDR_ANY))
+         ||
+         (s->family == AF_INET6 &&
+          (0 == memcmp(haddr6->s6_addr, &((saddr->sin6).sin6_addr.s6_addr), 16) ||
+           0 == memcmp(haddr6->s6_addr, &(anyaddr.s6_addr), 16) ||
+           sh_ipvx_isany(saddr) ))
+         )
       {
         struct sock_store try;
@@ -975 +1037 @@
 #include "samhain.h"
 #include "sh_utils.h"
-
-char * sh_port2proc_query(int proto, struct in_addr * saddr, int sport,
+#include "sh_ipvx.h"
+
+char * sh_port2proc_query(int proto, struct sh_sockaddr * saddr, int sport,
                           unsigned long * pid, char * user, size_t userlen)
 {

trunk/src/sh_portcheck.c

@@ -74 +74 @@
 /* TIME_WAIT ? 60-240 seconds */
 
-/* the size of an interface string 
- */
-#define SH_INTERFACE_SIZE 16
-
-#define SH_PORT_NOT 0
-#define SH_PORT_REQ 1
-#define SH_PORT_OPT 2
-#define SH_PORT_IGN 3
-#define SH_PORT_BLACKLIST 4
-
-#define SH_PORT_MISS 0
-#define SH_PORT_ISOK 1
-#define SH_PORT_UNKN 2
-
-#define SH_PORT_NOREPT 0
-#define SH_PORT_REPORT 1
-
-#define SH_PROTO_TCP 0
-#define SH_PROTO_UDP 1
-#define SH_PROTO_STR(a) (((a) == IPPROTO_TCP) ? _("tcp") : _("udp"))
-
-struct sh_portentry {
-  int  port;
-  char interface[SH_INTERFACE_SIZE];
-  char * service;
-  char * error;
-  int  flag;    /* required or not */
-  int  status;  /* missing or not  */
-  struct sh_portentry * next;
-};
-
-static struct sh_portentry * portlist_tcp = NULL;
-static struct sh_portentry * portlist_udp = NULL;
-
-struct sh_port {
-  int              port;
-  struct in_addr   haddr;
-  struct sh_port * next;
-};
-
-static struct sh_port * blacklist_tcp = NULL;
-static struct sh_port * blacklist_udp = NULL;
-
-#define SH_PORTCHK_INTERVAL 300
-
-static int sh_portchk_check_udp = 1;
-static int sh_portchk_active    = 1;
-static int sh_portchk_interval  = SH_PORTCHK_INTERVAL;
 #if !defined(TEST_ONLY)
 
@@ -134 +86 @@
 #include "sh_static.h"
 #include "sh_pthread.h"
+#include "sh_ipvx.h"
+
+/* the size of an interface string 
+ */
+#define SH_INTERFACE_SIZE SH_IP_BUF
+
+#define SH_PORT_NOT 0
+#define SH_PORT_REQ 1
+#define SH_PORT_OPT 2
+#define SH_PORT_IGN 3
+#define SH_PORT_BLACKLIST 4
+
+#define SH_PORT_MISS 0
+#define SH_PORT_ISOK 1
+#define SH_PORT_UNKN 2
+
+#define SH_PORT_NOREPT 0
+#define SH_PORT_REPORT 1
+
+#define SH_PROTO_TCP 0
+#define SH_PROTO_UDP 1
+#define SH_PROTO_STR(a) (((a) == IPPROTO_TCP) ? _("tcp") : _("udp"))
+
+struct sh_portentry {
+  int  port;
+  char interface[SH_INTERFACE_SIZE];
+  char * service;
+  char * error;
+  int  flag;    /* required or not */
+  int  status;  /* missing or not  */
+  struct sh_portentry * next;
+};
+
+static struct sh_portentry * portlist_tcp = NULL;
+static struct sh_portentry * portlist_udp = NULL;
+
+
+#define SH_PORTCHK_INTERVAL 300
+
+static int sh_portchk_check_udp = 1;
+static int sh_portchk_active    = 1;
+static int sh_portchk_interval  = SH_PORTCHK_INTERVAL;
+
+struct sh_port {
+  int                  port;
+  struct sh_sockaddr * paddr;
+  struct sh_port     * next;
+};
+
+static struct sh_port * blacklist_tcp = NULL;
+static struct sh_port * blacklist_udp = NULL;
 
 SH_MUTEX_STATIC(mutex_port_check, PTHREAD_MUTEX_INITIALIZER);
@@ -139 +142 @@
 static int sh_portchk_severity  = SH_ERR_SEVERE;
 
-extern char * sh_port2proc_query(int proto, struct in_addr * saddr, int sport,
+extern char * sh_port2proc_query(int proto, struct sh_sockaddr * saddr, int sport,
                                  unsigned long * pid, char * user, size_t userlen);
 extern int sh_port2proc_prepare();
@@ -168 +171 @@
 /* verify whether port/interface is blacklisted (do not check)
  */
-static int sh_portchk_is_blacklisted(int port, struct in_addr haddr, int proto);
+static int sh_portchk_is_blacklisted(int port, struct sh_sockaddr * haddr, int proto);
 
 #ifndef TEST_ONLY
@@ -379 +382 @@
 
 static void sh_portchk_add_to_list (int proto, 
-                                    int port, struct in_addr haddr, 
+                                    int port, struct sh_sockaddr * paddr, 
                                     char * service,
                                     int flag, int status)
@@ -390 +393 @@
 
   new->port = port;
-  sl_strlcpy (new->interface, inet_ntoa(haddr), SH_INTERFACE_SIZE);
+  sh_ipvx_ntoa(new->interface, SH_INTERFACE_SIZE, paddr);
   new->status = status;
   new->flag   = flag;
@@ -459 +462 @@
         sh_portchk_kill_blacklist (head->next);
 
+      SH_FREE(head->paddr);
       SH_FREE(head);
     }
@@ -560 +564 @@
 
 static struct sh_portentry * sh_portchk_get_from_list (int proto, int port, 
-                                                       struct in_addr haddr, char * service)
+                                                       struct sh_sockaddr * paddr, char * service)
 {
   struct sh_portentry * portlist;
-  char iface_all[8];
-
-  sl_strlcpy (iface_all, _("0.0.0.0"), sizeof(iface_all));
-  
+  char str_addr[SH_IP_BUF];
+
   if (proto == IPPROTO_TCP)
     portlist = portlist_tcp;
@@ -572 +574 @@
     portlist = portlist_udp;
 
+  sh_ipvx_ntoa(str_addr, sizeof(str_addr), paddr);
+
   if (service)
     {
@@ -578 +582 @@
           if (portlist->service && 
               0 == strcmp(service, portlist->service) &&
-              (0 == strcmp(portlist->interface, inet_ntoa(haddr)) ||
-               0 == strcmp(portlist->interface, iface_all)))
+              ( 0 == strcmp(portlist->interface, str_addr) ||
+                sh_ipvx_isany(paddr) ))
             return portlist;
           portlist = portlist->next;
@@ -589 +593 @@
         {
           if (port == portlist->port &&
-              (0 == strcmp(portlist->interface, inet_ntoa(haddr)) ||
-               0 == strcmp(portlist->interface, iface_all)))
+              (0 == strcmp(portlist->interface, str_addr)  ||
+               sh_ipvx_isany(paddr) ))
             return portlist;
           portlist = portlist->next;
@@ -599 +603 @@
       
 
-static void sh_portchk_cmp_to_list (int proto, int port, struct in_addr haddr, char * service)
+static void sh_portchk_cmp_to_list (int proto, int port, struct sh_sockaddr * paddr, char * service)
 {
   struct sh_portentry * portent;
@@ -605 +609 @@
 
   
-  portent = sh_portchk_get_from_list (proto, port, haddr, service);
+  portent = sh_portchk_get_from_list (proto, port, paddr, service);
 
   if (service)
@@ -614 +618 @@
           unsigned long qpid;
           char   user[USER_MAX];
+          char   saddr[SH_IP_BUF];
+
+          sh_ipvx_ntoa(saddr, sizeof(saddr), paddr);
 
           snprintf (errbuf, sizeof(errbuf), _("port: %s:%d/%s (%s)"), 
-                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), service);
+                    saddr, port, SH_PROTO_STR(proto), service);
 #ifdef TEST_ONLY
           fprintf(stderr, _("open port: %s:%d/%s (%s)\n"), 
-                  inet_ntoa(haddr), port, SH_PROTO_STR(proto), service);
-#else
-          path = sh_port2proc_query(proto, &haddr, port, &qpid, user, sizeof(user));
+                  saddr, port, SH_PROTO_STR(proto), service);
+#else
+          path = sh_port2proc_query(proto, paddr, port, &qpid, user, sizeof(user));
           SH_MUTEX_LOCK(mutex_thread_nolog);
           sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0, 
@@ -631 +638 @@
            * was not there, thus it is not in 'required' or 'optional' list
            */
-          sh_portchk_add_to_list (proto, port, haddr, service, SH_PORT_NOT, SH_PORT_ISOK);
+          sh_portchk_add_to_list (proto, port, paddr, service, SH_PORT_NOT, SH_PORT_ISOK);
         }
       else if (portent->status == SH_PORT_MISS && portent->flag != SH_PORT_IGN)
@@ -638 +645 @@
           unsigned long qpid;
           char   user[USER_MAX];
+          char   saddr[SH_IP_BUF];
+
+          sh_ipvx_ntoa(saddr, sizeof(saddr), paddr);
 
           snprintf (errbuf, sizeof(errbuf), _("port: %s:%d/%s (%s), was %d/%s"), 
-                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), service, portent->port, SH_PROTO_STR(proto));
+                    saddr, port, SH_PROTO_STR(proto), service, portent->port, SH_PROTO_STR(proto));
 #ifdef TEST_ONLY
           fprintf(stderr, _("service: %s\n"), errbuf);
 #else
-          path = sh_port2proc_query(proto, &haddr, port, &qpid, user, sizeof(user));
+          path = sh_port2proc_query(proto, paddr, port, &qpid, user, sizeof(user));
           SH_MUTEX_LOCK(mutex_thread_nolog);
           sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0, 
@@ -659 +669 @@
           unsigned long qpid;
           char   user[USER_MAX];
+          char   saddr[SH_IP_BUF];
+
+          sh_ipvx_ntoa(saddr, sizeof(saddr), paddr);
 
           snprintf (errbuf, sizeof(errbuf), _("port: %s:%d/%s (%s), was %d/%s"), 
-                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), service, portent->port, SH_PROTO_STR(proto));
+                    saddr, port, SH_PROTO_STR(proto), service, portent->port, SH_PROTO_STR(proto));
 #ifdef TEST_ONLY
           fprintf(stderr, _("service: %s\n"), errbuf);
 #else
-          path = sh_port2proc_query(proto, &haddr, port, &qpid, user, sizeof(user));
+          path = sh_port2proc_query(proto, paddr, port, &qpid, user, sizeof(user));
           SH_MUTEX_LOCK(mutex_thread_nolog);
           sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0, 
@@ -687 +700 @@
           unsigned long qpid;
           char   user[USER_MAX];
+          char   saddr[SH_IP_BUF];
+
+          sh_ipvx_ntoa(saddr, sizeof(saddr), paddr);
 
           snprintf (errbuf, sizeof(errbuf), _("port: %s:%d/%s (%s)"), 
-                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), check_services(port, proto));
+                    saddr, port, SH_PROTO_STR(proto), check_services(port, proto));
 #ifdef TEST_ONLY
           fprintf(stderr, _("open port: %s:%d/%s (%s)\n"), 
-                  inet_ntoa(haddr), port, SH_PROTO_STR(proto), check_services(port, proto));
-#else
-          path = sh_port2proc_query(proto, &haddr, port, &qpid, user, sizeof(user));
+                  saddr, port, SH_PROTO_STR(proto), check_services(port, proto));
+#else
+          path = sh_port2proc_query(proto, paddr, port, &qpid, user, sizeof(user));
           SH_MUTEX_LOCK(mutex_thread_nolog);
           sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0, 
@@ -704 +720 @@
           /* was not there, thus it is not in 'required' or 'optional' list
            */
-          sh_portchk_add_to_list (proto, port, haddr, service, SH_PORT_NOT, SH_PORT_ISOK);
+          sh_portchk_add_to_list (proto, port, paddr, service, SH_PORT_NOT, SH_PORT_ISOK);
         }
       else if (portent->status == SH_PORT_MISS && portent->flag != SH_PORT_IGN)
@@ -711 +727 @@
           unsigned long qpid;
           char   user[USER_MAX];
+          char   saddr[SH_IP_BUF];
+
+          sh_ipvx_ntoa(saddr, sizeof(saddr), paddr);
 
           snprintf (errbuf, sizeof(errbuf), _("port: %s:%d/%s (%s)"), 
-                    inet_ntoa(haddr), port, SH_PROTO_STR(proto), check_services(port, proto));
+                    saddr, port, SH_PROTO_STR(proto), check_services(port, proto));
 #ifdef TEST_ONLY
           fprintf(stderr, _("port   : %s\n"), errbuf);
 #else
-          path = sh_port2proc_query(proto, &haddr, port, &qpid, user, sizeof(user));
+          path = sh_port2proc_query(proto, paddr, port, &qpid, user, sizeof(user));
           SH_MUTEX_LOCK(mutex_thread_nolog);
           sh_error_handle(sh_portchk_severity, FIL__, __LINE__, 0, 
@@ -799 +818 @@
 }
 
-static int check_port_udp_internal (int fd, int port, struct in_addr haddr)
-{
-  struct sockaddr_in sinr;
-  /* struct in_addr     haddr; */
+static int check_port_udp_internal (int fd, int port, struct sh_sockaddr * paddr)
+{
   int                retval;
-  char             * p;
+  char             * p = NULL;
   char               buf[8];
 #ifndef TEST_ONLY
@@ -811 +828 @@
 #endif
   char errbuf[SH_ERRBUF_SIZE];
-
-  /* inet_aton(interface, &haddr); */
-
-  sinr.sin_family = AF_INET;
-  sinr.sin_port   = htons (port);
-  sinr.sin_addr   = haddr;
+  char ipbuf[SH_IP_BUF];
+
+  sh_ipvx_set_port(paddr, port);
 
   do {
-    retval = connect(fd, (struct sockaddr *) &sinr, sizeof(sinr));
+    retval = connect(fd, sh_ipvx_sockaddr_cast(paddr), SH_SSP_LEN(paddr));
   } while (retval < 0 && (errno == EINTR || errno == EINPROGRESS));
 
@@ -828 +842 @@
         perror(_("connect"));
 #else
+      sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
+
       nerr = errno;
       sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/udp on %15s: %s"),
-                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
+                  port, ipbuf, sh_error_message(errno, errbuf, sizeof(errbuf)));
       SH_MUTEX_LOCK(mutex_thread_nolog);
       sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN, 
@@ -845 +861 @@
       if (retval == -1 && errno == ECONNREFUSED)
         {
+          sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
           if (portchk_debug)
             fprintf(stderr, _("check port: %5d/udp on %15s established/time_wait\n"),
-                    port, inet_ntoa(haddr));
+                    port, ipbuf);
         }
       else 
@@ -859 +876 @@
           if (retval == -1 && errno == ECONNREFUSED)
             {
+              sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
               if (portchk_debug)
                 fprintf(stderr, _("check port: %5d/udp on %15s established/time_wait\n"),
-                        port, inet_ntoa(haddr));
+                        port, ipbuf);
             }
           else if (retval != -1)
@@ -867 +885 @@
               /* Try to get service name from portmap
                */
-              p = check_rpc_list (port, &sinr, IPPROTO_UDP);
+              if (paddr->ss_family == AF_INET)
+                {
+                  p = check_rpc_list (port, (struct sockaddr_in *) sh_ipvx_sockaddr_cast(paddr), IPPROTO_UDP);
+                }
               
-              sh_portchk_cmp_to_list (IPPROTO_UDP, port, haddr, p ? p : NULL);
+              sh_portchk_cmp_to_list (IPPROTO_UDP, port, paddr, p ? p : NULL);
               
               /* If not an RPC service, try to get name from /etc/services
@@ -877 +898 @@
               
               if (portchk_debug)
-                fprintf(stderr, _("check port: %5d/udp on %15s open %s\n"), 
-                        port, inet_ntoa(haddr), p);
+                {
+                  sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
+                  fprintf(stderr, _("check port: %5d/udp on %15s open %s\n"), 
+                          port, ipbuf, p);
+                }
               
             }
@@ -887 +911 @@
 }
 
-static int check_port_tcp_internal (int fd, int port, struct in_addr haddr)
-{
-  struct sockaddr_in sinr;
-  /* struct in_addr     haddr; */
+static int check_port_tcp_internal (int fd, int port, struct sh_sockaddr * paddr)
+{
   int                retval;
   int                flags;
-  char             * p;
+  char             * p = NULL;
 #ifndef TEST_ONLY
   char               errmsg[256];
@@ -899 +921 @@
 #endif
   char errbuf[SH_ERRBUF_SIZE];
-
-  /* inet_aton(interface, &haddr); */
-
-  sinr.sin_family = AF_INET;
-  sinr.sin_port   = htons (port);
-  sinr.sin_addr   = haddr;
+  char ipbuf[SH_IP_BUF];
+
+  sh_ipvx_set_port(paddr, port);
 
   do {
-    retval = connect(fd, (struct sockaddr *) &sinr, sizeof(sinr));
+    retval = connect(fd, sh_ipvx_sockaddr_cast(paddr), SH_SSP_LEN(paddr));
   } while (retval < 0 && (errno == EINTR || errno == EINPROGRESS));
 
@@ -913 +932 @@
     {
       if (portchk_debug)
-        fprintf(stderr, _("check port: %5d on %15s established/time_wait\n"),
-                port, inet_ntoa(haddr));
+        {
+          sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
+          fprintf(stderr, _("check port: %5d on %15s established/time_wait\n"),
+                  port, ipbuf);
+        }
     }
   else if (retval == -1)
@@ -922 +944 @@
         perror(_("connect"));
 #else
+      sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
       nerr = errno;
       sl_snprintf(errmsg, sizeof(errmsg), _("check port: %5d/tcp on %15s: %s"),
-                  port, inet_ntoa(haddr), sh_error_message(errno, errbuf, sizeof(errbuf)));
+                  port, ipbuf, sh_error_message(errno, errbuf, sizeof(errbuf)));
       SH_MUTEX_LOCK(mutex_thread_nolog);
       sh_error_handle((-1), FIL__, __LINE__, nerr, MSG_E_SUBGEN, 
@@ -935 +958 @@
       /* Try to get service name from portmap
        */
-      p = check_rpc_list (port, &sinr, IPPROTO_TCP);
-
-      sh_portchk_cmp_to_list (IPPROTO_TCP, port, haddr, p ? p : NULL);
+      if (paddr->ss_family == AF_INET)
+        {
+          p = check_rpc_list (port, (struct sockaddr_in *) sh_ipvx_sockaddr_cast(paddr), IPPROTO_TCP);
+        }
+
+      sh_portchk_cmp_to_list (IPPROTO_TCP, port, paddr, p ? p : NULL);
 
       /* If not an RPC service, try to get name from /etc/services
@@ -945 +971 @@
 
       if (portchk_debug)
-        fprintf(stderr, _("check port: %5d on %15s open %s\n"), 
-                port, inet_ntoa(haddr), p);
+        {
+          sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), paddr);
+          fprintf(stderr, _("check port: %5d on %15s open %s\n"), 
+                  port, ipbuf, p);
+        }
 
 #if !defined(O_NONBLOCK)
@@ -1011 +1040 @@
 
 struct portchk_interfaces {
-  struct in_addr iface[SH_IFACE_MAX];
+  struct sh_sockaddr iface[SH_IFACE_MAX];
   int            used;
 };
@@ -1026 +1055 @@
 static int sh_portchk_init_internal (void)
 {
-  struct hostent * hent;
   volatile int     i; /* might be clobbered by ‘longjmp’ or ‘vfork’*/
   char errbuf[256];
+#if defined(USE_IPVX)
+  struct addrinfo hints;
+  struct addrinfo *res;
+#else
+  struct hostent * hent;
+#endif
+  char ipbuf[SH_IP_BUF];
 
   if (portchk_debug)
@@ -1045 +1080 @@
       iface_initialized = 1;
     }
-            
+
+#if !defined(USE_IPVX)
   SH_MUTEX_LOCK(mutex_resolv);
   hent = sh_gethostbyname(portchk_hostname);
@@ -1051 +1087 @@
   while (hent && hent->h_addr_list[i] && (iface_list.used < SH_IFACE_MAX))
     {
-      memcpy (&(iface_list.iface[iface_list.used].s_addr), hent->h_addr_list[i], sizeof(in_addr_t));
+      struct sockaddr_in sin;
+
+      memcpy(&(sin.sin_addr.s_addr), hent->h_addr_list[i], sizeof(in_addr_t));
+      sh_ipvx_save(&(iface_list.iface[iface_list.used]), 
+                   AF_INET, (struct sockaddr *)&sin);
       ++iface_list.used;
       ++i;
     }
   SH_MUTEX_UNLOCK(mutex_resolv);
+#else
+  memset(&hints, '\0', sizeof(hints));
+  hints.ai_family = PF_UNSPEC;
+  hints.ai_flags  = AI_ADDRCONFIG;
+
+  if (0 == getaddrinfo(portchk_hostname, NULL, &hints, &res))
+    {
+      struct addrinfo *p = res;
+
+      while ((p != NULL) && (iface_list.used < SH_IFACE_MAX))
+        {
+          sh_ipvx_save(&(iface_list.iface[iface_list.used]), 
+                       p->ai_family, p->ai_addr);
+          ++iface_list.used;
+          p = p->ai_next;
+        }
+      freeaddrinfo(res);
+    } 
+#endif
 
   for (i = 0; i < iface_list.used; ++i)
     {
-      sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"), 
-                  inet_ntoa(iface_list.iface[i]));
+      sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), &(iface_list.iface[i]));
+      sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"), ipbuf);
+
       SH_MUTEX_LOCK(mutex_thread_nolog);
       sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN, 
@@ -1136 +1196 @@
 #endif
 
-static int check_port_generic (int port, int type, int protocol)
+static int check_port_generic (int port, int domain, int type, int protocol)
 {
   volatile int     i    =  0;
   int              sock = -1;
   int              flag =  1; /* non-zero to enable an option */
-  struct in_addr   haddr;
+  struct sh_sockaddr   paddr;
   char errbuf[SH_ERRBUF_SIZE];
 
@@ -1148 +1208 @@
   while (i < iface_list.used)
     {
-      haddr.s_addr = iface_list.iface[i].s_addr;
-
-      if (0 != sh_portchk_is_blacklisted(port, haddr, protocol))
-        {
-          ++i; continue;
-        }
-
-      if ((sock = socket(AF_INET, type, protocol)) < 0 )
+      memcpy(&paddr, &(iface_list.iface[i]), sizeof(paddr));
+
+      if (paddr.ss_family != domain)
+        {
+          ++i;
+          continue;
+        }
+
+      if (0 != sh_portchk_is_blacklisted(port, &paddr, protocol))
+        {
+          ++i; 
+          continue;
+        }
+
+      if ((sock = socket(paddr.ss_family, type, protocol)) < 0 )
         {
           ++i;
@@ -1187 +1254 @@
 
       if (protocol == IPPROTO_TCP)
-        check_port_tcp_internal(sock, port, haddr);
+        check_port_tcp_internal(sock, port, &paddr);
       else
-        check_port_udp_internal(sock, port, haddr);
+        check_port_udp_internal(sock, port, &paddr);
 
       ++i;
@@ -1199 +1266 @@
 
 
-static int check_port_udp (int port)
-{
-  return check_port_generic(port, SOCK_DGRAM, IPPROTO_UDP);
-}
-
-static int check_port_tcp (int port)
-{
-  return check_port_generic(port, SOCK_STREAM, IPPROTO_TCP);
-}
-
-
-
-static int sh_portchk_scan_ports_generic (int min_port, int max_port_arg, int type, int protocol)
+static int check_port_udp (int port, int domain)
+{
+  return check_port_generic(port, domain, SOCK_DGRAM, IPPROTO_UDP);
+}
+
+static int check_port_tcp (int port, int domain)
+{
+  return check_port_generic(port, domain, SOCK_STREAM, IPPROTO_TCP);
+}
+
+
+static int sh_portchk_scan_ports_generic (int min_port, int max_port_arg, 
+                                          int domain, int type, int protocol)
 {
   /*
@@ -1224 +1291 @@
   int flag   = 1; /* non-zero to enable an option */
 
-  struct sockaddr_in addr;
-  int addrlen      = sizeof(addr);
+  struct sockaddr_in  addr4;
+  struct sockaddr_in6 addr6;
+
+  int addrlen4      = sizeof(addr4);
+  int addrlen6      = sizeof(addr6);
+
+  struct in6_addr anyaddr = IN6ADDR_ANY_INIT; 
+
   char errbuf[SH_ERRBUF_SIZE];
 
@@ -1235 +1308 @@
   for (port = min_port; port <= max_port; ++port) 
     {
-      if ((sock = socket(AF_INET, type, protocol)) < 0 )
+      if ((sock = socket(domain, type, protocol)) < 0 )
         {
 #ifdef TEST_ONLY
@@ -1263 +1336 @@
         }
 
-      addr.sin_family      = AF_INET;
-      addr.sin_port        = htons(port);
-      addr.sin_addr.s_addr = INADDR_ANY;
-
-      retval = bind (sock, (struct sockaddr *) &addr, addrlen);
+      if (domain == AF_INET)
+        {
+          addr4.sin_family      = AF_INET;
+          addr4.sin_port        = htons(port);
+          addr4.sin_addr.s_addr = INADDR_ANY;
+          retval = bind (sock, (struct sockaddr *) &addr4, addrlen4);
+        }
+      else
+        {
+          addr6.sin6_family       = AF_INET6;
+          addr6.sin6_port         = htons(port);
+          memcpy(&(addr6.sin6_addr.s6_addr), &anyaddr, sizeof(anyaddr));
+          retval = bind (sock, (struct sockaddr *) &addr6, addrlen6);
+        }
 
       if (retval == 0)
@@ -1282 +1364 @@
                */
               if (protocol == IPPROTO_TCP)
-                check_port_tcp(port);
+                check_port_tcp(port, domain);
               else
-                check_port_udp(port);
+                check_port_udp(port, domain);
             }
           else
@@ -1306 +1388 @@
 static int sh_portchk_scan_ports_tcp (int min_port, int max_port)
 {
-  return sh_portchk_scan_ports_generic (min_port, max_port, SOCK_STREAM, IPPROTO_TCP);
+#if defined(USE_IPVX)
+  sh_portchk_scan_ports_generic (min_port, max_port, AF_INET6, 
+                                 SOCK_STREAM, IPPROTO_TCP);
+#endif
+  return sh_portchk_scan_ports_generic (min_port, max_port, AF_INET, 
+                                        SOCK_STREAM, IPPROTO_TCP);
 }
  
 static int sh_portchk_scan_ports_udp (int min_port, int max_port)
 {
-  return sh_portchk_scan_ports_generic (min_port, max_port, SOCK_DGRAM, IPPROTO_UDP);
+#if defined(USE_IPVX)
+  sh_portchk_scan_ports_generic (min_port, max_port, AF_INET6, 
+                                 SOCK_DGRAM, IPPROTO_UDP);
+#endif
+  return sh_portchk_scan_ports_generic (min_port, max_port, AF_INET,
+                                        SOCK_DGRAM, IPPROTO_UDP);
 }
 
@@ -1320 +1412 @@
 static int sh_portchk_add_interface (const char * str)
 {
-  struct in_addr   haddr;
+  struct sh_sockaddr saddr;
   char errbuf[256];
   char buf[64];
@@ -1338 +1430 @@
     if (*str)
       {
+        char ipbuf[SH_IP_BUF];
         unsigned int i = 0;
-        while (*str && i < (sizeof(buf)-1) && *str != ',' && *str != ' ' && *str != '\t')
+        while (*str && i < (sizeof(buf)-1) && 
+               *str != ',' && *str != ' ' && *str != '\t')
           {
             buf[i] = *str; ++str; ++i;
@@ -1345 +1439 @@
         buf[i] = '\0';
 
-        if (0 == inet_aton(buf, &haddr))
+        if (0 == sh_ipvx_aton(buf, &saddr))
           return -1;
 
@@ -1351 +1445 @@
           return -1;
 
-        sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"), inet_ntoa(haddr));
+        sh_ipvx_ntoa(ipbuf, sizeof(ipbuf), &saddr);
+        sl_snprintf(errbuf, sizeof(errbuf), _("interface: %s"), ipbuf);
         SH_MUTEX_LOCK(mutex_thread_nolog);
         sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN, 
@@ -1357 +1452 @@
         SH_MUTEX_UNLOCK(mutex_thread_nolog);
         
-        memcpy (&(iface_list.iface[iface_list.used].s_addr), &(haddr.s_addr), sizeof(in_addr_t));
+        memcpy (&(iface_list.iface[iface_list.used]), &(saddr), sizeof(saddr));
         ++iface_list.used;
       }
@@ -1367 +1462 @@
 /* verify whether port/interface is blacklisted (do not check)
  */
-static int sh_portchk_is_blacklisted(int port, struct in_addr haddr, int proto)
+static int sh_portchk_is_blacklisted(int port, struct sh_sockaddr * saddr, 
+                                     int proto)
 {
   struct sh_port * head;
@@ -1380 +1476 @@
       if (head->port == port)
         {
-          if ((head->haddr.s_addr == 0) || (head->haddr.s_addr == haddr.s_addr))
+          if (sh_ipvx_isany(head->paddr) || 
+              0 == sh_ipvx_cmp(head->paddr, saddr))
             return 1;
           else
@@ -1391 +1488 @@
 
 
-static int sh_portchk_blacklist(int port, struct in_addr haddr, int proto)
+static int sh_portchk_blacklist(int port, struct sh_sockaddr * saddr, int proto)
 {
   struct sh_port * black;
@@ -1405 +1502 @@
   while (black)
     {
-      if (black->port == port && head->haddr.s_addr == haddr.s_addr)
+      if (black->port == port && 
+          0 == sh_ipvx_cmp(head->paddr, saddr))
         return -1;
       black = black->next;
     }
+
   black = SH_ALLOC (sizeof(struct sh_port));
+  black->paddr = SH_ALLOC (sizeof(struct sh_sockaddr));
   black->port  = port;
-  black->haddr.s_addr = haddr.s_addr;
+  memcpy(black->paddr, saddr, sizeof(struct sh_sockaddr));
   black->next  = head;
 
@@ -1424 +1524 @@
 /* Subroutine to add a required or optional port/service
  */
-static int sh_portchk_add_required_port_generic (char * service, char * interface, int type)
+static int sh_portchk_add_required_port_generic (char * service, 
+                                                 char * interface, int type)
 {
   char buf[256];
@@ -1431 +1532 @@
   char * endptr;
   unsigned long int  port;
-  struct in_addr   haddr;
+  struct sh_sockaddr   saddr;
   struct sh_portentry * portent;
 
-  if (0 == inet_aton(interface, &haddr))
+  if (0 == sh_ipvx_aton(interface, &saddr))
     return -1;
 
@@ -1455 +1556 @@
    */
   if (*endptr == '\0' && port <= 65535 && type == SH_PORT_BLACKLIST)
-    return (sh_portchk_blacklist(port, haddr, proto));
+    return (sh_portchk_blacklist(port, &saddr, proto));
 
   if (*endptr != '\0')
     {  
-      portent = sh_portchk_get_from_list (proto, -1, haddr, buf);
+      portent = sh_portchk_get_from_list (proto, -1, &saddr, buf);
       if (!portent)
-        sh_portchk_add_to_list (proto,   -1, haddr,  buf, type, SH_PORT_UNKN);
+        sh_portchk_add_to_list (proto,   -1, &saddr,  buf, type, SH_PORT_UNKN);
       else
         {
@@ -1477 +1578 @@
   else if (port <= 65535)
     {
-      portent = sh_portchk_get_from_list (proto, port, haddr, NULL);
+      portent = sh_portchk_get_from_list (proto, port, &saddr, NULL);
       if (!portent)
-        sh_portchk_add_to_list (proto, port, haddr, NULL, type, SH_PORT_UNKN);
+        sh_portchk_add_to_list (proto, port, &saddr, NULL, type, SH_PORT_UNKN);
       else
         {
@@ -1669 +1770 @@
 {
 #if defined(SH_USE_PORTCHECK) && (defined(SH_WITH_CLIENT) || defined(SH_STANDALONE))
-  struct in_addr   haddr_local;
+  struct sh_sockaddr    haddr_local;
   struct sh_portentry * portent;
   char   buf[256];
@@ -1704 +1805 @@
   CuAssertTrue(tc, 0 == strcmp(buf, "daytime"));
 
-  CuAssertTrue(tc, 0 != inet_aton("127.0.0.1", &haddr_local));
-
-  sh_portchk_add_to_list (IPPROTO_TCP,  8000, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
-
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, NULL);
+  CuAssertTrue(tc, 0 != sh_ipvx_aton("127.0.0.1", &haddr_local));
+
+  sh_portchk_add_to_list (IPPROTO_TCP,  8000, &haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
+
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, NULL);
   CuAssertPtrNotNull(tc, portent);
 
@@ -1720 +1821 @@
   CuAssertTrue(tc, NULL == portlist_tcp);
 
-  sh_portchk_add_to_list (IPPROTO_TCP,  8000, haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,  8001, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,  8002, haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,  8003, haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,  8004, haddr_local, NULL, SH_PORT_IGN, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo1", SH_PORT_NOT, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo2", SH_PORT_REQ, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo3", SH_PORT_NOT, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo4", SH_PORT_REQ, SH_PORT_UNKN);
-  sh_portchk_add_to_list (IPPROTO_TCP,    -1, haddr_local, "foo5", SH_PORT_IGN, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,  8000, &haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,  8001, &haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,  8002, &haddr_local, NULL, SH_PORT_REQ, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,  8003, &haddr_local, NULL, SH_PORT_NOT, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,  8004, &haddr_local, NULL, SH_PORT_IGN, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,    -1, &haddr_local, "foo1", SH_PORT_NOT, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,    -1, &haddr_local, "foo2", SH_PORT_REQ, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,    -1, &haddr_local, "foo3", SH_PORT_NOT, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,    -1, &haddr_local, "foo4", SH_PORT_REQ, SH_PORT_UNKN);
+  sh_portchk_add_to_list (IPPROTO_TCP,    -1, &haddr_local, "foo5", SH_PORT_IGN, SH_PORT_UNKN);
 
   sh_portchk_check_list (&portlist_tcp, IPPROTO_TCP, SH_PORT_NOREPT);
@@ -1735 +1836 @@
   CuAssertPtrNotNull(tc, portlist_tcp);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, NULL);
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, NULL);
   CuAssertPtrNotNull(tc, portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8001, haddr_local, NULL);
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8001, &haddr_local, NULL);
   CuAssertTrue(tc, NULL == portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8002, haddr_local, NULL);
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8002, &haddr_local, NULL);
   CuAssertPtrNotNull(tc, portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8003, haddr_local, NULL);
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8003, &haddr_local, NULL);
   CuAssertTrue(tc, NULL == portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8004, haddr_local, NULL);
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8004, &haddr_local, NULL);
   CuAssertPtrNotNull(tc, portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo1");
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, "foo1");
   CuAssertTrue(tc, NULL == portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo2");
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, "foo2");
   CuAssertPtrNotNull(tc, portent);
   CuAssertTrue(tc, 0 == strcmp(portent->service, "foo2"));
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo3");
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, "foo3");
   CuAssertTrue(tc, NULL == portent);
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo4");
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, "foo4");
   CuAssertPtrNotNull(tc, portent);
   CuAssertTrue(tc, 0 == strcmp(portent->service, "foo4"));
 
-  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, haddr_local, "foo5");
+  portent = sh_portchk_get_from_list(IPPROTO_TCP,  8000, &haddr_local, "foo5");
   CuAssertPtrNotNull(tc, portent);
   CuAssertTrue(tc, 0 == strcmp(portent->service, "foo5"));
 
-  CuAssertTrue(tc, 0 == sh_portchk_blacklist(666, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 != sh_portchk_blacklist(666, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 == sh_portchk_blacklist(667, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 == sh_portchk_blacklist(668, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 == sh_portchk_blacklist(666, haddr_local, IPPROTO_UDP));
-  CuAssertTrue(tc, 0 != sh_portchk_blacklist(666, haddr_local, IPPROTO_UDP));
-  CuAssertTrue(tc, 0 == sh_portchk_blacklist(667, haddr_local, IPPROTO_UDP));
-  CuAssertTrue(tc, 0 == sh_portchk_blacklist(668, haddr_local, IPPROTO_UDP));
-
-  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(668, haddr_local, IPPROTO_UDP));
-  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(667, haddr_local, IPPROTO_UDP));
-  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(666, haddr_local, IPPROTO_UDP));
-  CuAssertTrue(tc, 0 == sh_portchk_is_blacklisted(665, haddr_local, IPPROTO_UDP));
-
-  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(668, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(667, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(666, haddr_local, IPPROTO_TCP));
-  CuAssertTrue(tc, 0 == sh_portchk_is_blacklisted(665, haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 == sh_portchk_blacklist(666, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 != sh_portchk_blacklist(666, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 == sh_portchk_blacklist(667, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 == sh_portchk_blacklist(668, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 == sh_portchk_blacklist(666, &haddr_local, IPPROTO_UDP));
+  CuAssertTrue(tc, 0 != sh_portchk_blacklist(666, &haddr_local, IPPROTO_UDP));
+  CuAssertTrue(tc, 0 == sh_portchk_blacklist(667, &haddr_local, IPPROTO_UDP));
+  CuAssertTrue(tc, 0 == sh_portchk_blacklist(668, &haddr_local, IPPROTO_UDP));
+
+  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(668, &haddr_local, IPPROTO_UDP));
+  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(667, &haddr_local, IPPROTO_UDP));
+  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(666, &haddr_local, IPPROTO_UDP));
+  CuAssertTrue(tc, 0 == sh_portchk_is_blacklisted(665, &haddr_local, IPPROTO_UDP));
+
+  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(668, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(667, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 != sh_portchk_is_blacklisted(666, &haddr_local, IPPROTO_TCP));
+  CuAssertTrue(tc, 0 == sh_portchk_is_blacklisted(665, &haddr_local, IPPROTO_TCP));
 #else
   (void) tc; /* fix compiler warning */

trunk/src/sh_registry.c

@@ -447 +447 @@
 }
 
+#if !defined(KEY_WOW64_64KEY)
+#define KEY_WOW64_64KEY 0x0100;
+#endif
+#if !defined(KEY_WOW64_32KEY)
+#define KEY_WOW64_32KEY 0x0200;
+#endif
 
 
@@ -790 +796 @@
 
 
-int CheckThisSubkey (HKEY key, char * subkey, char * path, int isSingle)
+int CheckThisSubkey (HKEY key, char * subkey, char * path, int isSingle,
+                     int view)
 {
   HKEY hTestKey;
@@ -826 +833 @@
                     subkey,
                     0,
-                    KEY_READ,
+                    (KEY_READ | view),
                     &hTestKey) == ERROR_SUCCESS
       )
@@ -867 +874 @@
   char path[20] = "";
   int pos = 0;
+  int retval = -1;
   
   if      (0 == strncmp(key, _("HKEY_CLASSES_ROOT"), 17))
@@ -924 +932 @@
       return -1;
     }
-  
-  return CheckThisSubkey (topKey, subkey, path, isSingle);
+
+  /************************  
+  if (ShCheckBothViews)
+    {
+      CheckThisSubkey (topKey, subkey, path, isSingle, KEY_WOW64_32KEY);
+      return CheckThisSubkey (topKey, subkey, path, isSingle, KEY_WOW64_64KEY);
+    }
+  *************************/
+
+  return CheckThisSubkey (topKey, subkey, path, isSingle, 0);
 }
 

trunk/src/sh_socket.c

@@ -557 +557 @@
   char message[SH_MAXMSG];
   struct sockaddr_un name;
-  int size;
+  ACCEPT_TYPE_ARG3 size = sizeof(name);
+
   int nbytes;
   int talkfd;
@@ -636 +637 @@
    * 'name' is the address of the sender socket
    */
-  size = sizeof (name);
-  talkfd = retry_accept(FIL__, __LINE__, 
-                        pf_unix_fd, (struct sockaddr *) & name, &size);
+  do {
+    talkfd = accept(pf_unix_fd, (struct sockaddr *) &name, &size);
+  } while (talkfd < 0 && errno == EINTR);
+
   if ((talkfd < 0) && (errno == EAGAIN))
     {

trunk/src/sh_tools.c

@@ -89 +89 @@
 #include "sh_static.h"
 #include "sh_pthread.h"
+#include "sh_ipvx.h"
 
 #undef  FIL__
@@ -127 +128 @@
 int sh_tools_iface_is_present(char *str)
 {
+#if defined(USE_IPVX)
+  struct addrinfo *ai;
+  struct addrinfo hints;
+  int             res;
+
+  memset (&hints, '\0', sizeof (hints));
+  hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
+  hints.ai_socktype = SOCK_STREAM;
+  res = getaddrinfo (str, _("2543"), &hints, &ai);
+  
+  if (res == 0)
+    {
+      struct addrinfo *p = ai;
+      while (p != NULL)
+        {
+          int fd = socket (p->ai_family, p->ai_socktype,
+                           p->ai_protocol);
+
+          if (fd < 0)
+            {
+              freeaddrinfo (ai);
+              return 0;
+            }
+
+          if (bind (fd, p->ai_addr, p->ai_addrlen) != 0)
+            {
+              /* bind() fails for access reasons, iface exists
+               */
+              if (errno == EACCES || errno == EADDRINUSE)
+                {
+                  sl_close_fd (FIL__, __LINE__, fd);
+                  freeaddrinfo (ai);
+                  return 1;
+                }
+
+              sl_close_fd (FIL__, __LINE__, fd);
+              freeaddrinfo (ai);
+              return 0;
+            }
+
+          sl_close_fd (FIL__, __LINE__, fd);
+          freeaddrinfo (ai);
+          return 1;
+          /* p = p->ai_next; */ 
+        }
+    }
+#else
   struct sockaddr_in sin;
   int sd;
@@ -158 +206 @@
       return 1;
     }
+#endif
   return 0;
 }
@@ -428 +477 @@
 }
 
-int is_numeric (const char * address)
-{
-  int j;
-  int len = sl_strlen(address);
-  
-  for (j = 0; j < len; ++j)
-    if ( (address[j] < '0' || address[j] > '9') && address[j] != '.')
-      return (1 == 0);
-  return (1 == 1);
-}
-
 #if defined (SH_WITH_SERVER)
 
@@ -468 +506 @@
 typedef struct _sin_cache {
   char * address;
-  struct sockaddr_in sin;
+  struct sh_sockaddr  saddr;
   struct _sin_cache * next;
 } sin_cache;
@@ -503 +541 @@
 }
 
+#if !defined(USE_IPVX)
 int connect_port (char * address, int port, 
                   char * ecall, int * errnum, char * errmsg, int errsiz)
@@ -537 +576 @@
                                address, sl_strlen(address)))
             {
-              memcpy (&sinr, &(check_cache->sin), sizeof(struct sockaddr_in));
+              memcpy (&sinr, &((check_cache->saddr).sin), sizeof(struct sockaddr_in));
               sinr.sin_family = AF_INET;
               sinr.sin_port   = htons (port);
@@ -657 +696 @@
           check_cache->address = SH_ALLOC(sl_strlen(address) + 1);
           sl_strlcpy (check_cache->address, address, sl_strlen(address) + 1);
-          memcpy(&(check_cache->sin), &sinr, sizeof(struct sockaddr_in));
+
+          sh_ipvx_save(&(check_cache->saddr), AF_INET, (struct sockaddr *) &sinr);
+
           ++cached_addr;
           
@@ -710 +751 @@
   SL_RETURN(retval, _("connect_port"));
 }
+#else
+int connect_port (char * address, int port, 
+                  char * ecall, int * errnum, char * errmsg, int errsiz)
+{
+  struct sockaddr_in *sin;
+  struct sockaddr_in6 *sin6;
+  struct sh_sockaddr ss;
+  sin_cache * check_cache = conn_cache;
+  int    cached = 0;
+  int    fail   = 0;
+  int    fd     = -1;
+  int    status = 0;
+
+  int    retval;
+  char   errbuf[SH_ERRBUF_SIZE];
+
+  SL_ENTER(_("connect_port"));
+
+  /* paranoia -- should not happen
+   */
+  if (cached_addr > 128)
+    delete_cache();
+
+  if (check_cache != NULL)
+    {
+      while (check_cache && check_cache->address)
+        {
+          if ( 0 == sl_strncmp(check_cache->address, 
+                               address, sl_strlen(address)))
+            {
+              memcpy (&ss, &(check_cache->saddr), sizeof(struct sh_sockaddr));
+              switch (ss.ss_family) 
+                {
+                case AF_INET:
+                  sin = &(ss.sin);
+                  sin->sin_port   = htons (port);
+                case AF_INET6:
+                  sin6 = &(ss.sin6);
+                  sin6->sin6_port  = htons (port);
+                }
+              cached = 1;
+              break;
+            }
+          if (check_cache->next)
+            check_cache = check_cache->next;
+          else
+            check_cache = NULL;
+        }
+    }
+
+  if (cached != 0)
+    {
+      fd = socket(ss.ss_family, SOCK_STREAM, 0);
+      if (fd < 0) 
+        {
+          status = errno;
+          fail   = (-1);
+          sl_strlcpy(ecall, _("socket"), SH_MINIBUF);
+          *errnum = status;
+          sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
+          sl_strlcat(errmsg, _(", address "), errsiz);
+          sl_strlcat(errmsg, address, errsiz);
+        }
+    
+  
+      if (fail != (-1)) 
+        {
+          int addrlen = SH_SS_LEN(ss);
+        
+          if ( retry_connect(FIL__, __LINE__, fd, 
+                             sh_ipvx_sockaddr_cast(&ss), addrlen) < 0) 
+            {
+              status = errno;
+              sl_strlcpy(ecall, _("connect"), SH_MINIBUF);
+              *errnum = status;
+              sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
+              sl_strlcat(errmsg, _(", address "), errsiz);
+              sl_strlcat(errmsg, address, errsiz);
+              sl_close_fd(FIL__, __LINE__, fd);
+              fail = (-1); 
+            }
+        }
+
+      if (fail != 0)
+        {
+          delete_cache();
+          cached = 0;
+        }
+    }
+
+  if (cached == 0)
+    {
+      int    res;
+      char   sport[32];
+      struct addrinfo *ai;
+      struct addrinfo hints;
+
+      memset (&hints, '\0', sizeof (hints));
+      hints.ai_flags = AI_ADDRCONFIG;
+#if defined(AI_CANONNAME)
+      hints.ai_flags |= AI_CANONNAME;
+#endif 
+      hints.ai_socktype = SOCK_STREAM;
+      sl_snprintf(sport, sizeof(sport), "%d", port);
+
+      res = getaddrinfo (address, sport, &hints, &ai);
+      if (res != 0)
+        {
+          fail = (-1);
+          status = errno;
+          sl_strlcpy(ecall, _("getaddrinfo"), SH_MINIBUF);
+          *errnum = status;
+          sl_strlcpy(errmsg, gai_strerror (res), errsiz);
+          sl_strlcat(errmsg, _(", address "), errsiz);
+          sl_strlcat(errmsg, address, errsiz);
+        }
+
+      if (fail != (-1) && (DoReverseLookup == S_TRUE) && !sh_ipvx_is_numeric(address))
+        {
+          struct addrinfo *p = ai;
+          int    success = 0;
+          char hostname[SH_BUFSIZE];
+          const char * canonical;
+
+#if defined(AI_CANONNAME)
+          if (ai->ai_canonname && strlen(ai->ai_canonname) > 0)
+            {
+              canonical = ai->ai_canonname;
+            }
+          else
+            {
+              canonical = address;
+            }
+#else
+          canonical = address;
+#endif
+
+          while (p != NULL)
+            {
+              int e = getnameinfo (p->ai_addr, p->ai_addrlen, 
+                                   hostname, sizeof(hostname),
+                                   NULL, 0, NI_NAMEREQD);
+              
+              if (e == 0)
+                {
+                  if (sl_strcasecmp(hostname, canonical) == 0)
+                    {
+                      success = 1;
+                      break;
+                    }
+                }
+            
+              p = p->ai_next;
+            }
+
+          if (success == 0)
+            {
+              sl_strlcpy(ecall, _("strcmp"), SH_MINIBUF);
+              sl_strlcpy(errmsg, _("Reverse lookup failed: "), 
+                         errsiz);
+              sl_strlcat(errmsg, address, errsiz);
+              fail = -1;
+              freeaddrinfo (ai);
+            }
+        }
+
+      if (fail != (-1))
+        {
+          struct addrinfo *p = ai;
+
+          while (p != NULL)
+            {
+              fd = socket(p->ai_family, p->ai_socktype,
+                          p->ai_protocol);
+
+              if (fd != (-1))
+                {
+                  if (retry_connect(FIL__, __LINE__, fd, 
+                                    p->ai_addr, p->ai_addrlen) >= 0)
+                    {
+                      /* put it into the cache
+                       */
+                      check_cache          = SH_ALLOC(sizeof(sin_cache));
+                      check_cache->address = SH_ALLOC(sl_strlen(address) + 1);
+                      sl_strlcpy (check_cache->address, address, sl_strlen(address) + 1);
+
+                      sh_ipvx_save(&(check_cache->saddr), p->ai_family, p->ai_addr);
+
+                      ++cached_addr;
+          
+                      if (conn_cache)
+                        {
+                          if (conn_cache->next)
+                            check_cache->next    = conn_cache->next;
+                          else
+                            check_cache->next    = NULL;
+                          conn_cache->next     = check_cache;
+                        }
+                      else
+                        {
+                          check_cache->next    = NULL;
+                          conn_cache           = check_cache;
+                        }
+                    
+                      freeaddrinfo (ai);
+                      goto end;
+                    }
+                  status = errno;
+                  sl_close_fd(FIL__, __LINE__, fd);
+                }
+              else
+                {
+                  status = errno;
+                }
+              p = p->ai_next;
+            }
+          fail = (-1);
+          freeaddrinfo (ai);
+
+          sl_strlcpy(ecall, _("connect"), SH_MINIBUF);
+          *errnum = status;
+          sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
+          sl_strlcat(errmsg, _(", address "), errsiz);
+          sl_strlcat(errmsg, address, errsiz);
+        }
+    }
+
+ end:
+  retval = (fail < 0) ? (-1) : fd;
+  SL_RETURN(retval, _("connect_port"));
+
+}
+#endif
 
 int connect_port_2 (char * address1, char * address2, int port, 

trunk/src/sh_unix.c

@@ -98 +98 @@
 #include "sh_hash.h"
 #include "sh_tools.h"
+#include "sh_ipvx.h"
 #include "sh_tiger.h"
 #include "sh_prelink.h"
@@ -1605 +1606 @@
 {
   struct utsname   buf;
-  struct hostent * he1;
   int              i;
   int              ddot;
@@ -1611 +1611 @@
   char           * p;
   char             hostname[256];
+  char             numeric[SH_IP_BUF];
+  char           * canonical;
 
 
@@ -1656 +1658 @@
     }
 
-  SH_MUTEX_LOCK(mutex_resolv);
-  he1 = sh_gethostbyname(hostname);
-
-  if (he1 != NULL)
-    {
-      sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
-      sh_tolower (sh.host.name);
-    }
-  SH_MUTEX_UNLOCK(mutex_resolv);
-
-  if (he1 == NULL)
-    {
-      dlog(1, FIL__, __LINE__, 
-           _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN. For more information, see the entry about self-resolving under 'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
-           hostname);
+  canonical = sh_ipvx_canonical(hostname, numeric, sizeof(numeric));
+
+  if (canonical == NULL)
+    {
       sl_strlcpy (sh.host.name, hostname,    SH_PATHBUF);
       sh_tolower (sh.host.name);
     }
-  
+  else
+    {
+      sl_strlcpy (sh.host.name, canonical,   SH_PATHBUF);
+      SH_FREE(canonical);
+    }
 
   /* check whether it looks like a FQDN
@@ -1683 +1678 @@
     if (sh.host.name[i] == '.') ++ddot; 
 
-  if (ddot == 0 && he1 != NULL)
+  if (ddot == 0)
     { 
       dlog(1, FIL__, __LINE__, 
            _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nRather, it resolves this to %s.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
            hostname, sh.host.name);
-      sl_strlcpy (sh.host.name, 
-                  inet_ntoa (*(struct in_addr *) he1->h_addr), 
-                  SH_PATHBUF);
+      sl_strlcpy (sh.host.name, numeric, SH_PATHBUF);
       SL_RET0(_("sh_unix_localhost"));
     } 
 
-  if (is_numeric(sh.host.name)) 
+  if (sh_ipvx_is_numeric(sh.host.name)) 
     {
       dlog(1, FIL__, __LINE__, 
@@ -1717 +1710 @@
   struct utsname   buf;
 #endif
-  struct hostent * he1;
   int              i;
   int              ddot;
   int              len;
   char             hostname[1024];
-
+  char             numeric[SH_IP_BUF];
+  char           * canonical;
 
   SL_ENTER(_("sh_unix_localhost"));
@@ -1737 +1730 @@
   hostname[1023] = '\0';
 
-  SH_MUTEX_LOCK(mutex_resolv);
-  he1 = sh_gethostbyname(hostname);
-
-  if (he1 != NULL)
-    {
-      sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
+  canonical = sh_ipvx_canonical(hostname, numeric, sizeof(numeric));
+
+  if (canonical == NULL)
+    {
+      sl_strlcpy (sh.host.name, hostname, SH_PATHBUF);
       sh_tolower (sh.host.name);
     }
-  SH_MUTEX_UNLOCK(mutex_resolv);
-
-  if (he1 == NULL)
-    {
-      dlog(1, FIL__, __LINE__, 
-           _("According to gethostname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
-           hostname);
-      sl_strlcpy (sh.host.name, _("localhost"), SH_PATHBUF);
-      SL_RET0(_("sh_unix_localhost"));
+  else
+    {
+      sl_strlcpy (sh.host.name, canonical,   SH_PATHBUF);
+      SH_FREE(canonical);
     }
 
@@ -1767 +1754 @@
            _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nRather, it resolves this to %s.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
            hostname, sh.host.name);
-      sl_strlcpy (sh.host.name, 
-                  inet_ntoa (*(struct in_addr *) he1->h_addr), 
-                  SH_PATHBUF);
+      sl_strlcpy (sh.host.name, numeric, SH_PATHBUF);
       SL_RET0(_("sh_unix_localhost"));
     }
 
-  if (is_numeric(sh.host.name)) 
+  if (sh_ipvx_is_numeric(sh.host.name)) 
     {
       dlog(1, FIL__, __LINE__, 

trunk/src/sh_utmp.c

@@ -179 +179 @@
   char                name[UT_NAMESIZE+1];
   char                ut_host[UT_HOSTSIZE+1];
-  char                ut_ship[16]; /* IP address */
+  char                ut_ship[SH_IP_BUF]; /* IP address */
   time_t              time;
   struct log_user   * next;
@@ -454 +454 @@
 
 #ifdef HAVE_UTADDR
-#ifdef HAVE_INET_ATON
-static char * my_inet_ntoa(struct in_addr in)
-{
-  return /*@-unrecog@*/inet_ntoa(in)/*@+unrecog@*/;
-}
-#else
-static char * my_inet_ntoa(struct in_addr in)
-{
-  unsigned char a, b, c, d;
-  static char   foo[16];
-  char          bar[4];
-  memcpy (bar, &(in.s_addr), 4); /* memory alignment (?) */
-  memcpy (&a, &bar[0], 1);
-  memcpy (&b, &bar[1], 1);
-  memcpy (&c, &bar[2], 1);
-  memcpy (&d, &bar[3], 1);
-  sprintf(foo, _("%d.%d.%d.%d"),                        /* known to fit  */
-          (int) a, (int) b, (int) c, (int) d);
-  return foo;
+#ifdef HAVE_UTADDR_V6
+static char * my_inet_ntoa(SINT32 * ut_addr_v6, char * buf, size_t buflen)
+{
+  struct in_addr in;
+
+  buf[0] = '\0';
+
+  if (0 == (ut_addr_v6[1] + ut_addr_v6[2] + ut_addr_v6[3]))
+    {
+      memcpy(&in, ut_addr_v6, sizeof(struct in_addr));
+      sl_strlcpy(buf, inet_ntoa(in), buflen);
+    }
+  else
+    {
+      inet_ntop(AF_INET6, ut_addr_v6, buf, buflen);
+    }
+  return buf;
+}
+#else
+static char * my_inet_ntoa(SINT32 ut_addr, char * buf, size_t buflen)
+{
+  struct in_addr in;
+
+  buf[0] = '\0';
+
+  memcpy(&in, ut_addr, sizeof(struct in_addr));
+  sl_strlcpy(buf, inet_ntoa(in), buflen);
+  return buf;
 }
 #endif
@@ -915 +924 @@
 #endif
 #ifdef HAVE_UTADDR
-      /*@-type@*//* ut_addr does exist !!! */
-      {
-        struct in_addr saddr;
-        memcpy (&saddr, &(ut->ut_addr), sizeof(struct in_addr));
-        (void) sl_strlcpy((char*)(user->ut_ship), 
-                          my_inet_ntoa(saddr), 16);
-      }
-      /*@+type@*/
+#ifdef HAVE_UTADDR_V6
+      my_inet_ntoa(ut->ut_addr_v6, user->ut_ship, SH_IP_BUF);
+#else
+      my_inet_ntoa(ut->ut_addr, user->ut_ship, SH_IP_BUF);
+#endif
 #endif
       user->time = ut->ut_time;
@@ -1059 +1065 @@
 #endif
 #ifdef HAVE_UTADDR
-      sl_strlcpy(user->ut_ship,my_inet_ntoa((struct in_addr)ut->ut_addr),16);
+#ifdef HAVE_UTADDR_V6
+      my_inet_ntoa(ut->ut_addr_v6, user->ut_ship, SH_IP_BUF);
+#else
+      my_inet_ntoa(ut->ut_addr, user->ut_ship, SH_IP_BUF);
+#endif
 #endif
       user->time       = ut->ut_time;