![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dns.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / udp|
Return to dns.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / udp |
1.1 root 1: /*
2: * Copyright (C) 2006 Michael Brown <[email protected]>.
3: *
4: * Portions copyright (C) 2004 Anselm M. Hoffmeister
5: * <[email protected]>.
6: *
7: * This program is free software; you can redistribute it and/or
8: * modify it under the terms of the GNU General Public License as
9: * published by the Free Software Foundation; either version 2 of the
10: * License, or any later version.
11: *
12: * This program is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with this program; if not, write to the Free Software
19: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21:
22: FILE_LICENCE ( GPL2_OR_LATER );
23:
24: #include <stdint.h>
25: #include <stdlib.h>
26: #include <string.h>
27: #include <stdio.h>
28: #include <errno.h>
29: #include <byteswap.h>
30: #include <ipxe/refcnt.h>
31: #include <ipxe/iobuf.h>
32: #include <ipxe/xfer.h>
33: #include <ipxe/open.h>
34: #include <ipxe/resolv.h>
35: #include <ipxe/retry.h>
36: #include <ipxe/tcpip.h>
37: #include <ipxe/settings.h>
38: #include <ipxe/features.h>
39: #include <ipxe/dns.h>
40:
41: /** @file
42: *
43: * DNS protocol
44: *
45: */
46:
47: FEATURE ( FEATURE_PROTOCOL, "DNS", DHCP_EB_FEATURE_DNS, 1 );
48:
49: /* Disambiguate the various error causes */
50: #define ENXIO_NO_RECORD __einfo_error ( EINFO_ENXIO_NO_RECORD )
51: #define EINFO_ENXIO_NO_RECORD \
52: __einfo_uniqify ( EINFO_ENXIO, 0x01, "DNS name does not exist" )
53: #define ENXIO_NO_NAMESERVER __einfo_error ( EINFO_ENXIO_NO_NAMESERVER )
54: #define EINFO_ENXIO_NO_NAMESERVER \
55: __einfo_uniqify ( EINFO_ENXIO, 0x02, "No DNS servers available" )
56:
57: /** The DNS server */
58: static struct sockaddr_tcpip nameserver = {
59: .st_port = htons ( DNS_PORT ),
60: };
61:
62: /** The local domain */
63: static char *localdomain;
64:
65: /** A DNS request */
66: struct dns_request {
67: /** Reference counter */
68: struct refcnt refcnt;
69: /** Name resolution interface */
70: struct interface resolv;
71: /** Data transfer interface */
72: struct interface socket;
73: /** Retry timer */
74: struct retry_timer timer;
75:
76: /** Socket address to fill in with resolved address */
77: struct sockaddr sa;
78: /** Current query packet */
79: struct dns_query query;
80: /** Location of query info structure within current packet
81: *
82: * The query info structure is located immediately after the
83: * compressed name.
84: */
85: struct dns_query_info *qinfo;
86: /** Recursion counter */
87: unsigned int recursion;
88: };
89:
90: /**
91: * Mark DNS request as complete
92: *
93: * @v dns DNS request
94: * @v rc Return status code
95: */
96: static void dns_done ( struct dns_request *dns, int rc ) {
97:
98: /* Stop the retry timer */
99: stop_timer ( &dns->timer );
100:
101: /* Shut down interfaces */
102: intf_shutdown ( &dns->socket, rc );
103: intf_shutdown ( &dns->resolv, rc );
104: }
105:
106: /**
107: * Compare DNS reply name against the query name from the original request
108: *
109: * @v dns DNS request
110: * @v reply DNS reply
111: * @v rname Reply name
112: * @ret zero Names match
113: * @ret non-zero Names do not match
114: */
115: static int dns_name_cmp ( struct dns_request *dns,
116: const struct dns_header *reply,
117: const char *rname ) {
118: const char *qname = dns->query.payload;
119: int i;
120:
121: while ( 1 ) {
122: /* Obtain next section of rname */
123: while ( ( *rname ) & 0xc0 ) {
124: rname = ( ( ( char * ) reply ) +
125: ( ntohs( *((uint16_t *)rname) ) & ~0xc000 ));
126: }
127: /* Check that lengths match */
128: if ( *rname != *qname )
129: return -1;
130: /* If length is zero, we have reached the end */
131: if ( ! *qname )
132: return 0;
133: /* Check that data matches */
134: for ( i = *qname + 1; i > 0 ; i-- ) {
135: if ( *(rname++) != *(qname++) )
136: return -1;
137: }
138: }
139: }
140:
141: /**
142: * Skip over a (possibly compressed) DNS name
143: *
144: * @v name DNS name
145: * @ret name Next DNS name
146: */
147: static const char * dns_skip_name ( const char *name ) {
148: while ( 1 ) {
149: if ( ! *name ) {
150: /* End of name */
151: return ( name + 1);
152: }
153: if ( *name & 0xc0 ) {
154: /* Start of a compressed name */
155: return ( name + 2 );
156: }
157: /* Uncompressed name portion */
158: name += *name + 1;
159: }
160: }
161:
162: /**
163: * Find an RR in a reply packet corresponding to our query
164: *
165: * @v dns DNS request
166: * @v reply DNS reply
167: * @ret rr DNS RR, or NULL if not found
168: */
169: static union dns_rr_info * dns_find_rr ( struct dns_request *dns,
170: const struct dns_header *reply ) {
171: int i, cmp;
172: const char *p = ( ( char * ) reply ) + sizeof ( struct dns_header );
173: union dns_rr_info *rr_info;
174:
175: /* Skip over the questions section */
176: for ( i = ntohs ( reply->qdcount ) ; i > 0 ; i-- ) {
177: p = dns_skip_name ( p ) + sizeof ( struct dns_query_info );
178: }
179:
180: /* Process the answers section */
181: for ( i = ntohs ( reply->ancount ) ; i > 0 ; i-- ) {
182: cmp = dns_name_cmp ( dns, reply, p );
183: p = dns_skip_name ( p );
184: rr_info = ( ( union dns_rr_info * ) p );
185: if ( cmp == 0 )
186: return rr_info;
187: p += ( sizeof ( rr_info->common ) +
188: ntohs ( rr_info->common.rdlength ) );
189: }
190:
191: return NULL;
192: }
193:
194: /**
195: * Append DHCP domain name if available and name is not fully qualified
196: *
197: * @v string Name as a NUL-terminated string
198: * @ret fqdn Fully-qualified domain name, malloc'd copy
199: *
200: * The caller must free fqdn which is allocated even if the name is already
201: * fully qualified.
202: */
203: static char * dns_qualify_name ( const char *string ) {
204: char *fqdn;
205:
206: /* Leave unchanged if already fully-qualified or no local domain */
207: if ( ( ! localdomain ) || ( strchr ( string, '.' ) != 0 ) )
208: return strdup ( string );
209:
210: /* Append local domain to name */
211: asprintf ( &fqdn, "%s.%s", string, localdomain );
212: return fqdn;
213: }
214:
215: /**
216: * Convert a standard NUL-terminated string to a DNS name
217: *
218: * @v string Name as a NUL-terminated string
219: * @v buf Buffer in which to place DNS name
220: * @ret next Byte following constructed DNS name
221: *
222: * DNS names consist of "<length>element" pairs.
223: */
224: static char * dns_make_name ( const char *string, char *buf ) {
225: char *length_byte = buf++;
226: char c;
227:
228: while ( ( c = *(string++) ) ) {
229: if ( c == '.' ) {
230: *length_byte = buf - length_byte - 1;
231: length_byte = buf;
232: }
233: *(buf++) = c;
234: }
235: *length_byte = buf - length_byte - 1;
236: *(buf++) = '\0';
237: return buf;
238: }
239:
240: /**
241: * Convert an uncompressed DNS name to a NUL-terminated string
242: *
243: * @v name DNS name
244: * @ret string NUL-terminated string
245: *
246: * Produce a printable version of a DNS name. Used only for debugging.
247: */
248: static inline char * dns_unmake_name ( char *name ) {
249: char *p;
250: unsigned int len;
251:
252: p = name;
253: while ( ( len = *p ) ) {
254: *(p++) = '.';
255: p += len;
256: }
257:
258: return name + 1;
259: }
260:
261: /**
262: * Decompress a DNS name
263: *
264: * @v reply DNS replay
265: * @v name DNS name
266: * @v buf Buffer into which to decompress DNS name
267: * @ret next Byte following decompressed DNS name
268: */
269: static char * dns_decompress_name ( const struct dns_header *reply,
270: const char *name, char *buf ) {
271: int i, len;
272:
273: do {
274: /* Obtain next section of name */
275: while ( ( *name ) & 0xc0 ) {
276: name = ( ( char * ) reply +
277: ( ntohs ( *((uint16_t *)name) ) & ~0xc000 ) );
278: }
279: /* Copy data */
280: len = *name;
281: for ( i = len + 1 ; i > 0 ; i-- ) {
282: *(buf++) = *(name++);
283: }
284: } while ( len );
285: return buf;
286: }
287:
288: /**
289: * Send next packet in DNS request
290: *
291: * @v dns DNS request
292: */
293: static int dns_send_packet ( struct dns_request *dns ) {
294: static unsigned int qid = 0;
295: size_t qlen;
296:
297: /* Increment query ID */
298: dns->query.dns.id = htons ( ++qid );
299:
300: DBGC ( dns, "DNS %p sending query ID %d\n", dns, qid );
301:
302: /* Start retransmission timer */
303: start_timer ( &dns->timer );
304:
305: /* Send the data */
306: qlen = ( ( ( void * ) dns->qinfo ) - ( ( void * ) &dns->query )
307: + sizeof ( dns->qinfo ) );
308: return xfer_deliver_raw ( &dns->socket, &dns->query, qlen );
309: }
310:
311: /**
312: * Handle DNS retransmission timer expiry
313: *
314: * @v timer Retry timer
315: * @v fail Failure indicator
316: */
317: static void dns_timer_expired ( struct retry_timer *timer, int fail ) {
318: struct dns_request *dns =
319: container_of ( timer, struct dns_request, timer );
320:
321: if ( fail ) {
322: dns_done ( dns, -ETIMEDOUT );
323: } else {
324: dns_send_packet ( dns );
325: }
326: }
327:
328: /**
329: * Receive new data
330: *
331: * @v dns DNS request
332: * @v iobuf I/O buffer
333: * @v meta Data transfer metadata
334: * @ret rc Return status code
335: */
336: static int dns_xfer_deliver ( struct dns_request *dns,
337: struct io_buffer *iobuf,
338: struct xfer_metadata *meta __unused ) {
339: const struct dns_header *reply = iobuf->data;
340: union dns_rr_info *rr_info;
341: struct sockaddr_in *sin;
342: unsigned int qtype = dns->qinfo->qtype;
343: int rc;
344:
345: /* Sanity check */
346: if ( iob_len ( iobuf ) < sizeof ( *reply ) ) {
347: DBGC ( dns, "DNS %p received underlength packet length %zd\n",
348: dns, iob_len ( iobuf ) );
349: rc = -EINVAL;
350: goto done;
351: }
352:
353: /* Check reply ID matches query ID */
354: if ( reply->id != dns->query.dns.id ) {
355: DBGC ( dns, "DNS %p received unexpected reply ID %d "
356: "(wanted %d)\n", dns, ntohs ( reply->id ),
357: ntohs ( dns->query.dns.id ) );
358: rc = -EINVAL;
359: goto done;
360: }
361:
362: DBGC ( dns, "DNS %p received reply ID %d\n", dns, ntohs ( reply->id ));
363:
364: /* Stop the retry timer. After this point, each code path
365: * must either restart the timer by calling dns_send_packet(),
366: * or mark the DNS operation as complete by calling
367: * dns_done()
368: */
369: stop_timer ( &dns->timer );
370:
371: /* Search through response for useful answers. Do this
372: * multiple times, to take advantage of useful nameservers
373: * which send us e.g. the CNAME *and* the A record for the
374: * pointed-to name.
375: */
376: while ( ( rr_info = dns_find_rr ( dns, reply ) ) ) {
377: switch ( rr_info->common.type ) {
378:
379: case htons ( DNS_TYPE_A ):
380:
381: /* Found the target A record */
382: DBGC ( dns, "DNS %p found address %s\n",
383: dns, inet_ntoa ( rr_info->a.in_addr ) );
384: sin = ( struct sockaddr_in * ) &dns->sa;
385: sin->sin_family = AF_INET;
386: sin->sin_addr = rr_info->a.in_addr;
387:
388: /* Return resolved address */
389: resolv_done ( &dns->resolv, &dns->sa );
390:
391: /* Mark operation as complete */
392: dns_done ( dns, 0 );
393: rc = 0;
394: goto done;
395:
396: case htons ( DNS_TYPE_CNAME ):
397:
398: /* Found a CNAME record; update query and recurse */
399: DBGC ( dns, "DNS %p found CNAME\n", dns );
400: dns->qinfo = ( void * ) dns_decompress_name ( reply,
401: rr_info->cname.cname,
402: dns->query.payload );
403: dns->qinfo->qtype = htons ( DNS_TYPE_A );
404: dns->qinfo->qclass = htons ( DNS_CLASS_IN );
405:
406: /* Terminate the operation if we recurse too far */
407: if ( ++dns->recursion > DNS_MAX_CNAME_RECURSION ) {
408: DBGC ( dns, "DNS %p recursion exceeded\n",
409: dns );
410: dns_done ( dns, -ELOOP );
411: rc = 0;
412: goto done;
413: }
414: break;
415:
416: default:
417: DBGC ( dns, "DNS %p got unknown record type %d\n",
418: dns, ntohs ( rr_info->common.type ) );
419: break;
420: }
421: }
422:
423: /* Determine what to do next based on the type of query we
424: * issued and the reponse we received
425: */
426: switch ( qtype ) {
427:
428: case htons ( DNS_TYPE_A ):
429: /* We asked for an A record and got nothing;
430: * try the CNAME.
431: */
432: DBGC ( dns, "DNS %p found no A record; trying CNAME\n", dns );
433: dns->qinfo->qtype = htons ( DNS_TYPE_CNAME );
434: dns_send_packet ( dns );
435: rc = 0;
436: goto done;
437:
438: case htons ( DNS_TYPE_CNAME ):
439: /* We asked for a CNAME record. If we got a response
440: * (i.e. if the next A query is already set up), then
441: * issue it, otherwise abort.
442: */
443: if ( dns->qinfo->qtype == htons ( DNS_TYPE_A ) ) {
444: dns_send_packet ( dns );
445: rc = 0;
446: goto done;
447: } else {
448: DBGC ( dns, "DNS %p found no CNAME record\n", dns );
449: dns_done ( dns, -ENXIO_NO_RECORD );
450: rc = 0;
451: goto done;
452: }
453:
454: default:
455: assert ( 0 );
456: dns_done ( dns, -EINVAL );
457: rc = -EINVAL;
458: goto done;
459: }
460:
461: done:
462: /* Free I/O buffer */
463: free_iob ( iobuf );
464: return rc;
465: }
466:
467: /**
468: * Receive new data
469: *
470: * @v dns DNS request
471: * @v rc Reason for close
472: */
473: static void dns_xfer_close ( struct dns_request *dns, int rc ) {
474:
475: if ( ! rc )
476: rc = -ECONNABORTED;
477:
478: dns_done ( dns, rc );
479: }
480:
481: /** DNS socket interface operations */
482: static struct interface_operation dns_socket_operations[] = {
483: INTF_OP ( xfer_deliver, struct dns_request *, dns_xfer_deliver ),
484: INTF_OP ( intf_close, struct dns_request *, dns_xfer_close ),
485: };
486:
487: /** DNS socket interface descriptor */
488: static struct interface_descriptor dns_socket_desc =
489: INTF_DESC ( struct dns_request, socket, dns_socket_operations );
490:
491: /** DNS resolver interface operations */
492: static struct interface_operation dns_resolv_op[] = {
493: INTF_OP ( intf_close, struct dns_request *, dns_done ),
494: };
495:
496: /** DNS resolver interface descriptor */
497: static struct interface_descriptor dns_resolv_desc =
498: INTF_DESC ( struct dns_request, resolv, dns_resolv_op );
499:
500: /**
501: * Resolve name using DNS
502: *
503: * @v resolv Name resolution interface
504: * @v name Name to resolve
505: * @v sa Socket address to fill in
506: * @ret rc Return status code
507: */
508: static int dns_resolv ( struct interface *resolv,
509: const char *name, struct sockaddr *sa ) {
510: struct dns_request *dns;
511: char *fqdn;
512: int rc;
513:
514: /* Fail immediately if no DNS servers */
515: if ( ! nameserver.st_family ) {
516: DBG ( "DNS not attempting to resolve \"%s\": "
517: "no DNS servers\n", name );
518: rc = -ENXIO_NO_NAMESERVER;
519: goto err_no_nameserver;
520: }
521:
522: /* Ensure fully-qualified domain name if DHCP option was given */
523: fqdn = dns_qualify_name ( name );
524: if ( ! fqdn ) {
525: rc = -ENOMEM;
526: goto err_qualify_name;
527: }
528:
529: /* Allocate DNS structure */
530: dns = zalloc ( sizeof ( *dns ) );
531: if ( ! dns ) {
532: rc = -ENOMEM;
533: goto err_alloc_dns;
534: }
535: ref_init ( &dns->refcnt, NULL );
536: intf_init ( &dns->resolv, &dns_resolv_desc, &dns->refcnt );
537: intf_init ( &dns->socket, &dns_socket_desc, &dns->refcnt );
538: timer_init ( &dns->timer, dns_timer_expired, &dns->refcnt );
539: memcpy ( &dns->sa, sa, sizeof ( dns->sa ) );
540:
541: /* Create query */
542: dns->query.dns.flags = htons ( DNS_FLAG_QUERY | DNS_FLAG_OPCODE_QUERY |
543: DNS_FLAG_RD );
544: dns->query.dns.qdcount = htons ( 1 );
545: dns->qinfo = ( void * ) dns_make_name ( fqdn, dns->query.payload );
546: dns->qinfo->qtype = htons ( DNS_TYPE_A );
547: dns->qinfo->qclass = htons ( DNS_CLASS_IN );
548:
549: /* Open UDP connection */
550: if ( ( rc = xfer_open_socket ( &dns->socket, SOCK_DGRAM,
551: ( struct sockaddr * ) &nameserver,
552: NULL ) ) != 0 ) {
553: DBGC ( dns, "DNS %p could not open socket: %s\n",
554: dns, strerror ( rc ) );
555: goto err_open_socket;
556: }
557:
558: /* Send first DNS packet */
559: dns_send_packet ( dns );
560:
561: /* Attach parent interface, mortalise self, and return */
562: intf_plug_plug ( &dns->resolv, resolv );
563: ref_put ( &dns->refcnt );
564: free ( fqdn );
565: return 0;
566:
567: err_open_socket:
568: err_alloc_dns:
569: ref_put ( &dns->refcnt );
570: err_qualify_name:
571: free ( fqdn );
572: err_no_nameserver:
573: return rc;
574: }
575:
576: /** DNS name resolver */
577: struct resolver dns_resolver __resolver ( RESOLV_NORMAL ) = {
578: .name = "DNS",
579: .resolv = dns_resolv,
580: };
581:
582: /******************************************************************************
583: *
584: * Settings
585: *
586: ******************************************************************************
587: */
588:
589: /** DNS server setting */
590: struct setting dns_setting __setting ( SETTING_IPv4_EXTRA ) = {
591: .name = "dns",
592: .description = "DNS server",
593: .tag = DHCP_DNS_SERVERS,
594: .type = &setting_type_ipv4,
595: };
596:
597: /** Domain name setting */
598: struct setting domain_setting __setting ( SETTING_IPv4_EXTRA ) = {
599: .name = "domain",
600: .description = "DNS domain",
601: .tag = DHCP_DOMAIN_NAME,
602: .type = &setting_type_string,
603: };
604:
605: /**
606: * Apply DNS settings
607: *
608: * @ret rc Return status code
609: */
610: static int apply_dns_settings ( void ) {
611: struct sockaddr_in *sin_nameserver =
612: ( struct sockaddr_in * ) &nameserver;
613: int len;
614:
615: /* Fetch DNS server address */
616: nameserver.st_family = 0;
617: if ( ( len = fetch_ipv4_setting ( NULL, &dns_setting,
618: &sin_nameserver->sin_addr ) ) >= 0 ){
619: nameserver.st_family = AF_INET;
620: DBG ( "DNS using nameserver %s\n",
621: inet_ntoa ( sin_nameserver->sin_addr ) );
622: }
623:
624: /* Get local domain DHCP option */
625: free ( localdomain );
626: if ( ( len = fetch_string_setting_copy ( NULL, &domain_setting,
627: &localdomain ) ) < 0 ) {
628: DBG ( "DNS could not fetch local domain: %s\n",
629: strerror ( len ) );
630: }
631: if ( localdomain )
632: DBG ( "DNS local domain %s\n", localdomain );
633:
634: return 0;
635: }
636:
637: /** DNS settings applicator */
638: struct settings_applicator dns_applicator __settings_applicator = {
639: .apply = apply_dns_settings,
640: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.