core/legacynet/dnsresolv.c - platform/external/syslinux - Git at Google

 #include <stdio.h>
 #include <string.h>
 #include <core.h>
 #include "pxe.h"

 /* DNS CLASS values we care about */
 #define CLASS_IN	1

 /* DNS TYPE values we care about */
 #define TYPE_A		1
 #define TYPE_CNAME	5

 /*
  * The DNS header structure
  */
 struct dnshdr {
     uint16_t id;
     uint16_t flags;
     /* number of entries in the question section */
     uint16_t qdcount;
     /* number of resource records in the answer section */
     uint16_t ancount;
     /* number of name server resource records in the authority records section*/
     uint16_t nscount;
     /* number of resource records in the additional records section */
     uint16_t arcount;
 } __attribute__ ((packed));

 /*
  * The DNS query structure
  */
 struct dnsquery {
     uint16_t qtype;
     uint16_t qclass;
 } __attribute__ ((packed));

 /*
  * The DNS Resource recodes structure
  */
 struct dnsrr {
     uint16_t type;
     uint16_t class;
     uint32_t ttl;
     uint16_t rdlength;   /* The lenght of this rr data */
     char     rdata[];
 } __attribute__ ((packed));


 #define DNS_PORT	htons(53)               /* Default DNS port */
 #define DNS_MAX_SERVERS 4		/* Max no of DNS servers */

 uint32_t dns_server[DNS_MAX_SERVERS] = {0, };


 /*
  * Turn a string in _src_ into a DNS "label set" in _dst_; returns the
  * number of dots encountered. On return, *dst is updated.
  */
 int dns_mangle(char **dst, const char *p)
 {
     char *q = *dst;
     char *count_ptr;
     char c;
     int dots = 0;

     count_ptr = q;
     *q++ = 0;

     while (1) {
         c = *p++;
         if (c == 0 || c == ':' || c == '/')
             break;
         if (c == '.') {
             dots++;
             count_ptr = q;
             *q++ = 0;
             continue;
         }

         *count_ptr += 1;
         *q++ = c;
     }

     if (*count_ptr)
         *q++ = 0;

     /* update the strings */
     *dst = q;
     return dots;
 }


 /*
  * Compare two sets of DNS labels, in _s1_ and _s2_; the one in _s2_
  * is allowed pointers relative to a packet in buf.
  *
  */
 static bool dns_compare(const void *s1, const void *s2, const void *buf)
 {
     const uint8_t *q = s1;
     const uint8_t *p = s2;
     unsigned int c0, c1;

     while (1) {
 	c0 = p[0];
         if (c0 >= 0xc0) {
 	    /* Follow pointer */
 	    c1 = p[1];
 	    p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
 	} else if (c0) {
 	    c0++;		/* Include the length byte */
 	    if (memcmp(q, p, c0))
 		return false;
 	    q += c0;
 	    p += c0;
 	} else {
 	    return *q == 0;
 	}
     }
 }

 /*
  * Copy a DNS label into a buffer, considering the possibility that we might
  * have to follow pointers relative to "buf".
  * Returns a pointer to the first free byte *after* the terminal null.
  */
 static void *dns_copylabel(void *dst, const void *src, const void *buf)
 {
     uint8_t *q = dst;
     const uint8_t *p = src;
     unsigned int c0, c1;

     while (1) {
 	c0 = p[0];
         if (c0 >= 0xc0) {
 	    /* Follow pointer */
 	    c1 = p[1];
 	    p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
 	} else if (c0) {
 	    c0++;		/* Include the length byte */
 	    memcpy(q, p, c0);
 	    p += c0;
 	    q += c0;
 	} else {
 	    *q++ = 0;
 	    return q;
 	}
     }
 }

 /*
  * Skip past a DNS label set in DS:SI
  */
 static char *dns_skiplabel(char *label)
 {
     uint8_t c;

     while (1) {
         c = *label++;
         if (c >= 0xc0)
             return ++label; /* pointer is two bytes */
         if (c == 0)
             return label;
         label += c;
     }
 }

 extern const uint8_t TimeoutTable[];
 extern uint16_t get_port(void);
 extern void free_port(uint16_t port);

 /*
  * parse the ip_str and return the ip address with *res.
  * return true if the whole string was consumed and the result
  * was valid.
  *
  */
 static bool parse_dotquad(const char *ip_str, uint32_t *res)
 {
     const char *p = ip_str;
     uint8_t part = 0;
     uint32_t ip = 0;
     int i;

     for (i = 0; i < 4; i++) {
         while (is_digit(*p)) {
             part = part * 10 + *p - '0';
             p++;
         }
         if (i != 3 && *p != '.')
             return false;

         ip = (ip << 8) | part;
         part = 0;
         p++;
     }
     p--;

     *res = htonl(ip);
     return *p == '\0';
 }

 /*
  * Actual resolver function
  * Points to a null-terminated or :-terminated string in _name_
  * and returns the ip addr in _ip_ if it exists and can be found.
  * If _ip_ = 0 on exit, the lookup failed. _name_ will be updated
  *
  * XXX: probably need some caching here.
  */
 __export uint32_t dns_resolv(const char *name)
 {
     static char __lowmem DNSSendBuf[PKTBUF_SIZE];
     static char __lowmem DNSRecvBuf[PKTBUF_SIZE];
     char *p;
     int err;
     int dots;
     int same;
     int rd_len;
     int ques, reps;    /* number of questions and replies */
     uint8_t timeout;
     const uint8_t *timeout_ptr = TimeoutTable;
     uint32_t oldtime;
     uint32_t srv;
     uint32_t *srv_ptr;
     struct dnshdr *hd1 = (struct dnshdr *)DNSSendBuf;
     struct dnshdr *hd2 = (struct dnshdr *)DNSRecvBuf;
     struct dnsquery *query;
     struct dnsrr *rr;
     static __lowmem struct s_PXENV_UDP_WRITE udp_write;
     static __lowmem struct s_PXENV_UDP_READ  udp_read;
     uint16_t local_port;
     uint32_t result = 0;

     /*
      * Return failure on an empty input... this can happen during
      * some types of URL parsing, and this is the easiest place to
      * check for it.
      */
     if (!name || !*name)
 	return 0;

     /* If it is a valid dot quad, just return that value */
     if (parse_dotquad(name, &result))
 	return result;

     /* Make sure we have at least one valid DNS server */
     if (!dns_server[0])
 	return 0;

     /* Get a local port number */
     local_port = get_port();

     /* First, fill the DNS header struct */
     hd1->id++;                      /* New query ID */
     hd1->flags   = htons(0x0100);   /* Recursion requested */
     hd1->qdcount = htons(1);        /* One question */
     hd1->ancount = 0;               /* No answers */
     hd1->nscount = 0;               /* No NS */
     hd1->arcount = 0;               /* No AR */

     p = DNSSendBuf + sizeof(struct dnshdr);
     dots = dns_mangle(&p, name);   /* store the CNAME */

     if (!dots) {
         p--; /* Remove final null */
         /* Uncompressed DNS label set so it ends in null */
         p = stpcpy(p, LocalDomain);
     }

     /* Fill the DNS query packet */
     query = (struct dnsquery *)p;
     query->qtype  = htons(TYPE_A);
     query->qclass = htons(CLASS_IN);
     p += sizeof(struct dnsquery);

     /* Now send it to name server */
     timeout_ptr = TimeoutTable;
     timeout = *timeout_ptr++;
     srv_ptr = dns_server;
     while (timeout) {
 	srv = *srv_ptr++;
 	if (!srv) {
 	    srv_ptr = dns_server;
 	    srv = *srv_ptr++;
 	}

         udp_write.status      = 0;
         udp_write.ip          = srv;
         udp_write.gw          = gateway(srv);
         udp_write.src_port    = local_port;
         udp_write.dst_port    = DNS_PORT;
         udp_write.buffer_size = p - DNSSendBuf;
         udp_write.buffer      = FAR_PTR(DNSSendBuf);
         err = pxe_call(PXENV_UDP_WRITE, &udp_write);
         if (err || udp_write.status)
             continue;

         oldtime = jiffies();
 	do {
 	    if (jiffies() - oldtime >= timeout)
 		goto again;

             udp_read.status      = 0;
             udp_read.src_ip      = srv;
             udp_read.dest_ip     = IPInfo.myip;
             udp_read.s_port      = DNS_PORT;
             udp_read.d_port      = local_port;
             udp_read.buffer_size = PKTBUF_SIZE;
             udp_read.buffer      = FAR_PTR(DNSRecvBuf);
             err = pxe_call(PXENV_UDP_READ, &udp_read);
 	} while (err || udp_read.status || hd2->id != hd1->id);

         if ((hd2->flags ^ 0x80) & htons(0xf80f))
             goto badness;

         ques = htons(hd2->qdcount);   /* Questions */
         reps = htons(hd2->ancount);   /* Replies   */
         p = DNSRecvBuf + sizeof(struct dnshdr);
         while (ques--) {
             p = dns_skiplabel(p); /* Skip name */
             p += 4;               /* Skip question trailer */
         }

         /* Parse the replies */
         while (reps--) {
             same = dns_compare(DNSSendBuf + sizeof(struct dnshdr),
 			       p, DNSRecvBuf);
             p = dns_skiplabel(p);
             rr = (struct dnsrr *)p;
             rd_len = ntohs(rr->rdlength);
             if (same && ntohs(rr->class) == CLASS_IN) {
 		switch (ntohs(rr->type)) {
 		case TYPE_A:
 		    if (rd_len == 4) {
 			result = *(uint32_t *)rr->rdata;
 			goto done;
 		    }
 		    break;
 		case TYPE_CNAME:
 		    dns_copylabel(DNSSendBuf + sizeof(struct dnshdr),
 				  rr->rdata, DNSRecvBuf);
 		    /*
 		     * We should probably rescan the packet from the top
 		     * here, and technically we might have to send a whole
 		     * new request here...
 		     */
 		    break;
 		default:
 		    break;
 		}
 	    }

             /* not the one we want, try next */
             p += sizeof(struct dnsrr) + rd_len;
         }

     badness:
         /*
          *
          ; We got back no data from this server.
          ; Unfortunately, for a recursive, non-authoritative
          ; query there is no such thing as an NXDOMAIN reply,
          ; which technically means we can't draw any
          ; conclusions.  However, in practice that means the
          ; domain doesn't exist.  If this turns out to be a
          ; problem, we may want to add code to go through all
          ; the servers before giving up.

          ; If the DNS server wasn't capable of recursion, and
          ; isn't capable of giving us an authoritative reply
          ; (i.e. neither AA or RA set), then at least try a
          ; different setver...
         */
         if (hd2->flags == htons(0x480))
             continue;

         break; /* failed */

     again:
 	continue;
     }

 done:
     free_port(local_port);	/* Return port number to the free pool */

     return result;
 }
	#include <stdio.h>
	#include <string.h>
	#include <core.h>
	#include "pxe.h"

	/* DNS CLASS values we care about */
	#define CLASS_IN 1

	/* DNS TYPE values we care about */
	#define TYPE_A 1
	#define TYPE_CNAME 5

	/*
	* The DNS header structure
	*/
	struct dnshdr {
	uint16_t id;
	uint16_t flags;
	/* number of entries in the question section */
	uint16_t qdcount;
	/* number of resource records in the answer section */
	uint16_t ancount;
	/* number of name server resource records in the authority records section*/
	uint16_t nscount;
	/* number of resource records in the additional records section */
	uint16_t arcount;
	} __attribute__ ((packed));

	/*
	* The DNS query structure
	*/
	struct dnsquery {
	uint16_t qtype;
	uint16_t qclass;
	} __attribute__ ((packed));

	/*
	* The DNS Resource recodes structure
	*/
	struct dnsrr {
	uint16_t type;
	uint16_t class;
	uint32_t ttl;
	uint16_t rdlength; /* The lenght of this rr data */
	char rdata[];
	} __attribute__ ((packed));


	#define DNS_PORT htons(53) /* Default DNS port */
	#define DNS_MAX_SERVERS 4 /* Max no of DNS servers */

	uint32_t dns_server[DNS_MAX_SERVERS] = {0, };


	/*
	* Turn a string in _src_ into a DNS "label set" in _dst_; returns the
	* number of dots encountered. On return, *dst is updated.
	*/
	int dns_mangle(char *dst, const char p)
	{
	char q = dst;
	char *count_ptr;
	char c;
	int dots = 0;

	count_ptr = q;
	*q++ = 0;

	while (1) {
	c = *p++;
	if (c == 0 \|\| c == ':' \|\| c == '/')
	break;
	if (c == '.') {
	dots++;
	count_ptr = q;
	*q++ = 0;
	continue;
	}

	*count_ptr += 1;
	*q++ = c;
	}

	if (*count_ptr)
	*q++ = 0;

	/* update the strings */
	*dst = q;
	return dots;
	}


	/*
	* Compare two sets of DNS labels, in _s1_ and _s2_; the one in _s2_
	* is allowed pointers relative to a packet in buf.
	*
	*/
	static bool dns_compare(const void s1, const void s2, const void *buf)
	{
	const uint8_t *q = s1;
	const uint8_t *p = s2;
	unsigned int c0, c1;

	while (1) {
	c0 = p[0];
	if (c0 >= 0xc0) {
	/* Follow pointer */
	c1 = p[1];
	p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
	} else if (c0) {
	c0++; /* Include the length byte */
	if (memcmp(q, p, c0))
	return false;
	q += c0;
	p += c0;
	} else {
	return *q == 0;
	}
	}
	}

	/*
	* Copy a DNS label into a buffer, considering the possibility that we might
	* have to follow pointers relative to "buf".
	* Returns a pointer to the first free byte after the terminal null.
	*/
	static void dns_copylabel(void dst, const void src, const void buf)
	{
	uint8_t *q = dst;
	const uint8_t *p = src;
	unsigned int c0, c1;

	while (1) {
	c0 = p[0];
	if (c0 >= 0xc0) {
	/* Follow pointer */
	c1 = p[1];
	p = (const uint8_t *)buf + ((c0 - 0xc0) << 8) + c1;
	} else if (c0) {
	c0++; /* Include the length byte */
	memcpy(q, p, c0);
	p += c0;
	q += c0;
	} else {
	*q++ = 0;
	return q;
	}
	}
	}

	/*
	* Skip past a DNS label set in DS:SI
	*/
	static char dns_skiplabel(char label)
	{
	uint8_t c;

	while (1) {
	c = *label++;
	if (c >= 0xc0)
	return ++label; /* pointer is two bytes */
	if (c == 0)
	return label;
	label += c;
	}
	}

	extern const uint8_t TimeoutTable[];
	extern uint16_t get_port(void);
	extern void free_port(uint16_t port);

	/*
	* parse the ip_str and return the ip address with *res.
	* return true if the whole string was consumed and the result
	* was valid.
	*
	*/
	static bool parse_dotquad(const char ip_str, uint32_t res)
	{
	const char *p = ip_str;
	uint8_t part = 0;
	uint32_t ip = 0;
	int i;

	for (i = 0; i < 4; i++) {
	while (is_digit(*p)) {
	part = part * 10 + *p - '0';
	p++;
	}
	if (i != 3 && *p != '.')
	return false;

	ip = (ip << 8) \| part;
	part = 0;
	p++;
	}
	p--;

	*res = htonl(ip);
	return *p == '\0';
	}

	/*
	* Actual resolver function
	* Points to a null-terminated or :-terminated string in _name_
	* and returns the ip addr in _ip_ if it exists and can be found.
	* If _ip_ = 0 on exit, the lookup failed. _name_ will be updated
	*
	* XXX: probably need some caching here.
	*/
	__export uint32_t dns_resolv(const char *name)
	{
	static char __lowmem DNSSendBuf[PKTBUF_SIZE];
	static char __lowmem DNSRecvBuf[PKTBUF_SIZE];
	char *p;
	int err;
	int dots;
	int same;
	int rd_len;
	int ques, reps; /* number of questions and replies */
	uint8_t timeout;
	const uint8_t *timeout_ptr = TimeoutTable;
	uint32_t oldtime;
	uint32_t srv;
	uint32_t *srv_ptr;
	struct dnshdr hd1 = (struct dnshdr )DNSSendBuf;
	struct dnshdr hd2 = (struct dnshdr )DNSRecvBuf;
	struct dnsquery *query;
	struct dnsrr *rr;
	static __lowmem struct s_PXENV_UDP_WRITE udp_write;
	static __lowmem struct s_PXENV_UDP_READ udp_read;
	uint16_t local_port;
	uint32_t result = 0;

	/*
	* Return failure on an empty input... this can happen during
	* some types of URL parsing, and this is the easiest place to
	* check for it.
	*/
	if (!name \|\| !*name)
	return 0;

	/* If it is a valid dot quad, just return that value */
	if (parse_dotquad(name, &result))
	return result;

	/* Make sure we have at least one valid DNS server */
	if (!dns_server[0])
	return 0;

	/* Get a local port number */
	local_port = get_port();

	/* First, fill the DNS header struct */
	hd1->id++; /* New query ID */
	hd1->flags = htons(0x0100); /* Recursion requested */
	hd1->qdcount = htons(1); /* One question */
	hd1->ancount = 0; /* No answers */
	hd1->nscount = 0; /* No NS */
	hd1->arcount = 0; /* No AR */

	p = DNSSendBuf + sizeof(struct dnshdr);
	dots = dns_mangle(&p, name); /* store the CNAME */

	if (!dots) {
	p--; /* Remove final null */
	/* Uncompressed DNS label set so it ends in null */
	p = stpcpy(p, LocalDomain);
	}

	/* Fill the DNS query packet */
	query = (struct dnsquery *)p;
	query->qtype = htons(TYPE_A);
	query->qclass = htons(CLASS_IN);
	p += sizeof(struct dnsquery);

	/* Now send it to name server */
	timeout_ptr = TimeoutTable;
	timeout = *timeout_ptr++;
	srv_ptr = dns_server;
	while (timeout) {
	srv = *srv_ptr++;
	if (!srv) {
	srv_ptr = dns_server;
	srv = *srv_ptr++;
	}

	udp_write.status = 0;
	udp_write.ip = srv;
	udp_write.gw = gateway(srv);
	udp_write.src_port = local_port;
	udp_write.dst_port = DNS_PORT;
	udp_write.buffer_size = p - DNSSendBuf;
	udp_write.buffer = FAR_PTR(DNSSendBuf);
	err = pxe_call(PXENV_UDP_WRITE, &udp_write);
	if (err \|\| udp_write.status)
	continue;

	oldtime = jiffies();
	do {
	if (jiffies() - oldtime >= timeout)
	goto again;

	udp_read.status = 0;
	udp_read.src_ip = srv;
	udp_read.dest_ip = IPInfo.myip;
	udp_read.s_port = DNS_PORT;
	udp_read.d_port = local_port;
	udp_read.buffer_size = PKTBUF_SIZE;
	udp_read.buffer = FAR_PTR(DNSRecvBuf);
	err = pxe_call(PXENV_UDP_READ, &udp_read);
	} while (err \|\| udp_read.status \|\| hd2->id != hd1->id);

	if ((hd2->flags ^ 0x80) & htons(0xf80f))
	goto badness;

	ques = htons(hd2->qdcount); /* Questions */
	reps = htons(hd2->ancount); /* Replies */
	p = DNSRecvBuf + sizeof(struct dnshdr);
	while (ques--) {
	p = dns_skiplabel(p); /* Skip name */
	p += 4; /* Skip question trailer */
	}

	/* Parse the replies */
	while (reps--) {
	same = dns_compare(DNSSendBuf + sizeof(struct dnshdr),
	p, DNSRecvBuf);
	p = dns_skiplabel(p);
	rr = (struct dnsrr *)p;
	rd_len = ntohs(rr->rdlength);
	if (same && ntohs(rr->class) == CLASS_IN) {
	switch (ntohs(rr->type)) {
	case TYPE_A:
	if (rd_len == 4) {
	result = (uint32_t )rr->rdata;
	goto done;
	}
	break;
	case TYPE_CNAME:
	dns_copylabel(DNSSendBuf + sizeof(struct dnshdr),
	rr->rdata, DNSRecvBuf);
	/*
	* We should probably rescan the packet from the top
	* here, and technically we might have to send a whole
	* new request here...
	*/
	break;
	default:
	break;
	}
	}

	/* not the one we want, try next */
	p += sizeof(struct dnsrr) + rd_len;
	}

	badness:
	/*
	*
	; We got back no data from this server.
	; Unfortunately, for a recursive, non-authoritative
	; query there is no such thing as an NXDOMAIN reply,
	; which technically means we can't draw any
	; conclusions. However, in practice that means the
	; domain doesn't exist. If this turns out to be a
	; problem, we may want to add code to go through all
	; the servers before giving up.

	; If the DNS server wasn't capable of recursion, and
	; isn't capable of giving us an authoritative reply
	; (i.e. neither AA or RA set), then at least try a
	; different setver...
	*/
	if (hd2->flags == htons(0x480))
	continue;

	break; /* failed */

	again:
	continue;
	}

	done:
	free_port(local_port); /* Return port number to the free pool */

	return result;
	}