![[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 / SLOF / clients / net-snk / app / netlib|
Return to dns.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / app / netlib |
1.1 root 1: /******************************************************************************
2: * Copyright (c) 2004, 2008 IBM Corporation
3: * All rights reserved.
4: * This program and the accompanying materials
5: * are made available under the terms of the BSD License
6: * which accompanies this distribution, and is available at
7: * http://www.opensource.org/licenses/bsd-license.php
8: *
9: * Contributors:
10: * IBM Corporation - initial implementation
11: *****************************************************************************/
12:
13: /*>>>>>>>>>>>>>>>>>>>>> DEFINITIONS & DECLARATIONS <<<<<<<<<<<<<<<<<<<<<<*/
14:
15: #include <dns.h>
16: #include <stdio.h>
17: #include <string.h>
18: #include <time.h>
19: #include <sys/socket.h>
20:
21: #include <ethernet.h>
22: #include <ipv4.h>
23: #include <udp.h>
24:
25: #define DNS_FLAG_MSGTYPE 0xF800 /**< Message type mask (opcode) */
26: #define DNS_FLAG_SQUERY 0x0000 /**< Standard query type */
27: #define DNS_FLAG_SRESPONSE 0x8000 /**< Standard response type */
28: #define DNS_FLAG_RD 0x0100 /**< Recursion desired flag */
29: #define DNS_FLAG_RCODE 0x000F /**< Response code mask
30: (stores err.cond.) code */
31: #define DNS_RCODE_NERROR 0 /**< "No errors" code */
32:
33: #define DNS_QTYPE_A 1 /**< A 32-bit IP record type */
34: #define DNS_QTYPE_CNAME 5 /**< Canonical name record type */
35:
36: #define DNS_QCLASS_IN 1 /**< Query class for internet msgs */
37:
38: /** \struct dnshdr
39: * A header for DNS-messages (see RFC 1035, paragraph 4.1.1).
40: * <p>
41: * DNS-message consist of DNS-header and 4 optional sections,
42: * arranged in the following order:<ul>
43: * <li> DNS-header
44: * <li> question section
45: * <li> answer section
46: * <li> authority section
47: * <li> additional section
48: * </ul>
49: */
50: struct dnshdr {
51: uint16_t id; /**< an identifier used to match up replies */
52: uint16_t flags; /**< contains op_code, err_code, etc. */
53: uint16_t qdcount; /**< specifies the number of entries in the
54: question section */
55: uint16_t ancount; /**< specifies the number of entries in the
56: answer section */
57: uint16_t nscount; /**< specifies the number of entries in the
58: authority section */
59: uint16_t arcount; /**< specifies the number of entries in the
60: additional section */
61: };
62:
63:
64: /*>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROTOTYPES <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
65:
66: static void
67: dns_send_query(int8_t * domain_name);
68:
69: static void
70: fill_dnshdr(uint8_t * packet, int8_t * domain_name);
71:
72: static uint8_t *
73: dns_extract_name(uint8_t * dnsh, int8_t * head, int8_t * domain_name);
74:
75: static int8_t
76: urltohost(char * url, char * host_name);
77:
78: static int8_t
79: hosttodomain(char * host_name, char * domain_name);
80:
81: /*>>>>>>>>>>>>>>>>>>>>>>>>>>> LOCAL VARIABLES <<<<<<<<<<<<<<<<<<<<<<<<<<<*/
82:
83: static uint8_t ether_packet[ETH_MTU_SIZE];
84: static int32_t dns_server_ip = 0;
85: static int32_t dns_result_ip = 0;
86: static int8_t dns_error = 0; /**< Stores error code or 0 */
87: static int8_t dns_domain_name[0x100]; /**< Raw domain name */
88: static int8_t dns_domain_cname[0x100]; /**< Canonical domain name */
89:
90: /*>>>>>>>>>>>>>>>>>>>>>>>>>>> IMPLEMENTATION <<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
91:
92: /**
93: * DNS: Initialize the environment for DNS client.
94: * To perfrom DNS-queries use the function dns_get_ip.
95: *
96: * @param device_socket a socket number used to send and recieve packets
97: * @param server_ip DNS-server IPv4 address (e.g. 127.0.0.1)
98: * @return TRUE in case of successful initialization;
99: * FALSE in case of fault (e.g. can't obtain MAC).
100: * @see dns_get_ip
101: */
102: int8_t
103: dns_init(uint32_t _dns_server_ip) {
104: dns_server_ip = _dns_server_ip;
105: return 0;
106: }
107:
108: /**
109: * DNS: For given URL retrieves IPv4 from DNS-server.
110: * <p>
111: * URL can be given in one of the following form: <ul>
112: * <li> scheme with full path with (without) user and password
113: * <br>(e.g. "http://user:[email protected]/url-path");
114: * <li> host name with url-path
115: * <br>(e.g. "www.host.org/url-path");
116: * <li> nothing but host name
117: * <br>(e.g. "www.host.org");
118: * </ul>
119: *
120: * @param url the URL to be resolved
121: * @param domain_ip In case of SUCCESS stores extracted IP.
122: * In case of FAULT stores zeros (0.0.0.0).
123: * @return TRUE - IP successfuly retrieved;
124: * FALSE - error condition occurs.
125: */
126: int8_t
127: dns_get_ip(int8_t * url, uint32_t * domain_ip) {
128: /* this counter is used so that we abort after 30 DNS request */
129: int32_t i;
130: /* this buffer stores host name retrieved from url */
131: static int8_t host_name[0x100];
132:
133: (* domain_ip) = 0;
134:
135: // Retrieve host name from URL
136: if (!urltohost((char *) url, (char *) host_name)) {
137: printf("\nERROR:\t\t\tBad URL!\n");
138: return 0;
139: }
140:
141: // Reformat host name into a series of labels
142: if (!hosttodomain((char *) host_name, (char *) dns_domain_name)) {
143: printf("\nERROR:\t\t\tBad host name!\n");
144: return 0;
145: }
146:
147: // Check if DNS server is presented and accessable
148: if (dns_server_ip == 0) {
149: printf("\nERROR:\t\t\tCan't resolve domain name "
150: "(DNS server is not presented)!\n");
151: return 0;
152: }
153:
154: // Use DNS-server to obtain IP
155: dns_result_ip = 0;
156: dns_error = 0;
157: strcpy((char *) dns_domain_cname, "");
158:
159: for(i = 0; i < 30; ++i) {
160: // Use canonical name in case we obtained it
161: if (strlen((char *) dns_domain_cname))
162: dns_send_query(dns_domain_cname);
163: else
164: dns_send_query(dns_domain_name);
165:
166: // setting up a timer with a timeout of one seconds
167: set_timer(TICKS_SEC);
168: do {
169: receive_ether();
170: if (dns_error)
171: return 0; // FALSE - error
172: if (dns_result_ip != 0) {
173: (* domain_ip) = dns_result_ip;
174: return 1; // TRUE - success (domain IP retrieved)
175: }
176: } while (get_timer() > 0);
177: }
178:
179: printf("\nGiving up after %d DNS requests\n", i);
180: return 0; // FALSE - domain name wasn't retrieved
181: }
182:
183: /**
184: * DNS: Handles DNS-messages according to Receive-handle diagram.
185: * Sets dns_result_ip for given dns_domain_name (see dns_get_ip)
186: * or signals error condition occurs during DNS-resolving proccess
187: * by setting dns_error flag.
188: *
189: * @param packet DNS-packet to be handled
190: * @param packetsize length of the packet
191: * @return ZERO - packet handled successfully;
192: * NON ZERO - packet was not handled (e.g. bad format)
193: * @see dns_get_ip
194: * @see receive_ether
195: * @see dnshdr
196: */
197: int32_t
198: handle_dns(uint8_t * packet, int32_t packetsize) {
199: struct dnshdr * dnsh = (struct dnshdr *) packet;
200: uint8_t * resp_section = packet + sizeof(struct dnshdr);
201: /* This string stores domain name from DNS-packets */
202: static int8_t handle_domain_name[0x100];
203: int i;
204:
205: // verify ID - is it response for our query?
206: if (dnsh -> id != htons(0x1234))
207: return 0;
208:
209: // Is it DNS response?
210: if ((dnsh -> flags & htons(DNS_FLAG_MSGTYPE)) != htons(DNS_FLAG_SRESPONSE))
211: return 0;
212:
213: // Is error condition occurs? (check error field in incoming packet)
214: if ((dnsh -> flags & htons(DNS_FLAG_RCODE)) != DNS_RCODE_NERROR) {
215: dns_error = 1;
216: return 0;
217: }
218:
219: /* Pass all (qdcount) records in question section */
220:
221: for (i = 0; i < htons(dnsh -> qdcount); i++) {
222: // pass QNAME
223: resp_section = dns_extract_name((uint8_t *) dnsh, (int8_t *) resp_section,
224: handle_domain_name);
225: if (resp_section == NULL) {
226: return -1; // incorrect domain name (bad packet)
227: }
228: // pass QTYPE & QCLASS
229: resp_section += 4;
230: }
231:
232: /* Handle all (ancount) records in answer section */
233:
234: for (i = 0; i < htons(dnsh -> ancount); i++) {
235: // retrieve domain name from the packet
236: resp_section = dns_extract_name((uint8_t *) dnsh, (int8_t *) resp_section,
237: handle_domain_name);
238:
239: if (resp_section == NULL) {
240: return -1; // incorrect domain name (bad packet)
241: }
242:
243: // Check the class of the query (should be IN for Internet)
244: if (* (uint16_t *) (resp_section + 2) == htons(DNS_QCLASS_IN)) {
245: // check if retrieved name fit raw or canonical domain name
246: if (!strcmp((char *) handle_domain_name, (char *) dns_domain_name) ||
247: !strcmp((char *) handle_domain_name, (char *) dns_domain_cname)) {
248: switch (htons(* (uint16_t *) resp_section)) {
249:
250: case DNS_QTYPE_A :
251: // rdata contains IP
252: dns_result_ip = htonl(* (uint32_t *) (resp_section + 10));
253: return 0; // IP successfully obtained
254:
255: case DNS_QTYPE_CNAME :
256: // rdata contains canonical name, store it for further requests
257: if (dns_extract_name((uint8_t *) dnsh, (int8_t *) resp_section + 10,
258: dns_domain_cname) == NULL) {
259: // incorrect domain name (bad packet)
260: return -1;
261: }
262: break;
263: }
264: }
265: // continue with next record in answer section
266: resp_section += htons(* (uint16_t *) (resp_section + 8)) + 10;
267: }
268: }
269: return 0; // Packet succesfuly handled but IP wasn't obtained
270: }
271:
272: /**
273: * DNS: Sends a standard DNS-query (read request package) to a DNS-server.
274: * DNS-server respones with host IP or signals some error condition.
275: * Responses from the server are handled by handle_dns function.
276: *
277: * @param domain_name the domain name given as series of labels preceded
278: * with length(label) and terminated with 0
279: * <br>(e.g. "\3,w,w,w,\4,h,o,s,t,\3,o,r,g,\0")
280: * @see handle_dns
281: */
282: static void
283: dns_send_query(int8_t * domain_name) {
284: int qry_len = strlen((char *) domain_name) + 5;
285:
286: uint32_t packetsize = sizeof(struct iphdr) +
287: sizeof(struct udphdr) + sizeof(struct dnshdr) +
288: qry_len;
289:
290: memset(ether_packet, 0, packetsize);
291: fill_dnshdr(ðer_packet[
292: sizeof(struct iphdr) + sizeof(struct udphdr)],
293: domain_name);
294: fill_udphdr(ðer_packet[
295: sizeof(struct iphdr)], sizeof(struct dnshdr) +
296: sizeof(struct udphdr) + qry_len,
297: UDPPORT_DNSC, UDPPORT_DNSS);
298: fill_iphdr(ether_packet,
299: sizeof(struct dnshdr) + sizeof(struct udphdr) +
300: sizeof(struct iphdr) + qry_len,
301: IPTYPE_UDP, 0, dns_server_ip);
302:
303: send_ipv4(ether_packet, packetsize);
304: }
305:
306: /**
307: * DNS: Creates standard DNS-query package. Places DNS-header
308: * and question section in a packet and fills it with
309: * corresponding information.
310: * <p>
311: * Use this function with similar functions for other network layers
312: * (fill_udphdr, fill_iphdr, fill_ethhdr).
313: *
314: * @param packet Points to the place where ARP-header must be placed.
315: * @param domain_name the domain name given as series of labels preceded
316: * with length(label) and terminated with 0
317: * <br>(e.g. "\3,w,w,w,\4,h,o,s,t,\3,o,r,g,\0")
318: * @see fill_udphdr
319: * @see fill_iphdr
320: * @see fill_ethhdr
321: */
322: static void
323: fill_dnshdr(uint8_t * packet, int8_t * domain_name) {
324: struct dnshdr * dnsh = (struct dnshdr *) packet;
325: uint8_t * qry_section = packet + sizeof(struct dnshdr);
326:
327: dnsh -> id = htons(0x1234);
328: dnsh -> flags = htons(DNS_FLAG_SQUERY) | htons(DNS_FLAG_RD);
329: dnsh -> qdcount = htons(1);
330:
331: strcpy((char *) qry_section, (char *) domain_name);
332: qry_section += strlen((char *) domain_name) + 1;
333:
334: // fill QTYPE (ask for IP)
335: * (uint16_t *) qry_section = htons(DNS_QTYPE_A);
336: qry_section += 2;
337: // fill QCLASS (IN is a standard class for Internet)
338: * (uint16_t *) qry_section = htons(DNS_QCLASS_IN);
339: }
340:
341: /**
342: * DNS: Extracts domain name from the question or answer section of
343: * the DNS-message. This function is need to support message
344: * compression requirement (see RFC 1035, paragraph 4.1.4).
345: *
346: * @param dnsh Points at the DNS-header.
347: * @param head Points at the beginning of the domain_name
348: * which has to be extracted.
349: * @param domain_name In case of SUCCESS this string stores extracted name.
350: * In case of FAULT this string is empty.
351: * @return NULL in case of FAULT (domain name > 255 octets);
352: * otherwise pointer to the data following the name.
353: * @see dnshdr
354: */
355: static uint8_t *
356: dns_extract_name(uint8_t * dnsh, int8_t * head, int8_t * domain_name) {
357: int8_t * tail = domain_name;
358: int8_t * ptr = head;
359: int8_t * next_section = NULL;
360:
361: while (1) {
362: if ((ptr[0] & 0xC0) == 0xC0) {
363: // message compressed (reference is used)
364: next_section = ptr + 2;
365: ptr = (int8_t *) dnsh + (htons(* (uint16_t *) ptr) & 0x3FFF);
366: continue;
367: }
368: if (ptr[0] == 0) {
369: // message termination
370: tail[0] = 0;
371: ptr += 1;
372: break;
373: }
374: // maximum length for domain name is 255 octets w/o termination sym
375: if (tail - domain_name + ptr[0] + 1 > 255) {
376: strcpy((char *) domain_name, "");
377: return NULL;
378: }
379: memcpy(tail, ptr, ptr[0] + 1);
380: tail += ptr[0] + 1;
381: ptr += ptr[0] + 1;
382: }
383:
384: if (next_section == NULL)
385: next_section = ptr;
386:
387: return (uint8_t *) next_section;
388: }
389:
390: /**
391: * DNS: Parses URL and returns host name.
392: * Input string can be given as: <ul>
393: * <li> scheme with full path with (without) user and password
394: * <br>(e.g. "http://user:[email protected]/url-path");
395: * <li> host name with url-path
396: * <br>(e.g. "www.host.org/url-path");
397: * <li> nothing but host name
398: * <br>(e.g. "www.host.org");
399: * </ul>
400: *
401: * @param url string that stores incoming URL
402: * @param host_name In case of SUCCESS this string stores the host name,
403: * In case of FAULT this string is empty.
404: * @return TRUE - host name retrieved,
405: * FALSE - host name > 255 octets or empty.
406: */
407: static int8_t
408: urltohost(char * url, char * host_name) {
409: uint16_t length1;
410: uint16_t length2;
411:
412: strcpy(host_name, "");
413:
414: if (strstr(url, "://") != NULL)
415: url = strstr(url, "//") + 2; // URL
416:
417: if (strstr(url, "@") != NULL) // truncate user & password
418: url = strstr(url, "@") + 1;
419:
420: if (strstr(url, "/") != NULL) // truncate url path
421: length1 = strstr(url, "/") - url;
422: else
423: length1 = strlen(url);
424:
425: if (strstr(url, ":") != NULL) // truncate port path
426: length2 = strstr(url, ":") - url;
427: else
428: length2 = strlen(url);
429:
430: if(length1 > length2)
431: length1 = length2;
432:
433: if (length1 == 0)
434: return 0; // string is empty
435: if(length1 >= 256)
436: return 0; // host name is too big
437:
438: strncpy(host_name, url, length1);
439: host_name[length1] = 0;
440:
441: return 1; // Host name is retrieved
442: }
443:
444: /**
445: * DNS: Transforms host name string into a series of labels
446: * each of them preceded with length(label). 0 is a terminator.
447: * "www.domain.dom" -> "\3,w,w,w,\6,d,o,m,a,i,n,\3,c,o,m,\0"
448: * <p>
449: * This format is used in DNS-messages.
450: *
451: * @param host_name incoming string with the host name
452: * @param domain_name resulting string with series of labels
453: * or empty string in case of FAULT
454: * @return TRUE - host name transformed,
455: * FALSE - host name > 255 octets or label > 63 octets.
456: */
457: static int8_t
458: hosttodomain(char * host_name, char * domain_name) {
459: char * domain_iter = domain_name;
460: char * host_iter = host_name;
461:
462: strcpy(domain_name, "");
463:
464: if(strlen(host_name) > 255)
465: return 0; // invalid host name (refer to RFC 1035)
466:
467: for(; 1; ++host_iter) {
468: if(*host_iter != '.' && *host_iter != 0)
469: continue;
470: *domain_iter = host_iter - host_name;
471: if (*domain_iter > 63) {
472: strcpy(domain_name, "");
473: return 0; // invalid host name (refer to RFC 1035)
474: }
475: ++domain_iter;
476: strncpy(domain_iter, host_name, host_iter - host_name);
477: domain_iter += (host_iter - host_name);
478: if(*host_iter == 0) {
479: *domain_iter = 0;
480: break;
481: }
482: host_name = host_iter + 1;
483: }
484: return 1; // ok
485: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.