Merge pull request #1563 from jacobbaungard/ipv6_check_icmp

check_icmp: Add IPv6 support

1 files changed, 336 insertions, 129 deletions

diff --git a/plugins-root/check_icmp.c b/plugins-root/check_icmp.c
index 4098874..e45fdf6 100644
--- a/plugins-root/check_icmp.c
+++ b/plugins-root/check_icmp.c
@@ -67,7 +67,9 @@ const char *email = "devel@monitoring-plugins.org";
 #include <netinet/in_systm.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>
+#include <netinet/ip6.h>
 #include <netinet/ip_icmp.h>
+#include <netinet/icmp6.h>
 #include <arpa/inet.h>
 #include <signal.h>
 #include <float.h>
@@ -113,8 +115,8 @@ typedef struct rta_host {
         unsigned short id;           /* id in **table, and icmp pkts */
         char *name;                  /* arg used for adding this host */
         char *msg;                   /* icmp error message, if any */
-        struct sockaddr_in saddr_in; /* the address of this host */
-        struct in_addr error_addr;   /* stores address of error replies */
+        struct sockaddr_storage saddr_in;     /* the address of this host */
+        struct sockaddr_storage error_addr;   /* stores address of error replies */
         unsigned long long time_waited; /* total time waited, in usecs */
         unsigned int icmp_sent, icmp_recv, icmp_lost; /* counters */
         unsigned char icmp_type, icmp_code; /* type and code from errors */
@@ -140,6 +142,18 @@ typedef struct icmp_ping_data {
         unsigned short ping_id;
 } icmp_ping_data;
 
+typedef union ip_hdr {
+        struct ip ip;
+        struct ip6_hdr ip6;
+} ip_hdr;
+
+typedef union icmp_packet {
+        void *buf;
+        struct icmp *icp;
+        struct icmp6_hdr *icp6;
+        u_short *cksum_in;
+} icmp_packet;
+
 /* the different modes of this program are as follows:
  * MODE_RTA: send all packets no matter what (mimic check_icmp and check_ping)
  * MODE_HOSTCHECK: Return immediately upon any sign of life
@@ -190,8 +204,9 @@ static int get_threshold(char *str, threshold *th);
 static void run_checks(void);
 static void set_source_ip(char *);
 static int add_target(char *);
-static int add_target_ip(char *, struct in_addr *);
-static int handle_random_icmp(unsigned char *, struct sockaddr_in *);
+static int add_target_ip(char *, struct sockaddr_storage *);
+static int handle_random_icmp(unsigned char *, struct sockaddr_storage *);
+static void parse_address(struct sockaddr_storage *, char *, int);
 static unsigned short icmp_checksum(unsigned short *, int);
 static void finish(int);
 static void crash(const char *, ...);
@@ -300,7 +315,7 @@ get_icmp_error_msg(unsigned char icmp_type, unsigned char icmp_code)
 }
 
 static int
-handle_random_icmp(unsigned char *packet, struct sockaddr_in *addr)
+handle_random_icmp(unsigned char *packet, struct sockaddr_storage *addr)
 {
         struct icmp p, sent_icmp;
         struct rta_host *host = NULL;
@@ -342,9 +357,11 @@ handle_random_icmp(unsigned char *packet, struct sockaddr_in *addr)
         /* it is indeed a response for us */
         host = table[ntohs(sent_icmp.icmp_seq)/packets];
         if(debug) {
+                char address[INET6_ADDRSTRLEN];
+                parse_address(addr, address, sizeof(address));
                 printf("Received \"%s\" from %s for ICMP ECHO sent to %s.\n",
-                           get_icmp_error_msg(p.icmp_type, p.icmp_code),
-                           inet_ntoa(addr->sin_addr), host->name);
+                        get_icmp_error_msg(p.icmp_type, p.icmp_code),
+                        address, host->name);
         }
 
         icmp_lost++;
@@ -364,11 +381,23 @@ handle_random_icmp(unsigned char *packet, struct sockaddr_in *addr)
         }
         host->icmp_type = p.icmp_type;
         host->icmp_code = p.icmp_code;
-        host->error_addr.s_addr = addr->sin_addr.s_addr;
+        host->error_addr = *addr;
 
         return 0;
 }
 
+void parse_address(struct sockaddr_storage *addr, char *address, int size)
+{
+        switch (address_family) {
+        case AF_INET:
+                inet_ntop(address_family, &((struct sockaddr_in *)addr)->sin_addr, address, size);
+        break;
+        case AF_INET6:
+                inet_ntop(address_family, &((struct sockaddr_in6 *)addr)->sin6_addr, address, size);
+        break;
+        }
+}
+
 int
 main(int argc, char **argv)
 {
@@ -381,6 +410,7 @@ main(int argc, char **argv)
 #ifdef SO_TIMESTAMP
         int on = 1;
 #endif
+        char * opts_str = "vhVw:c:n:p:t:H:s:i:b:I:l:m:64";
 
         setlocale (LC_ALL, "");
         bindtextdomain (PACKAGE, LOCALEDIR);
@@ -390,33 +420,8 @@ main(int argc, char **argv)
          * that before pointer magic (esp. on network data) */
         icmp_sockerrno = udp_sockerrno = tcp_sockerrno = sockets = 0;
 
-        if((icmp_sock = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP)) != -1)
-                sockets |= HAVE_ICMP;
-        else icmp_sockerrno = errno;
-
-        /* if((udp_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1) */
-        /*      sockets |= HAVE_UDP; */
-        /* else udp_sockerrno = errno; */
-
-        /* if((tcp_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) != -1) */
-        /*      sockets |= HAVE_TCP; */
-        /* else tcp_sockerrno = errno; */
-
-        /* now drop privileges (no effect if not setsuid or geteuid() == 0) */
-        setuid(getuid());
-
-#ifdef SO_TIMESTAMP
-        if(setsockopt(icmp_sock, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)))
-          if(debug) printf("Warning: no SO_TIMESTAMP support\n");
-#endif // SO_TIMESTAMP
-
-        /* POSIXLY_CORRECT might break things, so unset it (the portable way) */
-        environ = NULL;
-
-        /* use the pid to mark packets as ours */
-        /* Some systems have 32-bit pid_t so mask off only 16 bits */
-        pid = getpid() & 0xffff;
-        /* printf("pid = %u\n", pid); */
+        address_family = -1;
+        int icmp_proto = IPPROTO_ICMP;
 
         /* get calling name the old-fashioned way for portability instead
          * of relying on the glibc-ism __progname */
@@ -456,20 +461,35 @@ main(int argc, char **argv)
                 packets = 5;
         }
 
-        /* Parse extra opts if any */
-        argv=np_extra_opts(&argc, argv, progname);
-
-        /* support "--help" and "--version" */
-        if(argc == 2) {
-                if(!strcmp(argv[1], "--help"))
-                        strcpy(argv[1], "-h");
-                if(!strcmp(argv[1], "--version"))
-                        strcpy(argv[1], "-V");
+        /* Parse protocol arguments first */
+        for(i = 1; i < argc; i++) {
+                while((arg = getopt(argc, argv, opts_str)) != EOF) {
+                        unsigned short size;
+                        switch(arg) {
+                        case '4':
+                                if (address_family != -1)
+                                        crash("Multiple protocol versions not supported");
+                                address_family = AF_INET;
+                                break;
+                        case '6':
+#ifdef USE_IPV6
+                                if (address_family != -1)
+                                        crash("Multiple protocol versions not supported");
+                                address_family = AF_INET6;
+#else
+                                usage (_("IPv6 support not available\n"));
+#endif
+                                break;
+                        }
+                }
         }
 
+        /* Reset argument scanning */
+        optind = 1;
+
         /* parse the arguments */
         for(i = 1; i < argc; i++) {
-                while((arg = getopt(argc, argv, "vhVw:c:n:p:t:H:s:i:b:I:l:m:")) != EOF) {
+                while((arg = getopt(argc, argv, opts_str)) != EOF) {
                         unsigned short size;
                         switch(arg) {
                         case 'v':
@@ -530,10 +550,30 @@ main(int argc, char **argv)
                         case 'h': /* help */
                                 print_help ();
                                 exit (STATE_UNKNOWN);
+                                break;
                         }
                 }
         }
 
+        /* POSIXLY_CORRECT might break things, so unset it (the portable way) */
+        environ = NULL;
+
+        /* use the pid to mark packets as ours */
+        /* Some systems have 32-bit pid_t so mask off only 16 bits */
+        pid = getpid() & 0xffff;
+        /* printf("pid = %u\n", pid); */
+
+        /* Parse extra opts if any */
+        argv=np_extra_opts(&argc, argv, progname);
+
+        /* support "--help" and "--version" */
+        if(argc == 2) {
+                if(!strcmp(argv[1], "--help"))
+                        strcpy(argv[1], "-h");
+                if(!strcmp(argv[1], "--version"))
+                        strcpy(argv[1], "-V");
+        }
+
         argv = &argv[optind];
         while(*argv) {
                 add_target(*argv);
@@ -545,6 +585,30 @@ main(int argc, char **argv)
                 exit(3);
         }
 
+        // add_target might change address_family
+        switch ( address_family ){
+                case AF_INET:   icmp_proto = IPPROTO_ICMP;
+                                break;
+                case AF_INET6:  icmp_proto = IPPROTO_ICMPV6;
+                                break;
+                default:        crash("Address family not supported");
+        }
+        if((icmp_sock = socket(address_family, SOCK_RAW, icmp_proto)) != -1)
+                sockets |= HAVE_ICMP;
+        else icmp_sockerrno = errno;
+
+
+#ifdef SO_TIMESTAMP
+        if(setsockopt(icmp_sock, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on)))
+          if(debug) printf("Warning: no SO_TIMESTAMP support\n");
+#endif // SO_TIMESTAMP
+
+        /* now drop privileges (no effect if not setsuid or geteuid() == 0) */
+        if (setuid(getuid()) == -1) {
+                printf("ERROR: Failed to drop privileges\n");
+                return 1;
+        }
+
         if(!sockets) {
                 if(icmp_sock == -1) {
                         errno = icmp_sockerrno;
@@ -633,7 +697,7 @@ main(int argc, char **argv)
         }
 
         host = list;
-        table = malloc(sizeof(struct rta_host **) * targets);
+        table = (struct rta_host**)malloc(sizeof(struct rta_host **) * targets);
         i = 0;
         while(host) {
                 host->id = i*packets;
@@ -697,9 +761,15 @@ run_checks()
         }
 }
 
+
 /* response structure:
+ * IPv4:
  * ip header   : 20 bytes
  * icmp header : 28 bytes
+ * IPv6:
+ * ip header   : 40 bytes
+ * icmp header : 28 bytes
+ * both:
  * icmp echo reply : the rest
  */
 static int
@@ -707,16 +777,27 @@ wait_for_reply(int sock, u_int t)
 {
         int n, hlen;
         static unsigned char buf[4096];
-        struct sockaddr_in resp_addr;
-        struct ip *ip;
-        struct icmp icp;
+        struct sockaddr_storage resp_addr;
+        union ip_hdr *ip;
+        union icmp_packet packet;
         struct rta_host *host;
         struct icmp_ping_data data;
         struct timeval wait_start, now;
         u_int tdiff, i, per_pkt_wait;
 
+        if (!(packet.buf = malloc(icmp_pkt_size))) {
+                crash("send_icmp_ping(): failed to malloc %d bytes for send buffer",
+                        icmp_pkt_size);
+                return -1;      /* might be reached if we're in debug mode */
+        }
+
+        memset(packet.buf, 0, icmp_pkt_size);
+
         /* if we can't listen or don't have anything to listen to, just return */
-        if(!t || !icmp_pkts_en_route) return 0;
+        if(!t || !icmp_pkts_en_route) {
+                free(packet.buf);
+                return 0;
+        }
 
         gettimeofday(&wait_start, &tz);
 
@@ -735,7 +816,7 @@ wait_for_reply(int sock, u_int t)
 
                 /* reap responses until we hit a timeout */
                 n = recvfrom_wto(sock, buf, sizeof(buf),
-                                                 (struct sockaddr *)&resp_addr, &t, &now);
+                                         (struct sockaddr *)&resp_addr, &t, &now);
                 if(!n) {
                         if(debug > 1) {
                                 printf("recvfrom_wto() timed out during a %u usecs wait\n",
@@ -745,12 +826,23 @@ wait_for_reply(int sock, u_int t)
                 }
                 if(n < 0) {
                         if(debug) printf("recvfrom_wto() returned errors\n");
+                        free(packet.buf);
                         return n;
                 }
 
-                ip = (struct ip *)buf;
-                if(debug > 1) printf("received %u bytes from %s\n",
-                                                 ntohs(ip->ip_len), inet_ntoa(resp_addr.sin_addr));
+                // FIXME: with ipv6 we don't have an ip header here
+                if (address_family != AF_INET6) {
+                        ip = (union ip_hdr *)buf;
+
+                        if(debug > 1) {
+                                char address[INET6_ADDRSTRLEN];
+                                parse_address(&resp_addr, address, sizeof(address));
+                                printf("received %u bytes from %s\n",
+                                        address_family == AF_INET6 ? ntohs(ip->ip6.ip6_plen)
+                                                                   : ntohs(ip->ip.ip_len),
+                                        address);
+                        }
+                }
 
 /* obsolete. alpha on tru64 provides the necessary defines, but isn't broken */
 /* #if defined( __alpha__ ) && __STDC__ && !defined( __GLIBC__ ) */
@@ -759,12 +851,14 @@ wait_for_reply(int sock, u_int t)
                  * off the bottom 4 bits */
 /*              hlen = (ip->ip_vhl & 0x0f) << 2; */
 /* #else */
-                hlen = ip->ip_hl << 2;
+                hlen = (address_family == AF_INET6) ? 0 : ip->ip.ip_hl << 2;
 /* #endif */
 
                 if(n < (hlen + ICMP_MINLEN)) {
+                        char address[INET6_ADDRSTRLEN];
+                        parse_address(&resp_addr, address, sizeof(address));
                         crash("received packet too short for ICMP (%d bytes, expected %d) from %s\n",
-                                  n, hlen + icmp_pkt_size, inet_ntoa(resp_addr.sin_addr));
+                                  n, hlen + icmp_pkt_size, address);
                 }
                 /* else if(debug) { */
                 /*      printf("ip header size: %u, packet size: %u (expected %u, %u)\n", */
@@ -773,23 +867,39 @@ wait_for_reply(int sock, u_int t)
                 /* } */
 
                 /* check the response */
-                memcpy(&icp, buf + hlen, sizeof(icp));
 
-                if(ntohs(icp.icmp_id) != pid || icp.icmp_type != ICMP_ECHOREPLY ||
-                   ntohs(icp.icmp_seq) >= targets*packets) {
+                memcpy(packet.buf, buf + hlen, icmp_pkt_size);
+/*                      address_family == AF_INET6 ? sizeof(struct icmp6_hdr)
+                                                   : sizeof(struct icmp));*/
+
+                if(   (address_family == PF_INET &&
+                        (ntohs(packet.icp->icmp_id) != pid || packet.icp->icmp_type != ICMP_ECHOREPLY
+                         || ntohs(packet.icp->icmp_seq) >= targets * packets))
+                   || (address_family == PF_INET6 &&
+                        (ntohs(packet.icp6->icmp6_id) != pid || packet.icp6->icmp6_type != ICMP6_ECHO_REPLY
+                        || ntohs(packet.icp6->icmp6_seq) >= targets * packets))) {
                         if(debug > 2) printf("not a proper ICMP_ECHOREPLY\n");
                         handle_random_icmp(buf + hlen, &resp_addr);
                         continue;
                 }
 
                 /* this is indeed a valid response */
-                memcpy(&data, icp.icmp_data, sizeof(data));
-                if (debug > 2)
-                        printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n",
-                               (unsigned long)sizeof(data), ntohs(icp.icmp_id),
-                               ntohs(icp.icmp_seq), icp.icmp_cksum);
+                if (address_family == PF_INET) {
+                        memcpy(&data, packet.icp->icmp_data, sizeof(data));
+                        if (debug > 2)
+                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n",
+                                        (unsigned long)sizeof(data), ntohs(packet.icp->icmp_id),
+                                        ntohs(packet.icp->icmp_seq), packet.icp->icmp_cksum);
+                        host = table[ntohs(packet.icp->icmp_seq)/packets];
+                } else {
+                        memcpy(&data, &packet.icp6->icmp6_dataun.icmp6_un_data8[4], sizeof(data));
+                        if (debug > 2)
+                                printf("ICMP echo-reply of len %lu, id %u, seq %u, cksum 0x%X\n",
+                                        (unsigned long)sizeof(data), ntohs(packet.icp6->icmp6_id),
+                                        ntohs(packet.icp6->icmp6_seq), packet.icp6->icmp6_cksum);
+                        host = table[ntohs(packet.icp6->icmp6_seq)/packets];
+                }
 
-                host = table[ntohs(icp.icmp_seq)/packets];
                 tdiff = get_timevaldiff(&data.stime, &now);
 
                 host->time_waited += tdiff;
@@ -801,22 +911,25 @@ wait_for_reply(int sock, u_int t)
                         host->rtmin = tdiff;
 
                 if(debug) {
+                        char address[INET6_ADDRSTRLEN];
+                        parse_address(&resp_addr, address, sizeof(address));
                         printf("%0.3f ms rtt from %s, outgoing ttl: %u, incoming ttl: %u, max: %0.3f, min: %0.3f\n",
-                                   (float)tdiff / 1000, inet_ntoa(resp_addr.sin_addr),
-                                   ttl, ip->ip_ttl, (float)host->rtmax / 1000, (float)host->rtmin / 1000);
+                                (float)tdiff / 1000, address,
+                                ttl, ip->ip.ip_ttl, (float)host->rtmax / 1000, (float)host->rtmin / 1000);
                 }
 
                 /* if we're in hostcheck mode, exit with limited printouts */
                 if(mode == MODE_HOSTCHECK) {
                         printf("OK - %s responds to ICMP. Packet %u, rta %0.3fms|"
-                                   "pkt=%u;;0;%u rta=%0.3f;%0.3f;%0.3f;;\n",
-                                   host->name, icmp_recv, (float)tdiff / 1000,
-                                   icmp_recv, packets, (float)tdiff / 1000,
-                                   (float)warn.rta / 1000, (float)crit.rta / 1000);
+                                "pkt=%u;;0;%u rta=%0.3f;%0.3f;%0.3f;;\n",
+                                host->name, icmp_recv, (float)tdiff / 1000,
+                                icmp_recv, packets, (float)tdiff / 1000,
+                                (float)warn.rta / 1000, (float)crit.rta / 1000);
                         exit(STATE_OK);
                 }
         }
 
+        free(packet.buf);
         return 0;
 }
 
@@ -824,62 +937,81 @@ wait_for_reply(int sock, u_int t)
 static int
 send_icmp_ping(int sock, struct rta_host *host)
 {
-        static union {
-                void *buf; /* re-use so we prevent leaks */
-                struct icmp *icp;
-                u_short *cksum_in;
-        } packet = { NULL };
         long int len;
         struct icmp_ping_data data;
         struct msghdr hdr;
         struct iovec iov;
         struct timeval tv;
-        struct sockaddr *addr;
+        void *buf = NULL;
 
         if(sock == -1) {
                 errno = 0;
                 crash("Attempt to send on bogus socket");
                 return -1;
         }
-        addr = (struct sockaddr *)&host->saddr_in;
 
-        if(!packet.buf) {
-                if (!(packet.buf = malloc(icmp_pkt_size))) {
+        if(!buf) {
+                if (!(buf = malloc(icmp_pkt_size))) {
                         crash("send_icmp_ping(): failed to malloc %d bytes for send buffer",
                                   icmp_pkt_size);
                         return -1;      /* might be reached if we're in debug mode */
                 }
         }
-        memset(packet.buf, 0, icmp_pkt_size);
+        memset(buf, 0, icmp_pkt_size);
 
-        if((gettimeofday(&tv, &tz)) == -1) return -1;
+        if((gettimeofday(&tv, &tz)) == -1) {
+                free(buf);
+                return -1;
+        }
 
         data.ping_id = 10; /* host->icmp.icmp_sent; */
         memcpy(&data.stime, &tv, sizeof(tv));
-        memcpy(&packet.icp->icmp_data, &data, sizeof(data));
-        packet.icp->icmp_type = ICMP_ECHO;
-        packet.icp->icmp_code = 0;
-        packet.icp->icmp_cksum = 0;
-        packet.icp->icmp_id = htons(pid);
-        packet.icp->icmp_seq = htons(host->id++);
-        packet.icp->icmp_cksum = icmp_checksum(packet.cksum_in, icmp_pkt_size);
-
-        if (debug > 2)
-                printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n",
-                       (unsigned long)sizeof(data), ntohs(packet.icp->icmp_id),
-                       ntohs(packet.icp->icmp_seq), packet.icp->icmp_cksum,
-                       host->name);
+
+        if (address_family == AF_INET) {
+                struct icmp *icp = (struct icmp*)buf;
+
+                memcpy(&icp->icmp_data, &data, sizeof(data));
+
+                icp->icmp_type = ICMP_ECHO;
+                icp->icmp_code = 0;
+                icp->icmp_cksum = 0;
+                icp->icmp_id = htons(pid);
+                icp->icmp_seq = htons(host->id++);
+                icp->icmp_cksum = icmp_checksum((unsigned short*)buf, icmp_pkt_size);
+
+                if (debug > 2)
+                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n",
+                                (unsigned long)sizeof(data), ntohs(icp->icmp_id), ntohs(icp->icmp_seq), icp->icmp_cksum, host->name);
+        }
+        else {
+                struct icmp6_hdr *icp6 = (struct icmp6_hdr*)buf;
+                memcpy(&icp6->icmp6_dataun.icmp6_un_data8[4], &data, sizeof(data));
+                icp6->icmp6_type = ICMP6_ECHO_REQUEST;
+                icp6->icmp6_code = 0;
+                icp6->icmp6_cksum = 0;
+                icp6->icmp6_id = htons(pid);
+                icp6->icmp6_seq = htons(host->id++);
+                // let checksum be calculated automatically
+
+                if (debug > 2) {
+                        printf("Sending ICMP echo-request of len %lu, id %u, seq %u, cksum 0x%X to host %s\n",
+                                (unsigned long)sizeof(data), ntohs(icp6->icmp6_id),
+                                ntohs(icp6->icmp6_seq), icp6->icmp6_cksum, host->name);
+                }
+        }
 
         memset(&iov, 0, sizeof(iov));
-        iov.iov_base = packet.buf;
+        iov.iov_base = buf;
         iov.iov_len = icmp_pkt_size;
 
         memset(&hdr, 0, sizeof(hdr));
-        hdr.msg_name = addr;
-        hdr.msg_namelen = sizeof(struct sockaddr);
+        hdr.msg_name = (struct sockaddr *)&host->saddr_in;
+        hdr.msg_namelen = sizeof(struct sockaddr_storage);
         hdr.msg_iov = &iov;
         hdr.msg_iovlen = 1;
 
+        errno = 0;
+
 /* MSG_CONFIRM is a linux thing and only available on linux kernels >= 2.3.15, see send(2) */
 #ifdef MSG_CONFIRM
         len = sendmsg(sock, &hdr, MSG_CONFIRM);
@@ -887,9 +1019,15 @@ send_icmp_ping(int sock, struct rta_host *host)
         len = sendmsg(sock, &hdr, 0);
 #endif
 
+        free(buf);
+
         if(len < 0 || (unsigned int)len != icmp_pkt_size) {
-                if(debug) printf("Failed to send ping to %s\n",
-                                                 inet_ntoa(host->saddr_in.sin_addr));
+                if(debug) {
+                        char address[INET6_ADDRSTRLEN];
+                        parse_address((struct sockaddr_storage *)&host->saddr_in, address, sizeof(address));
+                        printf("Failed to send ping to %s: %s\n", address, strerror(errno));
+                }
+                errno = 0;
                 return -1;
         }
 
@@ -934,7 +1072,7 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
 
         if(!n) return 0;                                /* timeout */
 
-        slen = sizeof(struct sockaddr);
+        slen = sizeof(struct sockaddr_storage);
 
         memset(&iov, 0, sizeof(iov));
         iov.iov_base = buf;
@@ -958,6 +1096,7 @@ recvfrom_wto(int sock, void *buf, unsigned int len, struct sockaddr *saddr,
                         break ;
                 }
         }
+
         if (!chdr)
 #endif // SO_TIMESTAMP
                 gettimeofday(tv, &tz);
@@ -991,6 +1130,7 @@ finish(int sig)
 
         /* iterate thrice to calculate values, give output, and print perfparse */
         host = list;
+
         while(host) {
                 if(!host->icmp_recv) {
                         /* rta 0 is ofcourse not entirely correct, but will still show up
@@ -1039,10 +1179,12 @@ finish(int sig)
                 if(!host->icmp_recv) {
                         status = STATE_CRITICAL;
                         if(host->flags & FLAG_LOST_CAUSE) {
+                                char address[INET6_ADDRSTRLEN];
+                                parse_address(&host->error_addr, address, sizeof(address));
                                 printf("%s: %s @ %s. rta nan, lost %d%%",
                                            host->name,
                                            get_icmp_error_msg(host->icmp_type, host->icmp_code),
-                                           inet_ntoa(host->error_addr),
+                                           address,
                                            100);
                         }
                         else { /* not marked as lost cause, so we have no flags for it */
@@ -1104,7 +1246,6 @@ get_timevaldiff(struct timeval *early, struct timeval *later)
         {
                 return 0;
         }
-
         ret = (later->tv_sec - early->tv_sec) * 1000000;
         ret += later->tv_usec - early->tv_usec;
 
@@ -1112,18 +1253,35 @@ get_timevaldiff(struct timeval *early, struct timeval *later)
 }
 
 static int
-add_target_ip(char *arg, struct in_addr *in)
+add_target_ip(char *arg, struct sockaddr_storage *in)
 {
         struct rta_host *host;
+        struct sockaddr_in *sin, *host_sin;
+        struct sockaddr_in6 *sin6, *host_sin6;
+
+        if (address_family == AF_INET)
+                sin = (struct sockaddr_in *)in;
+        else
+                sin6 = (struct sockaddr_in6 *)in;
 
-        /* disregard obviously stupid addresses */
-        if(in->s_addr == INADDR_NONE || in->s_addr == INADDR_ANY)
+
+
+        /* disregard obviously stupid addresses
+         * (I didn't find an ipv6 equivalent to INADDR_NONE) */
+        if (((address_family == AF_INET && (sin->sin_addr.s_addr == INADDR_NONE
+                                        || sin->sin_addr.s_addr == INADDR_ANY)))
+                || (address_family == AF_INET6 && (sin6->sin6_addr.s6_addr == in6addr_any.s6_addr))) {
                 return -1;
+        }
 
         /* no point in adding two identical IP's, so don't. ;) */
         host = list;
         while(host) {
-                if(host->saddr_in.sin_addr.s_addr == in->s_addr) {
+                host_sin = (struct sockaddr_in *)&host->saddr_in;
+                host_sin6 = (struct sockaddr_in6 *)&host->saddr_in;
+
+                if(   (address_family == AF_INET && host_sin->sin_addr.s_addr == sin->sin_addr.s_addr)
+                   || (address_family == AF_INET6 && host_sin6->sin6_addr.s6_addr == sin6->sin6_addr.s6_addr)) {
                         if(debug) printf("Identical IP already exists. Not adding %s\n", arg);
                         return -1;
                 }
@@ -1131,19 +1289,29 @@ add_target_ip(char *arg, struct in_addr *in)
         }
 
         /* add the fresh ip */
-        host = malloc(sizeof(struct rta_host));
+        host = (struct rta_host*)malloc(sizeof(struct rta_host));
         if(!host) {
+                char straddr[INET6_ADDRSTRLEN];
+                parse_address((struct sockaddr_storage*)&in, straddr, sizeof(straddr));
                 crash("add_target_ip(%s, %s): malloc(%d) failed",
-                          arg, inet_ntoa(*in), sizeof(struct rta_host));
+                        arg, straddr, sizeof(struct rta_host));
         }
         memset(host, 0, sizeof(struct rta_host));
 
         /* set the values. use calling name for output */
         host->name = strdup(arg);
 
-        /* fill out the sockaddr_in struct */
-        host->saddr_in.sin_family = AF_INET;
-        host->saddr_in.sin_addr.s_addr = in->s_addr;
+        /* fill out the sockaddr_storage struct */
+        if(address_family == AF_INET) {
+                host_sin = (struct sockaddr_in *)&host->saddr_in;
+                host_sin->sin_family = AF_INET;
+                host_sin->sin_addr.s_addr = sin->sin_addr.s_addr;
+        }
+        else {
+                host_sin6 = (struct sockaddr_in6 *)&host->saddr_in;
+                host_sin6->sin6_family = AF_INET6;
+                memcpy(host_sin6->sin6_addr.s6_addr, sin6->sin6_addr.s6_addr, sizeof host_sin6->sin6_addr.s6_addr);
+        }
 
         host->rtmin = DBL_MAX;
 
@@ -1160,31 +1328,67 @@ add_target_ip(char *arg, struct in_addr *in)
 static int
 add_target(char *arg)
 {
-        int i;
-        struct hostent *he;
-        struct in_addr *in, ip;
+        int error, result;
+        struct sockaddr_storage ip;
+        struct addrinfo hints, *res, *p;
+        struct sockaddr_in *sin;
+        struct sockaddr_in6 *sin6;
+
+        switch (address_family) {
+        case -1:
+                /* -4 and -6 are not specified on cmdline */
+                address_family = AF_INET;
+                sin = (struct sockaddr_in *)&ip;
+                result = inet_pton(address_family, arg, &sin->sin_addr);
+#ifdef USE_IPV6
+                if( result != 1 ){
+                        address_family = AF_INET6;
+                        sin6 = (struct sockaddr_in6 *)&ip;
+                        result = inet_pton(address_family, arg, &sin6->sin6_addr);
+                }
+#endif
+                /* If we don't find any valid addresses, we still don't know the address_family */
+                if ( result != 1) {
+                        address_family = -1;
+                }
+                break;
+        case AF_INET:
+                sin = (struct sockaddr_in *)&ip;
+                result = inet_pton(address_family, arg, &sin->sin_addr);
+                break;
+        case AF_INET6:
+                sin6 = (struct sockaddr_in6 *)&ip;
+                result = inet_pton(address_family, arg, &sin6->sin6_addr);
+                break;
+        default: crash("Address family not supported");
+        }
 
         /* don't resolve if we don't have to */
-        if((ip.s_addr = inet_addr(arg)) != INADDR_NONE) {
+        if(result == 1) {
                 /* don't add all ip's if we were given a specific one */
                 return add_target_ip(arg, &ip);
-                /* he = gethostbyaddr((char *)in, sizeof(struct in_addr), AF_INET); */
-                /* if(!he) return add_target_ip(arg, in); */
         }
         else {
                 errno = 0;
-                he = gethostbyname(arg);
-                if(!he) {
+                memset(&hints, 0, sizeof(hints));
+                if (address_family == -1) {
+                        hints.ai_family = AF_UNSPEC;
+                } else {
+                        hints.ai_family = address_family == AF_INET ? PF_INET : PF_INET6;
+                }
+                hints.ai_socktype = SOCK_RAW;
+                if((error = getaddrinfo(arg, NULL, &hints, &res)) != 0) {
                         errno = 0;
-                        crash("Failed to resolve %s", arg);
+                        crash("Failed to resolve %s: %s", arg, gai_strerror(error));
                         return -1;
                 }
+                address_family = res->ai_family;
         }
 
         /* possibly add all the IP's as targets */
-        for(i = 0; he->h_addr_list[i]; i++) {
-                in = (struct in_addr *)he->h_addr_list[i];
-                add_target_ip(arg, in);
+        for(p = res; p != NULL; p = p->ai_next) {
+                memcpy(&ip, p->ai_addr, p->ai_addrlen);
+                add_target_ip(arg, &ip);
 
                 /* this is silly, but it works */
                 if(mode == MODE_HOSTCHECK || mode == MODE_ALL) {
@@ -1193,6 +1397,7 @@ add_target(char *arg)
                 }
                 break;
         }
+        freeaddrinfo(res);
 
         return 0;
 }
@@ -1203,7 +1408,7 @@ set_source_ip(char *arg)
         struct sockaddr_in src;
 
         memset(&src, 0, sizeof(src));
-        src.sin_family = AF_INET;
+        src.sin_family = address_family;
         if((src.sin_addr.s_addr = inet_addr(arg)) == INADDR_NONE)
                 src.sin_addr.s_addr = get_ip_address(arg);
         if(bind(icmp_sock, (struct sockaddr *)&src, sizeof(src)) == -1)
@@ -1311,12 +1516,12 @@ get_threshold(char *str, threshold *th)
 unsigned short
 icmp_checksum(unsigned short *p, int n)
 {
-        register unsigned short cksum;
-        register long sum = 0;
+        unsigned short cksum;
+        long sum = 0;
 
-        while(n > 1) {
+        while(n > 2) {
                 sum += *p++;
-                n -= 2;
+                n -= sizeof(unsigned short);
         }
 
         /* mop up the occasional odd byte */
@@ -1347,6 +1552,8 @@ print_help(void)
 
   printf (" %s\n", "-H");
   printf ("    %s\n", _("specify a target"));
+  printf (" %s\n", "[-4|-6]");
+  printf ("    %s\n", _("Use IPv4 (default) or IPv6 to communicate with the targets"));
   printf (" %s\n", "-w");
   printf ("    %s", _("warning threshold (currently "));
   printf ("%0.3fms,%u%%)\n", (float)warn.rta / 1000, warn.pl);