Changeset 7262f89 in mainline

Timestamp:

2013-04-20T10:42:13Z (12 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

dc95342

Parents:

f1dcf6d

Message:

Construct domain names, fix some bugs. Parse answer, print resulting hostname and IP address.

Location:

uspace/srv/net/dnsres

Files:

• dns_msg.c (modified) (13 diffs)
• dns_msg.h (modified) (1 diff)
• dns_type.h (modified) (3 diffs)
• dnsres.c (modified) (2 diffs)
• query.c (modified) (3 diffs)

uspace/srv/net/dnsres/dns_msg.c

@@ -49 +49 @@
 static uint16_t dns_uint16_t_decode(uint8_t *, size_t);
 
+static int dns_dstr_ext(char **dstr, const char *suff)
+{
+        size_t s1, s2;
+        size_t nsize;
+        char *nstr;
+
+        if (*dstr == NULL) {
+                *dstr = str_dup(suff);
+                if (*dstr == NULL)
+                        return ENOMEM;
+                return EOK;
+        }
+
+        s1 = str_size(*dstr);
+        s2 = str_size(suff);
+        nsize = s1 + s2 + 1;
+
+        nstr = realloc(*dstr, nsize);
+        if (nstr == NULL)
+                return ENOMEM;
+
+        str_cpy((*dstr) + s1, nsize - s1, suff);
+
+        *dstr = nstr;
+        return EOK;
+}
+
 #include <stdio.h>
 static int dns_name_encode(char *name, uint8_t *buf, size_t buf_size,
@@ -69 +96 @@
                 c = str_decode(name, &off, STR_NO_LIMIT);
                 printf("c=%d\n", (int)c);
-                if (c > 127) {
+                if (c >= 127) {
                         /* Non-ASCII character */
                         printf("non-ascii character\n");
@@ -121 +148 @@
         size_t ptr;
         size_t eptr;
+        char *name;
+        char dbuf[2];
+        int rc;
+        bool first;
+
+        name = NULL;
 
         if (boff > size)
@@ -127 +160 @@
         bp = buf + boff;
         bsize = min(size - boff, DNS_NAME_MAX_SIZE);
+        first = true;
+        *eoff = 0;
 
         while (true) {
                 if (bsize == 0) {
-                        return EINVAL;
+                        rc = EINVAL;
+                        goto error;
                 }
 
@@ -140 +176 @@
                         break;
 
-                if (bp != buf + boff + 1)
+                if (!first) {
                         printf(".");
+                        rc = dns_dstr_ext(&name, ".");
+                        if (rc != EOK) {
+                                rc = ENOMEM;
+                                goto error;
+                        }
+                }
 
                 if ((lsize & 0xc0) == 0xc0) {
@@ -148 +190 @@
                         if (bsize < 1) {
                                 printf("Pointer- bsize < 1\n");
-                                return EINVAL;
+                                rc = EINVAL;
+                                goto error;
                         }
 
                         ptr = dns_uint16_t_decode(bp - 1, bsize) & 0x3fff;
+                        ++bp;
+                        --bsize;
+
                         if (ptr >= (size_t)(bp - buf)) {
                                 printf("Pointer- forward ref %u, pos=%u\n",
                                     ptr, bp - buf);
                                 /* Forward reference */
-                                return EINVAL;
+                                rc = EINVAL;
+                                goto error;
                         }
 
@@ -163 +210 @@
                          * XXX Is assumption correct?
                          */
-                        eptr = buf - bp;
+                        eptr = bp - buf;
+                        /*
+                         * This is where encoded name ends in terms where
+                         * the message continues
+                         */
+                        *eoff = eptr;
 
                         printf("ptr=%u, eptr=%u\n", ptr, eptr);
@@ -172 +224 @@
 
                 if (lsize > bsize) {
-                        return EINVAL;
+                        rc = EINVAL;
+                        goto error;
                 }
 
                 for (i = 0; i < lsize; i++) {
                         printf("%c", *bp);
+
+                        if (*bp < 32 || *bp >= 127) {
+                                rc = EINVAL;
+                                goto error;
+                        }
+
+                        dbuf[0] = *bp;
+                        dbuf[1] = '\0';
+
+                        rc = dns_dstr_ext(&name, dbuf);
+                        if (rc != EOK) {
+                                rc = ENOMEM;
+                                goto error;
+                        }
                         ++bp;
                         --bsize;
                 }
+
+                first = false;
         }
 
         printf("\n");
 
-        *eoff = bp - buf;
-        return EOK;
+        *rname = name;
+        if (*eoff == 0)
+                *eoff = bp - buf;
+        return EOK;
+error:
+        free(name);
+        return rc;
 }
 
@@ -207 +281 @@
 
 /** Decode unaligned big-endian 32-bit integer */
-static uint16_t dns_uint32_t_decode(uint8_t *buf, size_t buf_size)
-{
+uint32_t dns_uint32_t_decode(uint8_t *buf, size_t buf_size)
+{
+        uint32_t w;
         assert(buf_size >= 4);
 
-        return ((uint32_t)buf[0] << 24) +
+        w = ((uint32_t)buf[0] << 24) +
             ((uint32_t)buf[1] << 16) +
             ((uint32_t)buf[2] << 8) +
-            buf[0];
+            buf[3];
+
+        printf("dns_uint32_t_decode: %x, %x, %x, %x -> %x\n",
+            buf[0], buf[1], buf[2], buf[3], w);
+        return w;
 }
 
@@ -304 +383 @@
         }
 
-        printf("ok decoding name..\n");
+        printf("ok decoding name.. '%s'\n", rr->name);
         if (name_eoff + 2 * sizeof(uint16_t) > buf_size) {
                 printf("name_eoff + 2 * 2 = %d >  buf_size = %d\n",
@@ -324 +403 @@
         rr->rtype = dns_uint16_t_decode(bp, bsz);
         bp += sizeof(uint16_t); bsz -= sizeof(uint16_t);
+        printf("rtype=%u\n", rr->rtype);
 
         rr->rclass = dns_uint16_t_decode(bp, bsz);
         bp += sizeof(uint16_t); bsz -= sizeof(uint16_t);
+        printf("rclass=%u\n", rr->rclass);
 
         rr->ttl = dns_uint32_t_decode(bp, bsz);
         bp += sizeof(uint32_t); bsz -= sizeof(uint32_t);
+        printf("ttl=%u\n", rr->ttl);
 
         rdlength = dns_uint16_t_decode(bp, bsz);
         bp += sizeof(uint16_t); bsz -= sizeof(uint16_t);
+        printf("rdlength=%u\n", rdlength);
 
         if (rdlength > bsz) {
@@ -469 +552 @@
                 printf("ok decoding question\n");
 
+                list_append(&question->msg, &msg->question);
                 doff = field_eoff;
         }
@@ -484 +568 @@
                 printf("ok decoding answer\n");
 
+                list_append(&rr->msg, &msg->answer);
                 doff = field_eoff;
         }

uspace/srv/net/dnsres/dns_msg.h

@@ -45 +45 @@
 extern int dns_message_encode(dns_message_t *, void **, size_t *);
 extern int dns_message_decode(void *, size_t, dns_message_t **);
+extern uint32_t dns_uint32_t_decode(uint8_t *, size_t);
 
 #endif

uspace/srv/net/dnsres/dns_type.h

@@ -38 +38 @@
 
 #include <adt/list.h>
+#include <inet/inet.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -80 +81 @@
 /** Unencoded DNS resource record */
 typedef struct {
+        link_t msg;
         /** Domain name */
         char *name;
@@ -97 +99 @@
 /** Host information */
 typedef struct {
+        /** Host name */
+        char *name;
+        /** Host address */
+        inet_addr_t addr;
 } dns_host_info_t;
 

uspace/srv/net/dnsres/dnsres.c

@@ -35 +35 @@
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <errno.h>
 
@@ -43 +44 @@
 #define NAME  "dnsres"
 
+static int addr_format(inet_addr_t *addr, char **bufp)
+{
+        int rc;
+
+        rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
+            (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
+            addr->ipv4 & 0xff);
+
+        if (rc < 0)
+                return ENOMEM;
+
+        return EOK;
+}
+
 int main(int argc, char *argv[])
 {
         dns_host_info_t hinfo;
+        char *astr;
         int rc;
 
         printf("%s: DNS Resolution Service\n", NAME);
-        rc = dns_name2host("helenos.org", &hinfo);
+        rc = dns_name2host(argc < 2 ? "helenos.org" : argv[1], &hinfo);
         printf("dns_name2host() -> rc = %d\n", rc);
+
+        if (rc == EOK) {
+                rc = addr_format(&hinfo.addr, &astr);
+                if (rc != EOK) {
+                        printf("Out of memory\n");
+                        return ENOMEM;
+                }
+
+                printf("hostname: %s\n", hinfo.name);
+                printf("IPv4 address: %s\n", astr);
+                free(astr);
+        }
 
         return 0;

uspace/srv/net/dnsres/query.c

@@ -36 +36 @@
 #include <errno.h>
 #include <mem.h>
+#include <str.h>
 
+#include "dns_msg.h"
 #include "dns_std.h"
 #include "dns_type.h"
@@ -44 +46 @@
 static uint16_t msg_id;
 
+#include <stdio.h>
 int dns_name2host(const char *name, dns_host_info_t *info)
 {
@@ -72 +75 @@
                 return rc;
 
-        return EOK;
+        list_foreach(amsg->answer, link) {
+                dns_rr_t *rr = list_get_instance(link, dns_rr_t, msg);
+
+                printf(" - '%s' %u/%u, dsize %u\n",
+                        rr->name, rr->rtype, rr->rclass, rr->rdata_size);
+
+                if (rr->rtype == DTYPE_A && rr->rclass == DC_IN) {
+                        if (rr->rdata_size != sizeof(uint32_t)) {
+                                printf("rdata_size = %u - fail\n", rr->rdata_size);
+                                return EIO;
+                        }
+
+                        info->name = str_dup(rr->name);
+                        info->addr.ipv4 = dns_uint32_t_decode(rr->rdata, rr->rdata_size);
+                        printf("info->addr = %x\n", info->addr.ipv4);
+                        return EOK;
+                }
+        }
+
+        printf("no A/IN found, fail\n");
+
+        return EIO;
 }