core/legacynet/dnsresolv.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <core.h>
   4 #include "pxe.h"
   5
   6 /* DNS CLASS values we care about */
   7 #define CLASS_IN        1
   8
   9 /* DNS TYPE values we care about */
  10 #define TYPE_A          1
  11 #define TYPE_CNAME      5
  12
  13 /*
  14  * The DNS header structure
  15  */
  16 struct dnshdr {
  17     uint16_t id;
  18     uint16_t flags;
  19     /* number of entries in the question section */
  20     uint16_t qdcount;
  21     /* number of resource records in the answer section */
  22     uint16_t ancount;
  23     /* number of name server resource records in the authority records section*/
  24     uint16_t nscount;
  25     /* number of resource records in the additional records section */
  26     uint16_t arcount;
  27 } __attribute__ ((packed));
  28
  29 /*
  30  * The DNS query structure
  31  */
  32 struct dnsquery {
  33     uint16_t qtype;
  34     uint16_t qclass;
  35 } __attribute__ ((packed));
  36
  37 /*
  38  * The DNS Resource recodes structure
  39  */
  40 struct dnsrr {
  41     uint16_t type;
  42     uint16_t class;
  43     uint32_t ttl;
  44     uint16_t rdlength;   /* The lenght of this rr data */
  45     char     rdata[];
  46 } __attribute__ ((packed));
  47
  48
  49 #define DNS_PORT        htons(53)               /* Default DNS port */
  50 #define DNS_MAX_SERVERS 4               /* Max no of DNS servers */
  51
  52 uint32_t dns_server[DNS_MAX_SERVERS] = {0, };
  53
  54
  55 /*
  56  * Turn a string in _src_ into a DNS "label set" in _dst_; returns the
  57  * number of dots encountered. On return, *dst is updated.
  58  */
  59 int dns_mangle(char **dst, const char *p)
  60 {
  61     char *q = *dst;
  62     char *count_ptr;
  63     char c;
  64     int dots = 0;
  65
  66     count_ptr = q;
  67     *q++ = 0;
  68
  69     while (1) {
  70         c = *p++;
  71         if (c == 0 || c == ':' || c == '/')
  72             break;
  73         if (c == '.') {
  74             dots++;
  75             count_ptr = q;
  76             *q++ = 0;
  77             continue;
  78         }
  79
  80         *count_ptr += 1;
  81         *q++ = c;
  82     }
  83
  84     if (*count_ptr)
  85         *q++ = 0;
  86
  87     /* update the strings */
  88     *dst = q;
  89     return dots;
  90 }
  91
  92
  93 /*
  94  * Compare two sets of DNS labels, in _s1_ and _s2_; the one in _s2_
  95  * is allowed pointers relative to a packet in buf.
  96  *
  97  */
  98 static bool dns_compare(const void *s1, const void *s2, const void *buf)
  99 {
 100     const uint8_t *q = s1;
 101     const uint8_t *p = s2;
 102     unsigned int c0, c1;
 103
 104     while (1) {
 105         c0 = p[0];
 106         if (c0 >= 0xc0) {
 107             /* Follow pointer */
 108             c1 = p[1];
 109             p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
 110         } else if (c0) {
 111             c0++;               /* Include the length byte */
 112             if (memcmp(q, p, c0))
 113                 return false;
 114             q += c0;
 115             p += c0;
 116         } else {
 117             return *q == 0;
 118         }
 119     }
 120 }
 121
 122 /*
 123  * Copy a DNS label into a buffer, considering the possibility that we might
 124  * have to follow pointers relative to "buf".
 125  * Returns a pointer to the first free byte *after* the terminal null.
 126  */
 127 static void *dns_copylabel(void *dst, const void *src, const void *buf)
 128 {
 129     uint8_t *q = dst;
 130     const uint8_t *p = src;
 131     unsigned int c0, c1;
 132
 133     while (1) {
 134         c0 = p[0];
 135         if (c0 >= 0xc0) {
 136             /* Follow pointer */
 137             c1 = p[1];
 138             p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
 139         } else if (c0) {
 140             c0++;               /* Include the length byte */
 141             memcpy(q, p, c0);
 142             p += c0;
 143             q += c0;
 144         } else {
 145             *q++ = 0;
 146             return q;
 147         }
 148     }
 149 }
 150
 151 /*
 152  * Skip past a DNS label set in DS:SI
 153  */
 154 static char *dns_skiplabel(char *label)
 155 {
 156     uint8_t c;
 157
 158     while (1) {
 159         c = *label++;
 160         if (c >= 0xc0)
 161             return ++label; /* pointer is two bytes */
 162         if (c == 0)
 163             return label;
 164         label += c;
 165     }
 166 }
 167
 168 extern const uint8_t TimeoutTable[];
 169 extern uint16_t get_port(void);
 170 extern void free_port(uint16_t port);
 171
 172 /*
 173  * parse the ip_str and return the ip address with *res.
 174  * return true if the whole string was consumed and the result
 175  * was valid.
 176  *
 177  */
 178 static bool parse_dotquad(const char *ip_str, uint32_t *res)
 179 {
 180     const char *p = ip_str;
 181     uint8_t part = 0;
 182     uint32_t ip = 0;
 183     int i;
 184
 185     for (i = 0; i < 4; i++) {
 186         while (is_digit(*p)) {
 187             part = part * 10 + *p - '0';
 188             p++;
 189         }
 190         if (i != 3 && *p != '.')
 191             return false;
 192
 193         ip = (ip << 8) | part;
 194         part = 0;
 195         p++;
 196     }
 197     p--;
 198
 199     *res = htonl(ip);
 200     return *p == '\0';
 201 }
 202
 203 /*
 204  * Actual resolver function
 205  * Points to a null-terminated or :-terminated string in _name_
 206  * and returns the ip addr in _ip_ if it exists and can be found.
 207  * If _ip_ = 0 on exit, the lookup failed. _name_ will be updated
 208  *
 209  * XXX: probably need some caching here.
 210  */
 211 __export uint32_t dns_resolv(const char *name)
 212 {
 213     static char __lowmem DNSSendBuf[PKTBUF_SIZE];
 214     static char __lowmem DNSRecvBuf[PKTBUF_SIZE];
 215     char *p;
 216     int err;
 217     int dots;
 218     int same;
 219     int rd_len;
 220     int ques, reps;    /* number of questions and replies */
 221     uint8_t timeout;
 222     const uint8_t *timeout_ptr = TimeoutTable;
 223     uint32_t oldtime;
 224     uint32_t srv;
 225     uint32_t *srv_ptr;
 226     struct dnshdr *hd1 = (struct dnshdr *)DNSSendBuf;
 227     struct dnshdr *hd2 = (struct dnshdr *)DNSRecvBuf;
 228     struct dnsquery *query;
 229     struct dnsrr *rr;
 230     static __lowmem struct s_PXENV_UDP_WRITE udp_write;
 231     static __lowmem struct s_PXENV_UDP_READ  udp_read;
 232     uint16_t local_port;
 233     uint32_t result = 0;
 234
 235     /*
 236      * Return failure on an empty input... this can happen during
 237      * some types of URL parsing, and this is the easiest place to
 238      * check for it.
 239      */
 240     if (!name || !*name)
 241         return 0;
 242
 243     /* If it is a valid dot quad, just return that value */
 244     if (parse_dotquad(name, &result))
 245         return result;
 246
 247     /* Make sure we have at least one valid DNS server */
 248     if (!dns_server[0])
 249         return 0;
 250
 251     /* Get a local port number */
 252     local_port = get_port();
 253
 254     /* First, fill the DNS header struct */
 255     hd1->id++;                      /* New query ID */
 256     hd1->flags   = htons(0x0100);   /* Recursion requested */
 257     hd1->qdcount = htons(1);        /* One question */
 258     hd1->ancount = 0;               /* No answers */
 259     hd1->nscount = 0;               /* No NS */
 260     hd1->arcount = 0;               /* No AR */
 261
 262     p = DNSSendBuf + sizeof(struct dnshdr);
 263     dots = dns_mangle(&p, name);   /* store the CNAME */
 264
 265     if (!dots) {
 266         p--; /* Remove final null */
 267         /* Uncompressed DNS label set so it ends in null */
 268         p = stpcpy(p, LocalDomain);
 269     }
 270
 271     /* Fill the DNS query packet */
 272     query = (struct dnsquery *)p;
 273     query->qtype  = htons(TYPE_A);
 274     query->qclass = htons(CLASS_IN);
 275     p += sizeof(struct dnsquery);
 276
 277     /* Now send it to name server */
 278     timeout_ptr = TimeoutTable;
 279     timeout = *timeout_ptr++;
 280     srv_ptr = dns_server;
 281     while (timeout) {
 282         srv = *srv_ptr++;
 283         if (!srv) {
 284             srv_ptr = dns_server;
 285             srv = *srv_ptr++;
 286         }
 287
 288         udp_write.status      = 0;
 289         udp_write.ip          = srv;
 290         udp_write.gw          = gateway(srv);
 291         udp_write.src_port    = local_port;
 292         udp_write.dst_port    = DNS_PORT;
 293         udp_write.buffer_size = p - DNSSendBuf;
 294         udp_write.buffer      = FAR_PTR(DNSSendBuf);
 295         err = pxe_call(PXENV_UDP_WRITE, &udp_write);
 296         if (err || udp_write.status)
 297             continue;
 298
 299         oldtime = jiffies();
 300         do {
 301             if (jiffies() - oldtime >= timeout)
 302                 goto again;
 303
 304             udp_read.status      = 0;
 305             udp_read.src_ip      = srv;
 306             udp_read.dest_ip     = IPInfo.myip;
 307             udp_read.s_port      = DNS_PORT;
 308             udp_read.d_port      = local_port;
 309             udp_read.buffer_size = PKTBUF_SIZE;
 310             udp_read.buffer      = FAR_PTR(DNSRecvBuf);
 311             err = pxe_call(PXENV_UDP_READ, &udp_read);
 312         } while (err || udp_read.status || hd2->id != hd1->id);
 313
 314         if ((hd2->flags ^ 0x80) & htons(0xf80f))
 315             goto badness;
 316
 317         ques = htons(hd2->qdcount);   /* Questions */
 318         reps = htons(hd2->ancount);   /* Replies   */
 319         p = DNSRecvBuf + sizeof(struct dnshdr);
 320         while (ques--) {
 321             p = dns_skiplabel(p); /* Skip name */
 322             p += 4;               /* Skip question trailer */
 323         }
 324
 325         /* Parse the replies */
 326         while (reps--) {
 327             same = dns_compare(DNSSendBuf + sizeof(struct dnshdr),
 328                                p, DNSRecvBuf);
 329             p = dns_skiplabel(p);
 330             rr = (struct dnsrr *)p;
 331             rd_len = ntohs(rr->rdlength);
 332             if (same && ntohs(rr->class) == CLASS_IN) {
 333                 switch (ntohs(rr->type)) {
 334                 case TYPE_A:
 335                     if (rd_len == 4) {
 336                         result = *(uint32_t *)rr->rdata;
 337                         goto done;
 338                     }
 339                     break;
 340                 case TYPE_CNAME:
 341                     dns_copylabel(DNSSendBuf + sizeof(struct dnshdr),
 342                                   rr->rdata, DNSRecvBuf);
 343                     /*
 344                      * We should probably rescan the packet from the top
 345                      * here, and technically we might have to send a whole
 346                      * new request here...
 347                      */
 348                     break;
 349                 default:
 350                     break;
 351                 }
 352             }
 353
 354             /* not the one we want, try next */
 355             p += sizeof(struct dnsrr) + rd_len;
 356         }
 357
 358     badness:
 359         /*
 360          *
 361          ; We got back no data from this server.
 362          ; Unfortunately, for a recursive, non-authoritative
 363          ; query there is no such thing as an NXDOMAIN reply,
 364          ; which technically means we can't draw any
 365          ; conclusions.  However, in practice that means the
 366          ; domain doesn't exist.  If this turns out to be a
 367          ; problem, we may want to add code to go through all
 368          ; the servers before giving up.
 369
 370          ; If the DNS server wasn't capable of recursion, and
 371          ; isn't capable of giving us an authoritative reply
 372          ; (i.e. neither AA or RA set), then at least try a
 373          ; different setver...
 374         */
 375         if (hd2->flags == htons(0x480))
 376             continue;
 377
 378         break; /* failed */
 379
 380     again:
 381         continue;
 382     }
 383
 384 done:
 385     free_port(local_port);      /* Return port number to the free pool */
 386
 387     return result;
 388 }