src/proto/dns.c

   1 /**************************************************************************
   2 *
   3 *    dns_resolver.c: Etherboot support for resolution of host/domain
   4 *    names in filename parameters
   5 *    Written 2004 by Anselm M. Hoffmeister
   6 *    <stockholm@users.sourceforge.net>
   7 *
   8 *    This program is free software; you can redistribute it and/or modify
   9 *    it under the terms of the GNU General Public License as published by
  10 *    the Free Software Foundation; either version 2 of the License, or
  11 *    (at your option) any later version.
  12 *
  13 *    This program is distributed in the hope that it will be useful,
  14 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 *    GNU General Public License for more details.
  17 *
  18 *    You should have received a copy of the GNU General Public License
  19 *    along with this program; if not, write to the Free Software
  20 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 *
  22 *    This code is using nuts and bolts from throughout etherboot.
  23 *    It is a fresh implementation according to the DNS RFC, #1035
  24 *
  25 *    REVISION HISTORY:
  26 *    ================
  27 *    2004-05-10 File created
  28 *    2004-05-19 First release to CVS
  29 *    2004-05-22 CNAME support first stage finished
  30 *    2004-05-24 First "stable" release to CVS
  31 *    2004-08-28 Improve readability, set recursion flag
  32 *    2005-04-30 Tidied up to the point of being a complete rewrite (mcb30)
  33 ***************************************************************************/
  34
  35 #include "etherboot.h"
  36 #include "nic.h"
  37 #include "resolv.h"
  38 #include "dns.h"
  39
  40 /*
  41  *      await_dns
  42  *      Shall be called on any incoming packet during the resolution process
  43  *      (as is the case with all the other await_ functions in etherboot)
  44  *      Param:  as any await functions
  45  *
  46  */
  47 static int await_dns ( int ival, void *ptr,
  48                        unsigned short ptype __unused,
  49                        struct iphdr *ip __unused,
  50                        struct udphdr *udp, struct tcphdr *tcp __unused ) {
  51         struct dns_header **header = ptr;
  52
  53         if ( ! udp )
  54                 return 0;
  55         if ( ntohs ( udp->dest ) != ival )
  56                 return 0;
  57         *header = ( struct dns_header * ) ( udp + 1 );
  58         return 1;
  59 }
  60
  61 /*
  62  * Send a name server query and wait for a response.  Query is retried
  63  * up to DNS_MAX_RETRIES times.  Returns a pointer to the answer
  64  * packet, or NULL if no answer was received.
  65  *
  66  */
  67 struct dns_header * dns_query ( struct dns_query *query,
  68                                 unsigned int query_len,
  69                                 struct sockaddr_in *nameserver ) {
  70         long timeout;
  71         int retry;
  72         struct dns_header *reply;
  73
  74         for ( retry = 0 ; retry < DNS_MAX_RETRIES ; retry++ ) {
  75                 udp_transmit ( nameserver->sin_addr.s_addr,
  76                                nameserver->sin_port, nameserver->sin_port,
  77                                query_len, query );
  78                 timeout = rfc2131_sleep_interval ( TIMEOUT, retry );
  79                 if ( ! await_reply ( await_dns, nameserver->sin_port,
  80                                      &reply, timeout ) )
  81                         continue;
  82                 if ( reply->id != query->dns.id ) {
  83                         DBG ( "DNS received unexpected reply ID %d "
  84                               "(wanted %d)\n",
  85                               ntohs ( reply->id ), ntohs ( query->dns.id ) );
  86                         continue;
  87                 }
  88                 /* We have a valid reply! */
  89                 return reply;
  90         }
  91         return NULL;
  92 }
  93
  94 /*
  95  * Compare two DNS names to see if they are the same.  Takes
  96  * compressed names in the reply into account (though the query name
  97  * must be uncompressed).  Returns 0 for a match (for consistency with
  98  * strcmp et al).
  99  *
 100  */
 101 static inline int dns_name_cmp ( const char *qname, const char *rname,
 102                                  struct dns_header *reply ) {
 103         int i;
 104         while ( 1 ) {
 105                 /* Obtain next section of rname */
 106                 while ( ( *rname ) & 0xc0 ) {
 107                         rname = ( ( char * ) reply +
 108                                   ( ntohs( *((uint16_t *)rname) ) & ~0xc000 ));
 109                 }
 110                 /* Check that lengths match */
 111                 if ( *rname != *qname )
 112                         return 1;
 113                 /* If length is zero, we have reached the end */
 114                 if ( ! *qname )
 115                         return 0;
 116                 /* Check that data matches */
 117                 for ( i = *qname + 1; i > 0 ; i-- ) {
 118                         if ( *(rname++) != *(qname++) )
 119                                 return 1;
 120                 }
 121         }
 122 }
 123
 124 /*
 125  * Skip over a DNS name, which may be compressed
 126  *
 127  */
 128 static inline const char * dns_skip_name ( const char *name ) {
 129         while ( 1 ) {
 130                 if ( ! *name ) {
 131                         /* End of name */
 132                         return ( name + 1);
 133                 }
 134                 if ( *name & 0xc0 ) {
 135                         /* Start of a compressed name */
 136                         return ( name + 2 );
 137                 }
 138                 /* Uncompressed name portion */
 139                 name += *name + 1;
 140         }
 141 }
 142
 143 /*
 144  * Find a Resource Record in a reply packet corresponding to our
 145  * query.  Returns a pointer to the RR, or NULL if no answer found.
 146  *
 147  */
 148 static struct dns_rr_info * dns_find_rr ( struct dns_query *query,
 149                                           struct dns_header *reply ) {
 150         int i;
 151         const char *p = ( ( char * ) reply ) + sizeof ( struct dns_header );
 152
 153         /* Skip over the questions section */
 154         for ( i = ntohs ( reply->qdcount ) ; i > 0 ; i-- ) {
 155                 p = dns_skip_name ( p ) + sizeof ( struct dns_query_info );
 156         }
 157
 158         /* Process the answers section */
 159         for ( i = ntohs ( reply->ancount ) ; i > 0 ; i-- ) {
 160                 if ( dns_name_cmp ( query->payload, p, reply ) == 0 ) {
 161                         return ( ( struct dns_rr_info * ) p );
 162                 }
 163                 p = dns_skip_name ( p );
 164                 p += ( sizeof ( struct dns_rr_info ) +
 165                        ntohs ( ( ( struct dns_rr_info * ) p )->rdlength ) );
 166         }
 167
 168         return NULL;
 169 }
 170
 171 /*
 172  * Convert a standard NUL-terminated string to a DNS query name,
 173  * consisting of "<length>element" pairs.
 174  *
 175  * Returns a pointer to the character following the constructed DNS
 176  * query name.
 177  *
 178  */
 179 static inline char * dns_make_name ( char *dest, const char *name ) {
 180         char *length_byte = dest++;
 181         char c;
 182
 183         while ( ( c = *(name++) ) ) {
 184                 if ( c == '.' ) {
 185                         *length_byte = dest - length_byte - 1;
 186                         length_byte = dest;
 187                 }
 188                 *(dest++) = c;
 189         }
 190         *length_byte = dest - length_byte - 1;
 191         *(dest++) = '\0';
 192         return dest;
 193 }
 194
 195 /*
 196  * Decompress a DNS name.
 197  *
 198  * Returns a pointer to the character following the decompressed DNS
 199  * name.
 200  *
 201  */
 202 static inline char * dns_decompress_name ( char *dest, const char *name,
 203                                            struct dns_header *header ) {
 204         int i, len;
 205
 206         do {
 207                 /* Obtain next section of name */
 208                 while ( ( *name ) & 0xc0 ) {
 209                         name = ( ( char * ) header +
 210                                  ( ntohs ( *((uint16_t *)name) ) & ~0xc000 ) );
 211                 }
 212                 /* Copy data */
 213                 len = *name;
 214                 for ( i = len + 1 ; i > 0 ; i-- ) {
 215                         *(dest++) = *(name++);
 216                 }
 217         } while ( len );
 218         return dest;
 219 }
 220
 221 /*
 222  * Resolve a name using DNS
 223  *
 224  */
 225 static int dns_resolv ( struct in_addr *addr, const char *name ) {
 226         struct dns_query query;
 227         struct dns_query_info *query_info;
 228         struct dns_header *reply;
 229         struct dns_rr_info *rr_info;
 230         struct sockaddr_in nameserver;
 231         uint16_t qtype;
 232         unsigned int recursion = 0;
 233         unsigned int id = 1;
 234
 235         DBG ( "DNS resolving %s\n", name );
 236
 237         /* Set up the query data */
 238         nameserver.sin_addr = arptable[ARP_NAMESERVER].ipaddr;
 239         nameserver.sin_port = DNS_UDP_PORT;
 240         memset ( &query, 0, sizeof ( query ) );
 241         query.dns.flags = htons ( DNS_FLAG_QUERY | DNS_FLAG_OPCODE_QUERY |
 242                                   DNS_FLAG_RD );
 243         query.dns.qdcount = htons ( 1 );
 244         query_info = ( void * ) dns_make_name ( query.payload, name );
 245         query_info->qtype = htons ( DNS_TYPE_A );
 246         query_info->qclass = htons ( DNS_CLASS_IN );
 247
 248         while ( 1 ) {
 249                 /* Transmit current query, wait for reply */
 250                 query.dns.id = htons ( id++ );
 251                 qtype = ntohs ( query_info->qtype );
 252                 reply = dns_query ( &query,
 253                                     ( ( ( char * ) query_info )
 254                                       + sizeof ( *query_info )
 255                                       - ( ( char * ) &query ) ),
 256                                     &nameserver );
 257                 if ( ! reply ) {
 258                         DBG ( "DNS got no response from server %@ (port %d)\n",
 259                               nameserver.sin_addr.s_addr,
 260                               nameserver.sin_port );
 261                         return 0;
 262                 }
 263
 264                 /* Search through response for useful answers.  Do
 265                  * this multiple times, to take advantage of useful
 266                  * nameservers which send us e.g. the CNAME *and* the
 267                  * A record for the pointed-to name.
 268                  */
 269                 while ( ( rr_info = dns_find_rr ( &query, reply ) ) ) {
 270                         switch ( ntohs ( rr_info->type ) ) {
 271                         case DNS_TYPE_A: {
 272                                 /* Found the target A record */
 273                                 struct dns_rr_info_a *rr_info_a =
 274                                         ( struct dns_rr_info_a * ) rr_info;
 275                                 *addr = rr_info_a->in_addr;
 276                                 DBG ( "DNS found address %@\n", addr->s_addr );
 277                                 return 1; }
 278                         case DNS_TYPE_CNAME: {
 279                                 /* Found a CNAME record - update the query */
 280                                 struct dns_rr_info_cname *rr_info_cname =
 281                                         ( struct dns_rr_info_cname * ) rr_info;
 282                                 char *cname = rr_info_cname->cname;
 283
 284                                 DBG ( "DNS found CNAME\n" );
 285                                 query_info = ( void * )
 286                                         dns_decompress_name ( query.payload,
 287                                                               cname, reply );
 288                                 query_info->qtype = htons ( DNS_TYPE_A );
 289                                 query_info->qclass = htons ( DNS_CLASS_IN );
 290
 291                                 if ( ++recursion > DNS_MAX_CNAME_RECURSION ) {
 292                                         DBG ( "DNS recursion exceeded\n" );
 293                                         return 0;
 294                                 }
 295                                 break; }
 296                         default:
 297                                 DBG ( "DNS got unknown record type %d\n",
 298                                       ntohs ( rr_info->type ) );
 299                                 return 0;
 300                         }
 301                 }
 302
 303                 /* Determine what to do next based on the type of
 304                  * query we issued and the reponse we received
 305                  */
 306                 switch ( qtype ) {
 307                 case DNS_TYPE_A :
 308                         /* We asked for an A record and got nothing;
 309                          * try the CNAME.
 310                          */
 311                         DBG ( "DNS found no A record; trying CNAME\n" );
 312                         query_info->qtype = htons ( DNS_TYPE_CNAME );
 313                         break;
 314                 case DNS_TYPE_CNAME :
 315                         /* We asked for a CNAME record.  If we didn't
 316                          * get any response (i.e. the next A query
 317                          * isn't already set up), then abort.
 318                          */
 319                         if ( query_info->qtype != htons ( DNS_TYPE_A ) ) {
 320                                 DBG ( "DNS found no CNAME record\n" );
 321                                 return 0;
 322                         }
 323                         break;
 324                 default:
 325                         DBG ( "DNS internal error - inconsistent state\n" );
 326                 }
 327         }
 328 }
 329
 330 static struct resolver dns_resolver __resolver = {
 331         .name = "DNS",
 332         .resolv = dns_resolv,
 333 };