gcc is rather over-aggressive about optimising out static data structures
[people/asdlkf/gpxe.git] / 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 struct dns_rr_info * dns_find_rr ( struct dns_query *query,
149                                    struct dns_header *reply ) {
150         int i, cmp;
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                 cmp = dns_name_cmp ( query->payload, p, reply );
161                 p = dns_skip_name ( p );
162                 if ( cmp == 0 )
163                         return ( ( struct dns_rr_info * ) 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  * Produce a printable version of a DNS name.  Used only for debugging.
197  *
198  */
199 static inline char * dns_unmake_name ( char *name ) {
200         char *p;
201         unsigned int len;
202
203         p = name;
204         while ( ( len = *p ) ) {
205                 *(p++) = '.';
206                 p += len;
207         }
208         
209         return name + 1;
210 }
211
212 /*
213  * Decompress a DNS name.
214  *
215  * Returns a pointer to the character following the decompressed DNS
216  * name.
217  *
218  */
219 static inline char * dns_decompress_name ( char *dest, const char *name,
220                                            struct dns_header *header ) {
221         int i, len;
222
223         do {
224                 /* Obtain next section of name */
225                 while ( ( *name ) & 0xc0 ) {
226                         name = ( ( char * ) header +
227                                  ( ntohs ( *((uint16_t *)name) ) & ~0xc000 ) );
228                 }
229                 /* Copy data */
230                 len = *name;
231                 for ( i = len + 1 ; i > 0 ; i-- ) {
232                         *(dest++) = *(name++);
233                 }
234         } while ( len );
235         return dest;
236 }
237
238 /*
239  * Resolve a name using DNS
240  *
241  */
242 static int dns_resolv ( struct in_addr *addr, const char *name ) {
243         struct dns_query query;
244         struct dns_query_info *query_info;
245         struct dns_header *reply;
246         struct dns_rr_info *rr_info;
247         struct sockaddr_in nameserver;
248         uint16_t qtype;
249         unsigned int recursion = 0;
250         unsigned int id = 1;
251
252         /* Fail immediately if we have no name server */
253         if ( ! arptable[ARP_NAMESERVER].ipaddr.s_addr ) {
254                 DBG ( "DNS has no nameserver\n" );
255                 return 0;
256         }
257
258         DBG ( "DNS resolving %s\n", name );
259
260         /* Set up the query data */
261         nameserver.sin_addr = arptable[ARP_NAMESERVER].ipaddr;
262         nameserver.sin_port = DNS_UDP_PORT;
263         memset ( &query, 0, sizeof ( query ) );
264         query.dns.flags = htons ( DNS_FLAG_QUERY | DNS_FLAG_OPCODE_QUERY |
265                                   DNS_FLAG_RD );
266         query.dns.qdcount = htons ( 1 );
267         query_info = ( void * ) dns_make_name ( query.payload, name );
268         query_info->qtype = htons ( DNS_TYPE_A );
269         query_info->qclass = htons ( DNS_CLASS_IN );
270
271         while ( 1 ) {
272                 /* Transmit current query, wait for reply */
273                 query.dns.id = htons ( id++ );
274                 qtype = ntohs ( query_info->qtype );
275                 reply = dns_query ( &query,
276                                     ( ( ( char * ) query_info )
277                                       + sizeof ( *query_info )
278                                       - ( ( char * ) &query ) ),
279                                     &nameserver );
280                 if ( ! reply ) {
281                         DBG ( "DNS got no response from server %@ (port %d)\n",
282                               nameserver.sin_addr.s_addr,
283                               nameserver.sin_port );
284                         return 0;
285                 }
286
287                 /* Search through response for useful answers.  Do
288                  * this multiple times, to take advantage of useful
289                  * nameservers which send us e.g. the CNAME *and* the
290                  * A record for the pointed-to name.
291                  */
292                 while ( ( rr_info = dns_find_rr ( &query, reply ) ) ) {
293                         switch ( ntohs ( rr_info->type ) ) {
294                         case DNS_TYPE_A: {
295                                 /* Found the target A record */
296                                 struct dns_rr_info_a *rr_info_a =
297                                         ( struct dns_rr_info_a * ) rr_info;
298                                 *addr = rr_info_a->in_addr;
299                                 DBG ( "DNS found address %@\n", addr->s_addr );
300                                 return 1; }
301                         case DNS_TYPE_CNAME: {
302                                 /* Found a CNAME record - update the query */
303                                 struct dns_rr_info_cname *rr_info_cname =
304                                         ( struct dns_rr_info_cname * ) rr_info;
305                                 char *cname = rr_info_cname->cname;
306
307                                 query_info = ( void * )
308                                         dns_decompress_name ( query.payload,
309                                                               cname, reply );
310                                 DBG ( "DNS found CNAME %s\n",
311                                       dns_unmake_name ( query.payload ) );
312                                 DBG ( "", /* Reconstruct name */
313                                       dns_make_name ( query.payload,
314                                                       query.payload + 1 ) );
315                                 
316                                 query_info->qtype = htons ( DNS_TYPE_A );
317                                 query_info->qclass = htons ( DNS_CLASS_IN );
318
319                                 if ( ++recursion > DNS_MAX_CNAME_RECURSION ) {
320                                         DBG ( "DNS recursion exceeded\n" );
321                                         return 0;
322                                 }
323                                 break; }
324                         default:
325                                 DBG ( "DNS got unknown record type %d\n",
326                                       ntohs ( rr_info->type ) );
327                                 return 0;
328                         }
329                 }
330                 
331                 /* Determine what to do next based on the type of
332                  * query we issued and the reponse we received
333                  */
334                 switch ( qtype ) {
335                 case DNS_TYPE_A :
336                         /* We asked for an A record and got nothing;
337                          * try the CNAME.
338                          */
339                         DBG ( "DNS found no A record; trying CNAME\n" );
340                         query_info->qtype = htons ( DNS_TYPE_CNAME );
341                         break;
342                 case DNS_TYPE_CNAME :
343                         /* We asked for a CNAME record.  If we didn't
344                          * get any response (i.e. the next A query
345                          * isn't already set up), then abort.
346                          */
347                         if ( query_info->qtype != htons ( DNS_TYPE_A ) ) {
348                                 DBG ( "DNS found no CNAME record\n" );
349                                 return 0;
350                         }
351                         break;
352                 default:
353                         DBG ( "DNS internal error - inconsistent state\n" );
354                 }
355         }
356 }
357
358 struct resolver dns_resolver __resolver = {
359         .name = "DNS",
360         .resolv = dns_resolv,
361 };