Ticket #107: diff

iodine-0.6.0-rc1

@@ -58 +58 @@
 static int running;
 static const char *password;
 
-static struct sockaddr_in nameserv;
-static struct sockaddr_in raw_serv;
+static struct sockaddr_in6 nameserv;
+static struct sockaddr_in6 raw_serv;
 static const char *topdomain;
 
 static uint16_t rand_seed;
@@ -148 +148 @@
 void
 client_set_nameserver(const char *cp, int port) 
 {
-        struct in_addr addr;
+        struct in6_addr addr;
 
-        if (inet_aton(cp, &addr) != 1) {
+        if (inet_pton(AF_INET6, cp, &addr) != 1) {
                 /* try resolving if a domain is given */
-                struct hostent *host;
+                struct addrinfo *res;
                 const char *err;
-                host = gethostbyname(cp);
-                if (host != NULL && h_errno > 0) {
-                        int i = 0;
-                        while (host->h_addr_list[i] != 0) {
-                                addr = *(struct in_addr *) host->h_addr_list[i++];
-                                fprintf(stderr, "Resolved %s to %s\n", cp, inet_ntoa(addr));
+                int error = getaddrinfo(cp, NULL, NULL, &res);
+                if (!error) {
+                        struct addrinfo *rp;
+                        for (rp = res; rp != NULL; rp = rp->ai_next) {
+                                if (rp->ai_family == AF_INET6)
+                                        addr = ((struct sockaddr_in6 *)(rp->ai_addr))->sin6_addr;
+                                else {
+                                        addr.s6_addr32[0] = 0;
+                                        addr.s6_addr32[1] = 0;
+                                        addr.s6_addr32[2] = htonl(0xffff);
+                                        addr.s6_addr32[3] = ((struct sockaddr_in *)(rp->ai_addr))->sin_addr.s_addr;
+                                }
+                                fprintf(stderr, "Resolved %s to %s\n", cp, inet6_ntoa(addr));
                                 goto setaddr;
                         }
                 }
 #ifndef WINDOWS32
-                err = hstrerror(h_errno);
+                err = gai_strerror(error);
 #else
                 {
                         DWORD wserr = WSAGetLastError();
@@ -186 +193 @@
 
 setaddr:
         memset(&nameserv, 0, sizeof(nameserv));
-        nameserv.sin_family = AF_INET;
-        nameserv.sin_port = htons(port);
-        nameserv.sin_addr = addr;
+        nameserv.sin6_family = AF_INET6;
+        nameserv.sin6_port = htons(port);
+        nameserv.sin6_addr = addr;
 }
 
 void
@@ -272 +279 @@
 const char *
 client_get_raw_addr()
 {
-        return inet_ntoa(raw_serv.sin_addr);
+        return inet6_ntoa(raw_serv.sin6_addr);
 }
 
 static void
@@ -601 +608 @@
         socklen_t addrlen;
         int r;
 
-        addrlen = sizeof(struct sockaddr);
+        addrlen = sizeof(struct sockaddr_in6);
         if ((r = recvfrom(dns_fd, data, sizeof(data), 0, 
                           (struct sockaddr*)&from, &addrlen)) < 0) {
                 warn("recvfrom");
@@ -1522 +1529 @@
         int r;
         int len;
         unsigned remoteaddr = 0;
-        struct in_addr server;
+        struct in6_addr server;
 
         fprintf(stderr, "Testing raw UDP data to the server (skip with -r)");
         for (i=0; running && i<3 ;i++) {
@@ -1541 +1548 @@
                                 remoteaddr |= (in[3] & 0xff);
                                 remoteaddr <<= 8;
                                 remoteaddr |= (in[4] & 0xff);
-                                server.s_addr = ntohl(remoteaddr);
+                                server.s6_addr32[0] = 0;
+                                server.s6_addr32[1] = 0;
+                                server.s6_addr32[2] = ntohl(0xffff);
+                                server.s6_addr32[3] = ntohl(remoteaddr);
                                 break;
+                        } else if (len == 17 && in[0] == 'I') {
+                                remoteaddr = -1;
+                                memcpy(&server, in + 1, sizeof(struct in6_addr));
                         }
                 /*XXX END adjust indent 1 tab back*/
 
@@ -1557 +1570 @@
                 fprintf(stderr, "Failed to get raw server IP, will use DNS mode.\n");
                 return 0;
         }
-        fprintf(stderr, "Server is at %s, trying raw login: ", inet_ntoa(server));
+        fprintf(stderr, "Server is at %s, trying raw login: ", inet6_ntoa(server));
         fflush(stderr);
 
         /* Store address to iodined server */
         memset(&raw_serv, 0, sizeof(raw_serv));
-        raw_serv.sin_family = AF_INET;
-        raw_serv.sin_port = htons(53);
-        raw_serv.sin_addr = server;
+        raw_serv.sin6_family = AF_INET6;
+        raw_serv.sin6_port = htons(53);
+        raw_serv.sin6_addr = server;
 
         /* do login against port 53 on remote server 
          * based on the old seed. If reply received,

iodine-0.6.0-rc1

@@ -53 +53 @@
 /* The raw header used when not using DNS protocol */
 const unsigned char raw_header[RAW_HDR_LEN] = { 0x10, 0xd1, 0x9e, 0x00 };
 
+/* Transparent socket */
+struct sockaddr_in6 tsock;
+
 /* daemon(3) exists only in 4.4BSD or later, and in GNU libc */
 #if !defined(WINDOWS32) && !(defined(BSD) && (BSD >= 199306)) && !defined(__GLIBC__)
 static int daemon(int nochdir, int noclose)
@@ -112 +115 @@
 }
 
 int 
-open_dns(int localport, in_addr_t listen_ip) 
+open_dns(int localport, struct in6_addr listen_ip) 
 {
-        struct sockaddr_in addr;
+        struct sockaddr_in6 addr;
         int flag = 1;
         int fd;
 
         memset(&addr, 0, sizeof(addr));
-        addr.sin_family = AF_INET;
-        addr.sin_port = htons(localport);
+        addr.sin6_family = AF_INET6;
+        addr.sin6_port = htons(localport);
         /* listen_ip already in network byte order from inet_addr, or 0 */
-        addr.sin_addr.s_addr = listen_ip; 
+        addr.sin6_addr = listen_ip; 
 
-        if ((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+        if ((fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
                 fprintf(stderr, "got fd %d\n", fd);
                 err(1, "socket");
         }
@@ -138 +141 @@
 #ifndef WINDOWS32
         /* To get destination address from each UDP datagram, see iodined.c:read_dns() */
         setsockopt(fd, IPPROTO_IP, DSTADDR_SOCKOPT, (const void*) &flag, sizeof(flag));
+        setsockopt(fd, IPPROTO_IPV6, IPV6_RECVORIGDSTADDR, (const void*) &flag, sizeof(flag));
+#ifdef IP_TRANSPARENT
+        /* To be able to use TPROXY in incoming queries */
+        if (localport && localport != DNS_PORT) {
+                setsockopt(fd, SOL_IP, IP_TRANSPARENT, (const void*) &flag, sizeof(flag));
+                tsock = addr;
+        }
+#endif
 #endif
 
 #ifdef IP_OPT_DONT_FRAG
@@ -348 +359 @@
         }
         return 0;
 }
+
+char *inet6_ntoa(struct in6_addr src) {
+        static char dst[INET6_ADDRSTRLEN];
+
+        if (IN6_IS_ADDR_V4MAPPED(&src))
+        {
+                struct in_addr ia;
+                ia.s_addr = src.s6_addr32[3];
+                inet_ntop(AF_INET, &ia, dst, sizeof(dst));
+        } else
+                inet_ntop(AF_INET6, &src, dst, sizeof(dst));
+
+        return dst;
+}
+
+int 
+sendto_tproxy(int sockfd, const void *buf, size_t len, int flags,
+                struct sockaddr_in6 *s_addr,
+                const struct sockaddr *dest_addr, socklen_t daddrlen)
+{
+        int fd;
+#ifdef IP_TRANSPARENT
+        static int tfd = -1;
+        if (tsock.sin6_family && (tsock.sin6_port != s_addr->sin6_port)) {
+                static struct sockaddr_in6 src_addr;
+                int flag = 1;
+
+                if (memcmp(&src_addr, s_addr, sizeof(src_addr))) {
+                        if (tfd >= 0)
+                                close(tfd);
+
+                        src_addr = *s_addr;
+
+                        if ((tfd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+                                fprintf(stderr, "got fd %d\n", tfd);
+                                err(1, "socket");
+                        }
+
+#ifdef SO_REUSEPORT
+                        setsockopt(tfd, SOL_SOCKET, SO_REUSEPORT, (const void*) &flag, sizeof(flag));
+#endif
+                        setsockopt(tfd, SOL_SOCKET, SO_REUSEADDR, (const void*) &flag, sizeof(flag));
+
+                        setsockopt(tfd, SOL_SOCKET, SO_BROADCAST, (const void*) &flag, sizeof(flag));
+                        setsockopt(tfd, SOL_IP, IP_TRANSPARENT, (const void*) &flag, sizeof(flag));
+
+#ifdef IP_OPT_DONT_FRAG
+                        /* Set dont-fragment ip header flag */
+                        flag = DONT_FRAG_VALUE;
+                        setsockopt(tfd, IPPROTO_IP, IP_OPT_DONT_FRAG, (const void*) &flag, sizeof(flag));
+#endif
+                        if(bind(tfd, (struct sockaddr*)&src_addr, sizeof(src_addr)) < 0) 
+                                err(1, "bind");
+                }
+                fd = tfd;
+        } else
+#endif
+                fd = sockfd;
+
+        return sendto(fd, buf, len, flags, dest_addr, daddrlen);
+}

iodine-0.6.0-rc1

@@ -52 +52 @@
 
 #define QUERY_NAME_SIZE 256
 
-#if defined IP_RECVDSTADDR 
+#if defined IP_RECVORIGDSTADDR
+# define IPV6_RECVORIGDSTADDR   74
+# define DSTADDR_SOCKOPT IP_RECVORIGDSTADDR 
+# define dstaddr(x) (&(((struct sockaddr_in *)(CMSG_DATA(x)))->sin_addr.s_addr))
+# define dstport(x) (((struct sockaddr_in *)(CMSG_DATA(x)))->sin_port)
+# define dstsock6(x) ((struct sockaddr_in6 *)(CMSG_DATA(x)))
+#elif defined IP_RECVDSTADDR 
 # define DSTADDR_SOCKOPT IP_RECVDSTADDR 
 # define dstaddr(x) ((struct in_addr *) CMSG_DATA(x)) 
+# define dstport(x) (DNS_PORT)
 #elif defined IP_PKTINFO 
 # define DSTADDR_SOCKOPT IP_PKTINFO 
 # define dstaddr(x) (&(((struct in_pktinfo *)(CMSG_DATA(x)))->ipi_addr)) 
+# define dstport(x) (DNS_PORT)
 #endif
 
 #if defined IP_MTU_DISCOVER
@@ -92 +100 @@
         unsigned short type;
         unsigned short rcode;
         unsigned short id;
-        struct in_addr destination;
-        struct sockaddr from;
+        struct sockaddr_in6 destination;
+        struct sockaddr_in6 from;
         int fromlen;
         unsigned short id2;
-        struct sockaddr from2;
+        struct sockaddr_in6 from2;
         int fromlen2;
 };
 
@@ -107 +115 @@
 };
 
 void check_superuser(void (*usage_fn)(void));
-int open_dns(int, in_addr_t);
+int open_dns(int, struct in6_addr);
 void close_dns(int);
 
 void do_chroot(char *);
@@ -129 +137 @@
 #endif
 
 int recent_seqno(int , int);
+char *inet6_ntoa(struct in6_addr src);
+int sendto_tproxy(int sockfd, const void *buf, size_t len, int flags,
+                struct sockaddr_in6 *s_addr,
+                const struct sockaddr *dest_addr, socklen_t daddrlen);
 
 #endif

iodine-0.6.0-rc1

@@ -317 +317 @@
                 retval = 1;
                 goto cleanup1;
         }
-        if ((dns_fd = open_dns(0, INADDR_ANY)) == -1) {
+        if ((dns_fd = open_dns(0, in6addr_any)) == -1) {
                 retval = 1;
                 goto cleanup2;
         }

iodine-0.6.0-rc1

@@ -80 +80 @@
 static in_addr_t my_ip;
 static int netmask;
 
-static in_addr_t ns_ip;
+static struct in6_addr ns_ip;
 
 static int bind_port;
 static int debug;
@@ -119 +119 @@
 static int
 check_user_and_ip(int userid, struct query *q)
 {
-        struct sockaddr_in *tempin;
+        struct sockaddr_in6 *tempin;
 
         /* Note: duplicate in handle_raw_login() except IP-address check */
 
@@ -138 +138 @@
                 return 0;
         }
 
-        tempin = (struct sockaddr_in *) &(q->from);
-        return memcmp(&(users[userid].host), &(tempin->sin_addr), sizeof(struct in_addr));
+        tempin = (struct sockaddr_in6 *) &(q->from);
+        return (!IN6_ARE_ADDR_EQUAL(&users[userid].host, &tempin->sin6_addr));
 }
 
 static void
@@ -159 +159 @@
         packet[RAW_HDR_CMD] = cmd | (user & 0x0F);
 
         if (debug >= 2) {
-                struct sockaddr_in *tempin;
-                tempin = (struct sockaddr_in *) &(q->from);
+                struct sockaddr_in6 *tempin;
+                tempin = (struct sockaddr_in6 *) &(q->from);
                 fprintf(stderr, "TX-raw: client %s, cmd %d, %d bytes\n", 
-                        inet_ntoa(tempin->sin_addr), cmd, len);
+                        inet6_ntoa(tempin->sin6_addr), cmd, len);
         }
 
-        sendto(fd, packet, len, 0, &q->from, q->fromlen);
+        sendto_tproxy(fd, packet, len, 0, &q->destination, (struct sockaddr *)&q->from, q->fromlen);
 }
 
 
@@ -698 +698 @@
                         userid = find_available_user();
                         if (userid >= 0) {
                                 int i;
-                                struct sockaddr_in *tempin;
+                                struct sockaddr_in6 *tempin;
 
                                 users[userid].seed = rand();
                                 /* Store remote IP number */
-                                tempin = (struct sockaddr_in *) &(q->from);
-                                memcpy(&(users[userid].host), &(tempin->sin_addr), sizeof(struct in_addr));
+                                tempin = (struct sockaddr_in6 *) &(q->from);
+                                memcpy(&(users[userid].host), &(tempin->sin6_addr), sizeof(struct in6_addr));
                                 
                                 memcpy(&(users[userid].q), q, sizeof(struct query));
                                 users[userid].encoder = get_base32_encoder();
                                 users[userid].downenc = 'T';
                                 send_version_response(dns_fd, VERSION_ACK, users[userid].seed, userid, q);
                                 syslog(LOG_INFO, "accepted version for user #%d from %s",
-                                        userid, inet_ntoa(tempin->sin_addr));
+                                        userid, inet6_ntoa(tempin->sin6_addr));
                                 users[userid].q.id = 0;
                                 users[userid].q.id2 = 0;
                                 users[userid].q_sendrealsoon.id = 0;
@@ -752 +752 @@
                                 /* No space for another user */
                                 send_version_response(dns_fd, VERSION_FULL, created_users, 0, q);
                                 syslog(LOG_INFO, "dropped user from %s, server full", 
-                                        inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr));
+                                        inet6_ntoa(((struct sockaddr_in6 *) &q->from)->sin6_addr));
                         }
                 } else {
                         send_version_response(dns_fd, VERSION_NACK, VERSION, 0, q);
                         syslog(LOG_INFO, "dropped user from %s, sent bad version %08X", 
-                                inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr), version);
+                                inet6_ntoa(((struct sockaddr_in6 *) &q->from)->sin6_addr), version);
                 }
                 return;
         } else if(in[0] == 'L' || in[0] == 'l') {
@@ -773 +773 @@
                 if (check_user_and_ip(userid, q) != 0) {
                         write_dns(dns_fd, q, "BADIP", 5, 'T');
                         syslog(LOG_WARNING, "dropped login request from user #%d from unexpected source %s",
-                                userid, inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr));
+                                userid, inet6_ntoa(((struct sockaddr_in6 *) &q->from)->sin6_addr));
                         return;
                 } else {
                         users[userid].last_pkt = time(NULL);
@@ -799 +799 @@
                         } else {
                                 write_dns(dns_fd, q, "LNAK", 4, 'T');
                                 syslog(LOG_WARNING, "rejected login request from user #%d from %s, bad password",
-                                        userid, inet_ntoa(((struct sockaddr_in *) &q->from)->sin_addr));
+                                        userid, inet6_ntoa(((struct sockaddr_in6 *) &q->from)->sin6_addr));
                         }
                 }
                 return;
         } else if(in[0] == 'I' || in[0] == 'i') {
                 /* Request for IP number */
-                in_addr_t replyaddr;
+                struct in6_addr replyaddr;
                 unsigned addr;
                 char reply[5];
                 
@@ -815 +815 @@
                         return; /* illegal id */
                 }
 
-                if (ns_ip != INADDR_ANY) {
+                if (!IN6_IS_ADDR_UNSPECIFIED(&ns_ip)) {
                         /* If set, use assigned external ip (-n option) */
                         replyaddr = ns_ip;
                 } else {
                         /* otherwise return destination ip from packet */
-                        memcpy(&replyaddr, &q->destination.s_addr, sizeof(in_addr_t));
+                        replyaddr = q->destination.sin6_addr;
                 }
 
-                addr = htonl(replyaddr);
-                reply[0] = 'I';
-                reply[1] = (addr >> 24) & 0xFF;
-                reply[2] = (addr >> 16) & 0xFF;
-                reply[3] = (addr >>  8) & 0xFF;
-                reply[4] = (addr >>  0) & 0xFF;
-                write_dns(dns_fd, q, reply, sizeof(reply), 'T');
+                if (!IN6_IS_ADDR_V4MAPPED(&replyaddr))
+                {
+                        char reply[17];
+                        reply[0] = 'I';
+                        memcpy(reply+1, &replyaddr, sizeof(struct in6_addr));
+                        write_dns(dns_fd, q, reply, sizeof(reply), 'T');
+                } else {
+                        addr = htonl(replyaddr.s6_addr32[3]);
+                        reply[0] = 'I';
+                        reply[1] = (addr >> 24) & 0xFF;
+                        reply[2] = (addr >> 16) & 0xFF;
+                        reply[3] = (addr >>  8) & 0xFF;
+                        reply[4] = (addr >>  0) & 0xFF;
+                        write_dns(dns_fd, q, reply, sizeof(reply), 'T');
+                }
         } else if(in[0] == 'Z' || in[0] == 'z') {
                 /* Check for case conservation and chars not allowed according to RFC */
 
@@ -1424 +1432 @@
         char buf[64*1024];
         int len;
 
-        if (ns_ip != INADDR_ANY) {
+        if (!IN6_IS_ADDR_UNSPECIFIED(&ns_ip)) {
                 /* If ns_ip set, overwrite destination addr with it.
                  * Destination addr will be sent as additional record (A, IN) */
-                memcpy(&q->destination.s_addr, &ns_ip, sizeof(in_addr_t));
+                q->destination.sin6_family = AF_INET6;
+                q->destination.sin6_addr = ns_ip;
+                q->destination.sin6_port = htons(DNS_PORT); 
         }
 
         len = dns_encode_ns_response(buf, sizeof(buf), q, topdomain);
@@ -1437 +1447 @@
         }
         
         if (debug >= 2) {
-                struct sockaddr_in *tempin;
-                tempin = (struct sockaddr_in *) &(q->from);
+                struct sockaddr_in6 *tempin;
+                tempin = (struct sockaddr_in6 *) &(q->from);
                 fprintf(stderr, "TX: client %s, type %d, name %s, %d bytes NS reply\n", 
-                        inet_ntoa(tempin->sin_addr), q->type, q->name, len);
+                        inet6_ntoa(tempin->sin6_addr), q->type, q->name, len);
         }
-        if (sendto(dns_fd, buf, len, 0, (struct sockaddr*)&q->from, q->fromlen) <= 0) {
+        if (sendto_tproxy(dns_fd, buf, len, 0, &q->destination, (struct sockaddr*)&q->from, q->fromlen) <= 0) {
                 warn("ns reply send error");
         }
 }
@@ -1455 +1465 @@
         int len;
 
         if (fakeip) {
-                in_addr_t ip = inet_addr("127.0.0.1");
-                memcpy(&q->destination.s_addr, &ip, sizeof(in_addr_t));
+                inet_pton(AF_INET6,"::FFFF:127.0.0.1",&q->destination.sin6_addr);
+                q->destination.sin6_family = AF_INET6;
+                q->destination.sin6_port = htons(DNS_PORT); 
 
-        } else if (ns_ip != INADDR_ANY) {
+        } else if (!IN6_IS_ADDR_UNSPECIFIED(&ns_ip)) {
                 /* If ns_ip set, overwrite destination addr with it.
                  * Destination addr will be sent as additional record (A, IN) */
-                memcpy(&q->destination.s_addr, &ns_ip, sizeof(in_addr_t));
+                q->destination.sin6_family = AF_INET6;
+                q->destination.sin6_addr = ns_ip;
+                q->destination.sin6_port = htons(DNS_PORT); 
         }
 
         len = dns_encode_a_response(buf, sizeof(buf), q);
@@ -1471 +1484 @@
         }
         
         if (debug >= 2) {
-                struct sockaddr_in *tempin;
-                tempin = (struct sockaddr_in *) &(q->from);
+                struct sockaddr_in6 *tempin;
+                tempin = (struct sockaddr_in6 *) &(q->from);
                 fprintf(stderr, "TX: client %s, type %d, name %s, %d bytes A reply\n",
-                        inet_ntoa(tempin->sin_addr), q->type, q->name, len);
+                        inet6_ntoa(tempin->sin6_addr), q->type, q->name, len);
         }
-        if (sendto(dns_fd, buf, len, 0, (struct sockaddr*)&q->from, q->fromlen) <= 0) {
+        if (sendto_tproxy(dns_fd, buf, len, 0, &q->destination, (struct sockaddr*)&q->from, q->fromlen) <= 0) {
                 warn("a reply send error");
         }
 }
@@ -1487 +1500 @@
         char buf[64*1024];
         int len;
         struct fw_query fwq;
-        struct sockaddr_in *myaddr;
-        in_addr_t newaddr;
+        struct sockaddr_in6 *myaddr;
 
         len = dns_encode(buf, sizeof(buf), q, QR_QUERY, q->name, strlen(q->name));
         if (len < 1) {
@@ -1502 +1514 @@
         fwq.id = q->id;
         fw_query_put(&fwq);
 
-        newaddr = inet_addr("127.0.0.1");
-        myaddr = (struct sockaddr_in *) &(q->from);
-        memcpy(&(myaddr->sin_addr), &newaddr, sizeof(in_addr_t));
-        myaddr->sin_port = htons(bind_port);
+        myaddr = (struct sockaddr_in6 *) &(q->from);
+        inet_pton(AF_INET6,"::FFFF:127.0.0.1",&(myaddr->sin6_addr));
+        myaddr->sin6_port = htons(bind_port);
         
         if (debug >= 2) {
                 fprintf(stderr, "TX: NS reply \n");
@@ -1520 +1531 @@
 tunnel_bind(int bind_fd, int dns_fd)
 {
         char packet[64*1024];
-        struct sockaddr_in from;
+        struct sockaddr_in6 from;
         socklen_t fromlen;
         struct fw_query *query;
         unsigned short id;
         int r;
 
-        fromlen = sizeof(struct sockaddr);
+        fromlen = sizeof(struct sockaddr_in6);
         r = recvfrom(bind_fd, packet, sizeof(packet), 0, 
                 (struct sockaddr*)&from, &fromlen);
 
@@ -1547 +1558 @@
         }
 
         if (debug >= 2) {
-                struct sockaddr_in *in;
-                in = (struct sockaddr_in *) &(query->addr);
+                struct sockaddr_in6 *in;
+                in = (struct sockaddr_in6 *) &(query->addr);
                 fprintf(stderr, "TX: client %s id %u, %d bytes\n",
-                        inet_ntoa(in->sin_addr), (id & 0xffff), r);
+                        inet6_ntoa(in->sin6_addr), (id & 0xffff), r);
         }
         
         if (sendto(dns_fd, packet, r, 0, (const struct sockaddr *) &(query->addr), 
@@ -1573 +1584 @@
                 return 0;
 
         if (debug >= 2) {
-                struct sockaddr_in *tempin;
-                tempin = (struct sockaddr_in *) &(q.from);
+                struct sockaddr_in6 *tempin;
+                tempin = (struct sockaddr_in6 *) &(q.from);
                 fprintf(stderr, "RX: client %s, type %d, name %s\n", 
-                        inet_ntoa(tempin->sin_addr), q.type, q.name);
+                        inet6_ntoa(tempin->sin6_addr), q.type, q.name);
         }
 
         domain_len = strlen(q.name) - strlen(topdomain);
@@ -1799 +1810 @@
         /* User sends hash of seed + 1 */
         login_calculate(myhash, 16, password, users[userid].seed + 1);
         if (memcmp(packet, myhash, 16) == 0) {
-                struct sockaddr_in *tempin;
+                struct sockaddr_in6 *tempin;
 
                 /* Update query and time info for user */
                 users[userid].last_pkt = time(NULL);
                 memcpy(&(users[userid].q), q, sizeof(struct query));
 
                 /* Store remote IP number */
-                tempin = (struct sockaddr_in *) &(q->from);
-                memcpy(&(users[userid].host), &(tempin->sin_addr), sizeof(struct in_addr));
+                tempin = (struct sockaddr_in6 *) &(q->from);
+                memcpy(&(users[userid].host), &(tempin->sin6_addr), sizeof(struct in6_addr));
                  
                 /* Correct hash, reply with hash of seed - 1 */
                 user_set_conn_type(userid, CONN_RAW_UDP);
@@ -1893 +1904 @@
 static int
 read_dns(int fd, int tun_fd, struct query *q) /* FIXME: tun_fd is because of raw_decode() below */
 {
-        struct sockaddr_in from;
+        struct sockaddr_in6 from;
         socklen_t addrlen;
         char packet[64*1024];
         int r;
@@ -1903 +1914 @@
         struct iovec iov;
         struct cmsghdr *cmsg;
 
-        addrlen = sizeof(struct sockaddr);
+        addrlen = sizeof(struct sockaddr_in6);
         iov.iov_base = packet;
         iov.iov_len = sizeof(packet);
 
@@ -1917 +1928 @@
         
         r = recvmsg(fd, &msg, 0);
 #else
-        addrlen = sizeof(struct sockaddr);
+        addrlen = sizeof(struct sockaddr_in6);
         r = recvfrom(fd, packet, sizeof(packet), 0, (struct sockaddr*)&from, &addrlen);
 #endif /* !WINDOWS32 */
 
@@ -1940 +1951 @@
                         if (cmsg->cmsg_level == IPPROTO_IP && 
                                 cmsg->cmsg_type == DSTADDR_SOCKOPT) { 
                                 
-                                q->destination = *dstaddr(cmsg); 
+                                q->destination.sin6_family = AF_INET6;
+                                q->destination.sin6_addr.s6_addr32[0] = 0;
+                                q->destination.sin6_addr.s6_addr32[1] = 0;
+                                q->destination.sin6_addr.s6_addr32[2] = htonl(0xffff);
+                                q->destination.sin6_addr.s6_addr32[3] = *dstaddr(cmsg); 
+                                q->destination.sin6_port = dstport(cmsg); 
+                                break;
+                        } else if (cmsg->cmsg_level == IPPROTO_IPV6 && 
+                                cmsg->cmsg_type == IPV6_RECVORIGDSTADDR) { 
+
+                                memcpy(&q->destination, dstsock6(cmsg), sizeof(struct sockaddr_in6));
                                 break;
                         } 
                 }
@@ -2106 +2127 @@
         }
         
         if (debug >= 2) {
-                struct sockaddr_in *tempin;
-                tempin = (struct sockaddr_in *) &(q->from);
+                struct sockaddr_in6 *tempin;
+                tempin = (struct sockaddr_in6 *) &(q->from);
                 fprintf(stderr, "TX: client %s, type %d, name %s, %d bytes data\n", 
-                        inet_ntoa(tempin->sin_addr), q->type, q->name, datalen);
+                        inet6_ntoa(tempin->sin6_addr), q->type, q->name, datalen);
         }
 
-        sendto(fd, buf, len, 0, (struct sockaddr*)&q->from, q->fromlen);
+        sendto_tproxy(fd, buf, len, 0, &q->destination, (struct sockaddr*)&q->from, q->fromlen);
 }
 
 static void
@@ -2173 +2194 @@
 main(int argc, char **argv)
 {
         extern char *__progname;
-        in_addr_t listen_ip;
+        struct in6_addr listen_ip;
 #ifndef WINDOWS32
         struct passwd *pw;
 #endif
@@ -2210 +2231 @@
         bind_fd = 0;
         mtu = 1130;     /* Very many relays give fragsize 1150 or slightly
                            higher for NULL; tun/zlib adds ~17 bytes. */
-        listen_ip = INADDR_ANY;
+        listen_ip = in6addr_any;
         port = 53;
-        ns_ip = INADDR_ANY;
+        ns_ip = in6addr_any;
         check_ip = 1;
         skipipconfig = 0;
         debug = 0;
@@ -2275 +2296 @@
                         mtu = atoi(optarg);
                         break;
                 case 'l':
-                        listen_ip = inet_addr(optarg);
+                        if (!inet_pton(AF_INET6, optarg, &listen_ip)) {
+                                warnx("Bad IP address to listen on.");
+                                usage();
+                        }
                         break;
                 case 'p':
                         port = atoi(optarg);
                         break;
                 case 'n':
-                        ns_ip = inet_addr(optarg);
+                        if (!inet_pton(AF_INET, optarg, &ns_ip)) {
+                                warnx("Bad IP address to return as nameserver.");
+                                usage();
+                        }
                         break;
                 case 'b':
                         bind_enable = 1;
@@ -2321 +2348 @@
                 netmask = atoi(netsize);
         }
 
-        my_ip = inet_addr(argv[0]);
-        
-        if (my_ip == INADDR_NONE) {
+        if (!inet_pton(AF_INET, argv[0], &my_ip)) {
                 warnx("Bad IP address to use inside tunnel.");
                 usage();
         }
@@ -2346 +2371 @@
                         usage();
                 }
 #endif
+                if (port != DNS_PORT) {
+                        warnx("setuid and tproxy options incompatible!");
+                        usage();
+                }
         }
 
         if (mtu <= 0) {
@@ -2365 +2394 @@
                         /* NOTREACHED */
                 }
                 /* Avoid forwarding loops */
-                if (bind_port == port && (listen_ip == INADDR_ANY || listen_ip == htonl(0x7f000001L))) {
+                if (bind_port == port && (IN6_IS_ADDR_UNSPECIFIED(&listen_ip) || IN6_IS_ADDR_LOOPBACK(&listen_ip))) {
                         warnx("Forward port is same as listen port (%d), will create a loop!", bind_port);
                         fprintf(stderr, "Use -l to set listen ip to avoid this.\n");
                         usage();
@@ -2386 +2415 @@
                 foreground = 1;
         }
 
-        if (listen_ip == INADDR_NONE) {
-                warnx("Bad IP address to listen on.");
-                usage();
-        }
-        
-        if (ns_ip == INADDR_NONE) {
-                warnx("Bad IP address to return as nameserver.");
-                usage();
-        }
         if (netmask > 30 || netmask < 8) {
                 warnx("Bad netmask (%d bits). Use 8-30 bits.", netmask);
                 usage();
@@ -2424 +2444 @@
                 goto cleanup2;
         }
         if (bind_enable) {
-                if ((bind_fd = open_dns(0, INADDR_ANY)) == -1) {
+                if ((bind_fd = open_dns(0, in6addr_any)) == -1) {
                         retval = 1;
                         goto cleanup3;
                 }

iodine-0.6.0-rc1

@@ -40 +40 @@
         time_t last_pkt;
         int seed;
         in_addr_t tun_ip;
-        struct in_addr host;
+        struct in6_addr host;
         struct query q;
         struct query q_sendrealsoon;
         int q_sendrealsoon_new;