dnsd: properly set _src_ IP:port on outgoing UDP packets

function                                             old     new   delta
send_to_from                                           -     258    +258
dnsd_main                                           1500    1568     +68
interrupt                                             17      19      +2
------------------------------------------------------------------------------
(add/remove: 1/0 grow/shrink: 2/0 up/down: 328/0)             Total: 328 bytes
   text    data     bss     dec     hex filename
 797101     658    7428  805187   c4943 busybox_old
 797429     658    7428  805515   c4a8b busybox_unstripped

1 files changed, 59 insertions, 58 deletions

diff --git a/networking/dnsd.c b/networking/dnsd.c
index b269bc52a..cb62d2081 100644
--- a/networking/dnsd.c
+++ b/networking/dnsd.c
@@ -36,7 +36,7 @@ enum {
    ttl(4B) + rlen(2B) + r (MAX_NAME_LEN =21B) +
    2*querystring (2 MAX_NAME_LEN= 42B), all together 90 Byte
 */
-        MAX_PACK_LEN = 512 + 1,
+        MAX_PACK_LEN = 512,
 
         DEFAULT_TTL = 30,       // increase this when not testing?
 
@@ -44,12 +44,6 @@ enum {
         REQ_PTR = 12
 };
 
-struct dns_repl {               // resource record, add 0 or 1 to accepted dns_msg in resp
-        uint16_t rlen;
-        uint8_t *r;             // resource
-        uint16_t flags;
-};
-
 struct dns_head {               // the message from client and first part of response mag
         uint16_t id;
         uint16_t flags;
@@ -218,20 +212,20 @@ static int table_lookup(uint16_t type, uint8_t * as, uint8_t * qs)
         return -1;
 }
 
-
 /*
  * Decode message and generate answer
  */
-static int process_packet(uint8_t * buf)
+static int process_packet(uint8_t *buf)
 {
+        uint8_t answstr[MAX_NAME_LEN + 1];
         struct dns_head *head;
         struct dns_prop *qprop;
-        struct dns_repl outr;
-        void *next, *from, *answb;
-
-        uint8_t answstr[MAX_NAME_LEN + 1];
-        int lookup_result, type, len, packet_len;
+        uint8_t *from, *answb;
+        uint16_t outr_rlen;
+        uint16_t outr_flags;
         uint16_t flags;
+        int lookup_result, type, packet_len;
+        int querystr_len;
 
         answstr[0] = '\0';
 
@@ -247,11 +241,12 @@ static int process_packet(uint8_t * buf)
         }
 
         from = (void *)&head[1];        //  start of query string
-        next = answb = from + strlen((char *)from) + 1 + sizeof(struct dns_prop);   // where to append answer block
+//FIXME: strlen of untrusted data??!
+        querystr_len = strlen((char *)from) + 1 + sizeof(struct dns_prop);
+        answb = from + querystr_len;   // where to append answer block
 
-        outr.rlen = 0;                  // may change later
-        outr.r = NULL;
-        outr.flags = 0;
+        outr_rlen = 0;
+        outr_flags = 0;
 
         qprop = (struct dns_prop *)(answb - 4);
         type = ntohs(qprop->type);
@@ -262,7 +257,7 @@ static int process_packet(uint8_t * buf)
         }
 
         if (ntohs(qprop->class) != 1 /* class INET */ ) {
-                outr.flags = 4; /* not supported */
+                outr_flags = 4; /* not supported */
                 goto empty_packet;
         }
         /* we only support standard queries */
@@ -272,49 +267,50 @@ static int process_packet(uint8_t * buf)
 
         // We have a standard query
         bb_info_msg("%s", (char *)from);
-        lookup_result = table_lookup(type, answstr, (uint8_t*)from);
+        lookup_result = table_lookup(type, answstr, from);
         if (lookup_result != 0) {
-                outr.flags = 3 | 0x0400;        //name do not exist and auth
+                outr_flags = 3 | 0x0400;        // name do not exist and auth
                 goto empty_packet;
         }
         if (type == REQ_A) {    // return an address
-                struct in_addr a;
-                if (!inet_aton((char*)answstr, &a)) {//dotted dec to long conv
-                        outr.flags = 1; /* Frmt err */
+                struct in_addr a; // NB! its "struct { unsigned __long__ s_addr; }"
+                uint32_t v32;
+                if (!inet_aton((char*)answstr, &a)) { //dotted dec to long conv
+                        outr_flags = 1; /* Frmt err */
                         goto empty_packet;
                 }
-                memcpy(answstr, &a.s_addr, 4);  // save before a disappears
-                outr.rlen = 4;                  // uint32_t IP
+                v32 = a.s_addr; /* in case long != int */
+                memcpy(answstr, &v32, 4);
+                outr_rlen = 4;                  // uint32_t IP
         } else
-                outr.rlen = strlen((char *)answstr) + 1;        // a host name
-        outr.r = answstr;                       // 32 bit ip or a host name
-        outr.flags |= 0x0400;                   /* authority-bit */
+                outr_rlen = strlen((char *)answstr) + 1;        // a host name
+        outr_flags |= 0x0400;                   /* authority-bit */
         // we have an answer
         head->nansw = htons(1);
 
         // copy query block to answer block
-        len = answb - from;
-        memcpy(answb, from, len);
-        next += len;
+        memcpy(answb, from, querystr_len);
+        answb += querystr_len;
 
         // and append answer rr
-        *(uint32_t *) next = htonl(ttl);
-        next += 4;
-        *(uint16_t *) next = htons(outr.rlen);
-        next += 2;
-        memcpy(next, (void *)answstr, outr.rlen);
-        next += outr.rlen;
+// FIXME: unaligned accesses??
+        *(uint32_t *) answb = htonl(ttl);
+        answb += 4;
+        *(uint16_t *) answb = htons(outr_rlen);
+        answb += 2;
+        memcpy(answb, answstr, outr_rlen);
+        answb += outr_rlen;
 
  empty_packet:
 
         flags = ntohs(head->flags);
         // clear rcode and RA, set responsebit and our new flags
-        flags |= (outr.flags & 0xff80) | 0x8000;
+        flags |= (outr_flags & 0xff80) | 0x8000;
         head->flags = htons(flags);
-        head->nauth = head->nadd = htons(0);
+        head->nauth = head->nadd = 0;
         head->nquer = htons(1);
 
-        packet_len = (uint8_t *)next - buf;
+        packet_len = answb - buf;
         return packet_len;
 }
 
@@ -333,10 +329,13 @@ int dnsd_main(int argc ATTRIBUTE_UNUSED, char **argv)
 {
         const char *listen_interface = "0.0.0.0";
         char *sttl, *sport;
-        len_and_sockaddr *lsa;
+        len_and_sockaddr *lsa, *from, *to;
+        unsigned lsa_size;
         int udps;
         uint16_t port = 53;
-        uint8_t buf[MAX_PACK_LEN];
+        /* Paranoid sizing: querystring x2 + ttl + outr_rlen + answstr */
+        /* I'd rather see process_packet() fixed instead... */
+        uint8_t buf[MAX_PACK_LEN * 2 + 4 + 2 + (MAX_NAME_LEN+1)];
 
         getopt32(argv, "i:c:t:p:dv", &listen_interface, &fileconf, &sttl, &sport);
         //if (option_mask32 & 0x1) // -i
@@ -375,32 +374,34 @@ int dnsd_main(int argc ATTRIBUTE_UNUSED, char **argv)
         lsa = xdotted2sockaddr(listen_interface, port);
         udps = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
         xbind(udps, &lsa->u.sa, lsa->len);
-        /* xlisten(udps, 50); - ?!! DGRAM sockets are never listened on I think? */
+        socket_want_pktinfo(udps); /* needed for recv_from_to to work */
+        lsa_size = LSA_LEN_SIZE + lsa->len;
+        from = xzalloc(lsa_size);
+        to = xzalloc(lsa_size);
+
         bb_info_msg("Accepting UDP packets on %s",
                         xmalloc_sockaddr2dotted(&lsa->u.sa));
 
         while (1) {
                 int r;
-                socklen_t fromlen = lsa->len;
-// FIXME: need to get *DEST* address (to which of our addresses
-// this query was directed), and reply from the same address.
-// Or else we can exhibit usual UDP ugliness:
-// [ip1.multihomed.ip2] <=  query to ip1  <= peer
-// [ip1.multihomed.ip2] => reply from ip2 => peer (confused)
-
-// TODO: recv_from_to
-
-                r = recvfrom(udps, buf, sizeof(buf), 0, &lsa->u.sa, &fromlen);
-                if (OPT_verbose)
-                        bb_info_msg("Got UDP packet");
-                if (r < 12 || r > 512) {
+                /* Try to get *DEST* address (to which of our addresses
+                 * this query was directed), and reply from the same address.
+                 * Or else we can exhibit usual UDP ugliness:
+                 * [ip1.multihomed.ip2] <=  query to ip1  <= peer
+                 * [ip1.multihomed.ip2] => reply from ip2 => peer (confused) */
+                memcpy(to, lsa, lsa_size);
+                r = recv_from_to(udps, buf, MAX_PACK_LEN + 1, 0, &from->u.sa, &to->u.sa, lsa->len);
+                if (r < 12 || r > MAX_PACK_LEN) {
                         bb_error_msg("invalid packet size");
                         continue;
                 }
+                if (OPT_verbose)
+                        bb_info_msg("Got UDP packet");
+                buf[r] = '\0'; /* paranoia */
                 r = process_packet(buf);
                 if (r <= 0)
                         continue;
-                sendto(udps, buf, r, 0, &lsa->u.sa, fromlen);
+                send_to_from(udps, buf, r, 0, &to->u.sa, &from->u.sa, lsa->len);
         }
         return 0;
 }