![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dhcp.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 dhcp.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:
14: /*>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALGORITHMS <<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
15:
16: /** \file dhcp.c <pre>
17: * **************** State-transition diagram for DHCP client *************
18: *
19: * +---------+ Note: DHCP-server msg / DHCP-client msg
20: * | INIT |
21: * +---------+
22: * |
23: * | - / Discover
24: * V
25: * +---------+
26: * | SELECT | Timeout
27: * +---------+ |
28: * | |
29: * | Offer / Request |
30: * | |
31: * V V
32: * +---------+ NACK / - ***********
33: * | REQUEST | ----------------> * FAULT *
34: * +---------+ ***********
35: * |
36: * | ACK / - ***********
37: * +----------------------> * SUCCESS *
38: * ***********
39: *
40: * ************************************************************************
41: * </pre> */
42:
43:
44: /*>>>>>>>>>>>>>>>>>>>>> DEFINITIONS & DECLARATIONS <<<<<<<<<<<<<<<<<<<<<<*/
45:
46: #include <dhcp.h>
47: #include <ethernet.h>
48: #include <ipv4.h>
49: #include <udp.h>
50: #include <dns.h>
51:
52: #include <stdio.h>
53: #include <string.h>
54: #include <time.h>
55: #include <sys/socket.h>
56: #include <ctype.h>
57: #include <stdlib.h>
58:
59: /* DHCP Message Types */
60: #define DHCPDISCOVER 1
61: #define DHCPOFFER 2
62: #define DHCPREQUEST 3
63: #define DHCPDECLINE 4
64: #define DHCPACK 5
65: #define DHCPNACK 6
66: #define DHCPRELEASE 7
67: #define DHCPINFORM 8
68:
69: /* DHCP Option Codes */
70: #define DHCP_MASK 1
71: #define DHCP_ROUTER 3
72: #define DHCP_DNS 6
73: #define DHCP_REQUESTED_IP 50
74: #define DHCP_OVERLOAD 52
75: #define DHCP_MSG_TYPE 53
76: #define DHCP_SERVER_ID 54
77: #define DHCP_REQUEST_LIST 55
78: #define DHCP_TFTP_SERVER 66
79: #define DHCP_BOOTFILE 67
80: #define DHCP_ENDOPT 0xFF
81: #define DHCP_PADOPT 0x00
82:
83: /* "file/sname" overload option values */
84: #define DHCP_OVERLOAD_FILE 1
85: #define DHCP_OVERLOAD_SNAME 2
86: #define DHCP_OVERLOAD_BOTH 3
87:
88: /* DHCP states codes */
89: #define DHCP_STATE_SELECT 1
90: #define DHCP_STATE_REQUEST 2
91: #define DHCP_STATE_SUCCESS 3
92: #define DHCP_STATE_FAULT 4
93:
94: static uint8_t dhcp_magic[] = {0x63, 0x82, 0x53, 0x63};
95: /**< DHCP_magic is a cookie, that identifies DHCP options (see RFC 2132) */
96:
97: /** \struct dhcp_options_t
98: * This structure is used to fill options in DHCP-msg during transmitting
99: * or to retrieve options from DHCP-msg during receiving.
100: * <p>
101: * If flag[i] == TRUE then field for i-th option retains valid value and
102: * information from this field may retrived (in case of receiving) or will
103: * be transmitted (in case of transmitting).
104: *
105: */
106: typedef struct {
107: uint8_t flag[256]; /**< Show if corresponding opt. is valid */
108: uint8_t request_list[256]; /**< o.55 If i-th member is TRUE, then i-th
109: option will be requested from server */
110: uint32_t server_ID; /**< o.54 Identifies DHCP-server */
111: uint32_t requested_IP; /**< o.50 Must be filled in DHCP-Request */
112: uint32_t dns_IP; /**< o. 6 DNS IP */
113: uint32_t router_IP; /**< o. 3 Router IP */
114: uint32_t subnet_mask; /**< o. 1 Subnet mask */
115: uint8_t msg_type; /**< o.53 DHCP-message type */
116: uint8_t overload; /**< o.52 Overload sname/file fields */
117: int8_t tftp_server[256]; /**< o.66 TFTP server name */
118: int8_t bootfile[256]; /**< o.67 Boot file name */
119: } dhcp_options_t;
120:
121: /** Stores state of DHCP-client (refer to State-transition diagram) */
122: static uint8_t dhcp_state;
123:
124:
125: /*>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROTOTYPES <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
126:
127: static int32_t
128: dhcp_attempt(void);
129:
130: static int32_t
131: dhcp_encode_options(uint8_t * opt_field, dhcp_options_t * opt_struct);
132:
133: static int32_t
134: dhcp_decode_options(uint8_t opt_field[], uint32_t opt_len,
135: dhcp_options_t * opt_struct);
136:
137: static int8_t
138: dhcp_merge_options(uint8_t dst_options[], uint32_t * dst_len,
139: uint8_t src_options[], uint32_t src_len);
140:
141: static int8_t
142: dhcp_find_option(uint8_t options[], uint32_t len,
143: uint8_t op_code, uint32_t * op_offset);
144:
145: static void
146: dhcp_append_option(uint8_t dst_options[], uint32_t * dst_len,
147: uint8_t * new_option);
148:
149: static void
150: dhcp_combine_option(uint8_t dst_options[], uint32_t * dst_len,
151: uint32_t dst_offset, uint8_t * new_option);
152:
153: static void
154: dhcp_send_discover(void);
155:
156: static void
157: dhcp_send_request(void);
158:
159: static uint8_t
160: strtoip(int8_t * str, uint32_t * ip);
161:
162:
163: /*>>>>>>>>>>>>>>>>>>>>>>>>>>>> LOCAL VARIABLES <<<<<<<<<<<<<<<<<<<<<<<<<<*/
164:
165: static uint8_t ether_packet[ETH_MTU_SIZE];
166: static uint32_t dhcp_own_ip = 0;
167: static uint32_t dhcp_server_ip = 0;
168: static uint32_t dhcp_siaddr_ip = 0;
169: static int8_t dhcp_filename[256];
170: static int8_t dhcp_tftp_name[256];
171:
172: static char * response_buffer;
173:
174: /*>>>>>>>>>>>>>>>>>>>>>>>>>>>> IMPLEMENTATION <<<<<<<<<<<<<<<<<<<<<<<<<<<*/
175:
176: /**
177: * DHCP: Obtains IP and configuration info from DHCP server
178: * (makes several attempts).
179: *
180: * @param boot_device a socket number used to send and recieve packets
181: * @param fn_ip contains the following configuration information:
182: * client MAC, client IP, TFTP-server MAC,
183: * TFTP-server IP, Boot file name
184: * @return ZERO - IP and configuration info obtained;
185: * NON ZERO - error condition occurs.
186: */
187: int32_t
188: dhcp(char *ret_buffer, filename_ip_t * fn_ip, unsigned int retries) {
189: int i = (int) retries+1;
190:
191: uint32_t dhcp_tftp_ip = 0;
192: strcpy((char *) dhcp_filename, "");
193: strcpy((char *) dhcp_tftp_name, "");
194:
195: response_buffer = ret_buffer;
196:
197: printf(" ");
198:
199: do {
200: printf("\b\b\b%03d", i-1);
201: if (getchar() == 27) {
202: printf("\nAborted\n");
203: return -1;
204: }
205: if (!--i) {
206: printf("\nGiving up after %d DHCP requests\n", retries);
207: return -1;
208: }
209: } while (!dhcp_attempt());
210: printf("\b\b\b\b");
211:
212: if (fn_ip->own_ip) {
213: dhcp_own_ip = fn_ip->own_ip;
214: }
215: if (fn_ip->server_ip) {
216: dhcp_siaddr_ip = fn_ip->server_ip;
217: }
218: if(fn_ip->filename[0] != 0) {
219: strcpy((char *) dhcp_filename, (char *) fn_ip->filename);
220: }
221:
222: // TFTP SERVER
223: if (!strlen((char *) dhcp_tftp_name)) {
224: if (!dhcp_siaddr_ip) {
225: // ERROR: TFTP name is not presented
226: return -3;
227: }
228:
229: // take TFTP-ip from siaddr field
230: dhcp_tftp_ip = dhcp_siaddr_ip;
231: }
232: else {
233: // TFTP server defined by its name
234: if (!strtoip(dhcp_tftp_name, &(dhcp_tftp_ip))) {
235: if (!dns_get_ip(dhcp_tftp_name, &(dhcp_tftp_ip))) {
236: // DNS error - can't obtain TFTP-server name
237: // Use TFTP-ip from siaddr field, if presented
238: if (dhcp_siaddr_ip) {
239: dhcp_tftp_ip = dhcp_siaddr_ip;
240: }
241: else {
242: // ERROR: Can't obtain TFTP server IP
243: return -4;
244: }
245: }
246: }
247: }
248:
249: // Store configuration info into filename_ip strucutre
250: fn_ip -> own_ip = dhcp_own_ip;
251: fn_ip -> server_ip = dhcp_tftp_ip;
252: strcpy((char *) fn_ip -> filename, (char *) dhcp_filename);
253:
254: return 0;
255: }
256:
257: /**
258: * DHCP: Tries o obtain DHCP parameters, refer to state-transition diagram
259: */
260: static int32_t
261: dhcp_attempt(void) {
262: int sec;
263:
264: // Send DISCOVER message and switch DHCP-client to SELECT state
265: dhcp_send_discover();
266:
267: dhcp_state = DHCP_STATE_SELECT;
268:
269: // setting up a timer with a timeout of two seconds
270: for (sec = 0; sec < 2; sec++) {
271: set_timer(TICKS_SEC);
272: do {
273: receive_ether();
274:
275: // Wait until client will switch to Final state or Timeout occurs
276: switch (dhcp_state) {
277: case DHCP_STATE_SUCCESS :
278: return 1;
279: case DHCP_STATE_FAULT :
280: return 0;
281: }
282: } while (get_timer() > 0);
283: }
284:
285: // timeout
286: return 0;
287: }
288:
289: /**
290: * DHCP: Supplements DHCP-message with options stored in structure.
291: * For more information about option coding see dhcp_options_t.
292: *
293: * @param opt_field Points to the "vend" field of DHCP-message
294: * (destination)
295: * @param opt_struct this structure stores info about the options wich
296: * will be added to DHCP-message (source)
297: * @return TRUE - options packed;
298: * FALSE - error condition occurs.
299: * @see dhcp_options_t
300: */
301: static int32_t
302: dhcp_encode_options(uint8_t * opt_field, dhcp_options_t * opt_struct) {
303: uint8_t * options = opt_field;
304: uint16_t i, sum; // used to define is any options set
305:
306: // magic
307: memcpy(options, dhcp_magic, 4);
308: options += 4;
309:
310: // fill message type
311: switch (opt_struct -> msg_type) {
312: case DHCPDISCOVER :
313: case DHCPREQUEST :
314: case DHCPDECLINE :
315: case DHCPINFORM :
316: case DHCPRELEASE :
317: options[0] = DHCP_MSG_TYPE;
318: options[1] = 1;
319: options[2] = opt_struct -> msg_type;
320: options += 3;
321: break;
322: default :
323: return 0; // Unsupported DHCP-message
324: }
325:
326: if (opt_struct -> overload) {
327: options[0] = DHCP_OVERLOAD;
328: options[1] = 0x01;
329: options[2] = opt_struct -> overload;
330: options +=3;
331: }
332:
333: if (opt_struct -> flag[DHCP_REQUESTED_IP]) {
334: options[0] = DHCP_REQUESTED_IP;
335: options[1] = 0x04;
336: * (uint32_t *) (options + 2) = htonl (opt_struct -> requested_IP);
337: options +=6;
338: }
339:
340: if (opt_struct -> flag[DHCP_SERVER_ID]) {
341: options[0] = DHCP_SERVER_ID;
342: options[1] = 0x04;
343: * (uint32_t *) (options + 2) = htonl (opt_struct -> server_ID);
344: options +=6;
345: }
346:
347: sum = 0;
348: for (i = 0; i < 256; i++)
349: sum += opt_struct -> request_list[i];
350:
351: if (sum) {
352: options[0] = DHCP_REQUEST_LIST;
353: options[1] = sum;
354: options += 2;
355: for (i = 0; i < 256; i++) {
356: if (opt_struct -> request_list[i]) {
357: options[0] = i; options++;
358: }
359: }
360: }
361:
362: if (opt_struct -> flag[DHCP_TFTP_SERVER]) {
363: options[0] = DHCP_TFTP_SERVER;
364: options[1] = strlen((char *) opt_struct -> tftp_server) + 1;
365: memcpy(options + 2, opt_struct -> tftp_server, options[1]);
366: options += options[1] + 2;
367: }
368:
369: if (opt_struct -> flag[DHCP_BOOTFILE]) {
370: options[0] = DHCP_BOOTFILE;
371: options[1] = strlen((char *) opt_struct -> bootfile) + 1;
372: memcpy(options + 2, opt_struct -> bootfile, options[1]);
373: options += options[1] + 2;
374: }
375:
376: // end options
377: options[0] = 0xFF;
378: options++;
379:
380: return 1;
381: }
382:
383: /**
384: * DHCP: Extracts encoded options from DHCP-message into the structure.
385: * For more information about option coding see dhcp_options_t.
386: *
387: * @param opt_field Points to the "options" field of DHCP-message
388: * (source).
389: * @param opt_len Length of "options" field.
390: * @param opt_struct this structure stores info about the options wich
391: * was extracted from DHCP-message (destination).
392: * @return TRUE - options extracted;
393: * FALSE - error condition occurs.
394: * @see dhcp_options_t
395: */
396: static int32_t
397: dhcp_decode_options(uint8_t opt_field[], uint32_t opt_len,
398: dhcp_options_t * opt_struct) {
399: int32_t offset = 0;
400:
401: memset(opt_struct, 0, sizeof(dhcp_options_t));
402:
403: // magic
404: if (memcmp(opt_field, dhcp_magic, 4)) {
405: return 0;
406: }
407:
408: offset += 4;
409: while (offset < opt_len) {
410: opt_struct -> flag[opt_field[offset]] = 1;
411: switch(opt_field[offset]) {
412: case DHCP_OVERLOAD :
413: opt_struct -> overload = opt_field[offset + 2];
414: offset += 2 + opt_field[offset + 1];
415: break;
416:
417: case DHCP_REQUESTED_IP :
418: opt_struct -> requested_IP = htonl(* (uint32_t *) (opt_field + offset + 2));
419: offset += 2 + opt_field[offset + 1];
420: break;
421:
422: case DHCP_MASK :
423: opt_struct -> flag[DHCP_MASK] = 1;
424: opt_struct -> subnet_mask = htonl(* (uint32_t *) (opt_field + offset + 2));
425: offset += 2 + opt_field[offset + 1];
426: break;
427:
428: case DHCP_DNS :
429: opt_struct -> flag[DHCP_DNS] = 1;
430: opt_struct -> dns_IP = htonl(* (uint32_t *) (opt_field + offset + 2));
431: offset += 2 + opt_field[offset + 1];
432: break;
433:
434: case DHCP_ROUTER :
435: opt_struct -> flag[DHCP_ROUTER] = 1;
436: opt_struct -> router_IP = htonl(* (uint32_t *) (opt_field + offset + 2));
437: offset += 2 + opt_field[offset + 1];
438: break;
439:
440: case DHCP_MSG_TYPE :
441: if ((opt_field[offset + 2] > 0) && (opt_field[offset + 2] < 9))
442: opt_struct -> msg_type = opt_field[offset + 2];
443: else
444: return 0;
445: offset += 2 + opt_field[offset + 1];
446: break;
447:
448: case DHCP_SERVER_ID :
449: opt_struct -> server_ID = htonl(* (uint32_t *) (opt_field + offset + 2));
450: offset += 2 + opt_field[offset + 1];
451: break;
452:
453: case DHCP_TFTP_SERVER :
454: memcpy(opt_struct -> tftp_server, opt_field + offset + 2, opt_field[offset + 1]);
455: (opt_struct -> tftp_server)[opt_field[offset + 1]] = 0;
456: offset += 2 + opt_field[offset + 1];
457: break;
458:
459: case DHCP_BOOTFILE :
460: memcpy(opt_struct -> bootfile, opt_field + offset + 2, opt_field[offset + 1]);
461: (opt_struct -> bootfile)[opt_field[offset + 1]] = 0;
462: offset += 2 + opt_field[offset + 1];
463: break;
464:
465: case DHCP_PADOPT :
466: offset++;
467: break;
468:
469: case DHCP_ENDOPT : // End of options
470: return 1;
471:
472: default :
473: offset += 2 + opt_field[offset + 1]; // Unsupported opt. - do nothing
474: }
475: }
476: if (offset == opt_len)
477: return 1; // options finished without 0xFF
478:
479: return 0;
480: }
481:
482: /**
483: * DHCP: Appends information from source "options" into dest "options".
484: * This function is used to support "file/sname" overloading.
485: *
486: * @param dst_options destanation "options" field
487: * @param dst_len size of dst_options (modified by this function)
488: * @param src_options source "options" field
489: * @param src_len size of src_options
490: * @return TRUE - options merged;
491: * FALSE - error condition occurs.
492: */
493: static int8_t dhcp_merge_options(uint8_t dst_options[], uint32_t * dst_len,
494: uint8_t src_options[], uint32_t src_len) {
495: int32_t dst_offset, src_offset = 0;
496:
497: // remove ENDOPT if presented
498: if (dhcp_find_option(dst_options, * dst_len, DHCP_ENDOPT, (uint32_t *) &dst_offset))
499: * dst_len = dst_offset;
500:
501: while (src_offset < src_len) {
502: switch(src_options[src_offset]) {
503: case DHCP_PADOPT:
504: src_offset++;
505: break;
506: case DHCP_ENDOPT:
507: return 1;
508: default:
509: if (dhcp_find_option(dst_options, * dst_len,
510: src_options[src_offset],
511: (uint32_t *) &dst_offset)) {
512: dhcp_combine_option(dst_options, dst_len,
513: dst_offset,
514: (uint8_t *) src_options +
515: src_offset);
516: }
517: else {
518: dhcp_append_option(dst_options, dst_len, src_options + src_offset);
519: }
520: src_offset += 2 + src_options[src_offset + 1];
521: }
522: }
523:
524: if (src_offset == src_len)
525: return 1;
526: return 0;
527: }
528:
529: /**
530: * DHCP: Finds given occurence of the option with the given code (op_code)
531: * in "options" field of DHCP-message.
532: *
533: * @param options "options" field of DHCP-message
534: * @param len length of the "options" field
535: * @param op_code code of the option to find
536: * @param op_offset SUCCESS - offset to an option occurence;
537: * FAULT - offset is set to zero.
538: * @return TRUE - option was find;
539: * FALSE - option wasn't find.
540: */
541: static int8_t dhcp_find_option(uint8_t options[], uint32_t len,
542: uint8_t op_code, uint32_t * op_offset) {
543: uint32_t srch_offset = 0;
544: * op_offset = 0;
545:
546: while (srch_offset < len) {
547: if (options[srch_offset] == op_code) {
548: * op_offset = srch_offset;
549: return 1;
550: }
551: if (options[srch_offset] == DHCP_ENDOPT)
552: return 0;
553:
554: if (options[srch_offset] == DHCP_PADOPT)
555: srch_offset++;
556: else
557: srch_offset += 2 + options[srch_offset + 1];
558: }
559: return 0;
560: }
561:
562: /**
563: * DHCP: Appends new option from one list (src) into the tail
564: * of another option list (dst)
565: *
566: * @param dst_options "options" field of DHCP-message
567: * @param dst_len length of the "options" field (modified)
568: * @param new_option points to an option in another list (src)
569: */
570: static void
571: dhcp_append_option(uint8_t dst_options[], uint32_t * dst_len,
572: uint8_t * new_option) {
573: memcpy(dst_options + ( * dst_len), new_option, 2 + (* (new_option + 1)));
574: * dst_len += 2 + *(new_option + 1);
575: }
576:
577: /**
578: * DHCP: This function is used when options with the same code are
579: * presented in both merged lists. In this case information
580: * about the option from one list (src) is combined (complemented)
581: * with information about the option in another list (dst).
582: *
583: * @param dst_options "options" field of DHCP-message
584: * @param dst_len length of the "options" field (modified)
585: * @param dst_offset offset of the option from beggining of the list
586: * @param new_option points to an option in another list (src)
587: */
588: static void
589: dhcp_combine_option(uint8_t dst_options[], uint32_t * dst_len,
590: uint32_t dst_offset, uint8_t * new_option) {
591:
592: uint8_t tmp_buffer[1024]; // use to provide safe memcpy
593: uint32_t tail_len;
594:
595: // move all subsequent options (allocate size for additional info)
596: tail_len = (* dst_len) - dst_offset - 2 - dst_options[dst_offset + 1];
597:
598: memcpy(tmp_buffer, dst_options + (* dst_len) - tail_len, tail_len);
599: memcpy(dst_options + (* dst_len) - tail_len + (* (new_option + 1)),
600: tmp_buffer, tail_len);
601:
602: // add new_content to option
603: memcpy(dst_options + (* dst_len) - tail_len, new_option + 2,
604: * (new_option + 1));
605: dst_options[dst_offset + 1] += * (new_option + 1);
606:
607: // correct dst_len
608: * dst_len += * (new_option + 1);
609: }
610:
611: /**
612: * DHCP: Sends DHCP-Discover message. Looks for DHCP servers.
613: */
614: static void
615: dhcp_send_discover(void) {
616: uint32_t packetsize = sizeof(struct iphdr) +
617: sizeof(struct udphdr) + sizeof(struct btphdr);
618: struct btphdr *btph;
619: dhcp_options_t opt;
620:
621: memset(ether_packet, 0, packetsize);
622:
623: btph = (struct btphdr *) (ðer_packet[
624: sizeof(struct iphdr) + sizeof(struct udphdr)]);
625:
626: btph -> op = 1;
627: btph -> htype = 1;
628: btph -> hlen = 6;
629: memcpy(btph -> chaddr, get_mac_address(), 6);
630:
631: memset(&opt, 0, sizeof(dhcp_options_t));
632:
633: opt.msg_type = DHCPDISCOVER;
634:
635: opt.request_list[DHCP_MASK] = 1;
636: opt.request_list[DHCP_DNS] = 1;
637: opt.request_list[DHCP_ROUTER] = 1;
638: opt.request_list[DHCP_TFTP_SERVER] = 1;
639: opt.request_list[DHCP_BOOTFILE] = 1;
640:
641: dhcp_encode_options(btph -> vend, &opt);
642:
643: fill_udphdr(ðer_packet[sizeof(struct iphdr)],
644: sizeof(struct btphdr) + sizeof(struct udphdr),
645: UDPPORT_BOOTPC, UDPPORT_BOOTPS);
646: fill_iphdr(ether_packet, sizeof(struct btphdr) +
647: sizeof(struct udphdr) + sizeof(struct iphdr),
648: IPTYPE_UDP, dhcp_own_ip, 0xFFFFFFFF);
649:
650: send_ipv4(ether_packet, packetsize);
651: }
652:
653: /**
654: * DHCP: Sends DHCP-Request message. Asks for acknowledgment to occupy IP.
655: */
656: static void
657: dhcp_send_request(void) {
658: uint32_t packetsize = sizeof(struct iphdr) +
659: sizeof(struct udphdr) + sizeof(struct btphdr);
660: struct btphdr *btph;
661: dhcp_options_t opt;
662:
663: memset(ether_packet, 0, packetsize);
664:
665: btph = (struct btphdr *) (ðer_packet[
666: sizeof(struct iphdr) + sizeof(struct udphdr)]);
667:
668: btph -> op = 1;
669: btph -> htype = 1;
670: btph -> hlen = 6;
671: memcpy(btph -> chaddr, get_mac_address(), 6);
672:
673: memset(&opt, 0, sizeof(dhcp_options_t));
674:
675: opt.msg_type = DHCPREQUEST;
676: memcpy(&(opt.requested_IP), &dhcp_own_ip, 4);
677: opt.flag[DHCP_REQUESTED_IP] = 1;
678: memcpy(&(opt.server_ID), &dhcp_server_ip, 4);
679: opt.flag[DHCP_SERVER_ID] = 1;
680:
681: opt.request_list[DHCP_MASK] = 1;
682: opt.request_list[DHCP_DNS] = 1;
683: opt.request_list[DHCP_ROUTER] = 1;
684: opt.request_list[DHCP_TFTP_SERVER] = 1;
685: opt.request_list[DHCP_BOOTFILE] = 1;
686:
687: dhcp_encode_options(btph -> vend, &opt);
688:
689: fill_udphdr(ðer_packet[sizeof(struct iphdr)],
690: sizeof(struct btphdr) + sizeof(struct udphdr),
691: UDPPORT_BOOTPC, UDPPORT_BOOTPS);
692: fill_iphdr(ether_packet, sizeof(struct btphdr) +
693: sizeof(struct udphdr) + sizeof(struct iphdr),
694: IPTYPE_UDP, 0, 0xFFFFFFFF);
695:
696: send_ipv4(ether_packet, packetsize);
697: }
698:
699:
700: /**
701: * DHCP: Sends DHCP-Release message. Releases occupied IP.
702: */
703: void dhcp_send_release(void) {
704: uint32_t packetsize = sizeof(struct iphdr) +
705: sizeof(struct udphdr) + sizeof(struct btphdr);
706: struct btphdr *btph;
707: dhcp_options_t opt;
708:
709: btph = (struct btphdr *) (ðer_packet[
710: sizeof(struct iphdr) + sizeof(struct udphdr)]);
711:
712: memset(ether_packet, 0, packetsize);
713:
714: btph -> op = 1;
715: btph -> htype = 1;
716: btph -> hlen = 6;
717: strcpy((char *) btph -> file, "");
718: memcpy(btph -> chaddr, get_mac_address(), 6);
719: btph -> ciaddr = htonl(dhcp_own_ip);
720:
721: memset(&opt, 0, sizeof(dhcp_options_t));
722:
723: opt.msg_type = DHCPRELEASE;
724: opt.server_ID = dhcp_server_ip;
725: opt.flag[DHCP_SERVER_ID] = 1;
726:
727: dhcp_encode_options(btph -> vend, &opt);
728:
729: fill_udphdr(ðer_packet[sizeof(struct iphdr)],
730: sizeof(struct btphdr) + sizeof(struct udphdr),
731: UDPPORT_BOOTPC, UDPPORT_BOOTPS);
732: fill_iphdr(ether_packet, sizeof(struct btphdr) +
733: sizeof(struct udphdr) + sizeof(struct iphdr), IPTYPE_UDP,
734: dhcp_own_ip, dhcp_server_ip);
735:
736: send_ipv4(ether_packet, packetsize);
737: }
738:
739: /**
740: * DHCP: Handles DHCP-messages according to Receive-handle diagram.
741: * Changes the state of DHCP-client.
742: *
743: * @param packet BootP/DHCP-packet to be handled
744: * @param packetsize length of the packet
745: * @return ZERO - packet handled successfully;
746: * NON ZERO - packet was not handled (e.g. bad format)
747: * @see receive_ether
748: * @see btphdr
749: */
750:
751: int8_t
752: handle_dhcp(uint8_t * packet, int32_t packetsize) {
753: struct btphdr * btph;
754: struct iphdr * iph;
755: dhcp_options_t opt;
756:
757: memset(&opt, 0, sizeof(dhcp_options_t));
758: btph = (struct btphdr *) packet;
759: iph = (struct iphdr *) packet - sizeof(struct udphdr) -
760: sizeof(struct iphdr);
761: if (btph -> op != 2)
762: return -1; // it is not Boot Reply
763:
764: if(response_buffer) {
765: if(packetsize <= 1720)
766: memcpy(response_buffer, packet, packetsize);
767: else
768: memcpy(response_buffer, packet, 1720);
769: }
770:
771: if (memcmp(btph -> vend, dhcp_magic, 4)) {
772: // It is BootP - RFC 951
773: dhcp_own_ip = htonl(btph -> yiaddr);
774: dhcp_siaddr_ip = htonl(btph -> siaddr);
775: dhcp_server_ip = htonl(iph -> ip_src);
776:
777: if (strlen((char *) btph -> sname) && !dhcp_siaddr_ip) {
778: strncpy((char *) dhcp_tftp_name, (char *) btph -> sname,
779: sizeof(btph -> sname));
780: dhcp_tftp_name[sizeof(btph -> sname)] = 0;
781: }
782:
783: if (strlen((char *) btph -> file)) {
784: strncpy((char *) dhcp_filename, (char *) btph -> file, sizeof(btph -> file));
785: dhcp_filename[sizeof(btph -> file)] = 0;
786: }
787:
788: dhcp_state = DHCP_STATE_SUCCESS;
789: return 0;
790: }
791:
792:
793: // decode options
794: if (!dhcp_decode_options(btph -> vend, packetsize -
795: sizeof(struct btphdr) + sizeof(btph -> vend),
796: &opt)) {
797: return -1; // can't decode options
798: }
799:
800: if (opt.overload) {
801: int16_t decode_res = 0;
802: uint8_t options[1024]; // buffer for merged options
803: uint32_t opt_len;
804:
805: // move 1-st part of options from vend field into buffer
806: opt_len = packetsize - sizeof(struct btphdr) +
807: sizeof(btph -> vend) - 4;
808: memcpy(options, btph -> vend, opt_len + 4);
809:
810: // add other parts
811: switch (opt.overload) {
812: case DHCP_OVERLOAD_FILE:
813: decode_res = dhcp_merge_options(options + 4, &opt_len,
814: btph -> file,
815: sizeof(btph -> file));
816: break;
817: case DHCP_OVERLOAD_SNAME:
818: decode_res = dhcp_merge_options(options + 4, &opt_len,
819: btph -> sname,
820: sizeof(btph -> sname));
821: break;
822: case DHCP_OVERLOAD_BOTH:
823: decode_res = dhcp_merge_options(options + 4, &opt_len,
824: btph -> file,
825: sizeof(btph -> file));
826: if (!decode_res)
827: break;
828: decode_res = dhcp_merge_options(options + 4, &opt_len,
829: btph -> sname,
830: sizeof(btph -> sname));
831: break;
832: }
833:
834: if (!decode_res)
835: return -1; // bad options in sname/file fields
836:
837: // decode merged options
838: if (!dhcp_decode_options(options, opt_len + 4, &opt)) {
839: return -1; // can't decode options
840: }
841: }
842:
843: if (!opt.msg_type) {
844: // It is BootP with Extensions - RFC 1497
845: // retrieve conf. settings from BootP - reply
846: dhcp_own_ip = htonl(btph -> yiaddr);
847: dhcp_siaddr_ip = htonl(btph -> siaddr);
848: if (strlen((char *) btph -> sname) && !dhcp_siaddr_ip) {
849: strncpy((char *) dhcp_tftp_name, (char *) btph -> sname, sizeof(btph -> sname));
850: dhcp_tftp_name[sizeof(btph -> sname)] = 0;
851: }
852:
853: if (strlen((char *) btph -> file)) {
854: strncpy((char *) dhcp_filename, (char *) btph -> file, sizeof(btph -> file));
855: dhcp_filename[sizeof(btph -> file)] = 0;
856: }
857:
858: // retrieve DHCP-server IP from IP-header
859: dhcp_server_ip = iph -> htonl(ip_src);
860:
861: dhcp_state = DHCP_STATE_SUCCESS;
862: }
863: else {
864: // It is DHCP - RFC 2131 & RFC 2132
865: // opt contains parameters from server
866: switch (dhcp_state) {
867: case DHCP_STATE_SELECT :
868: if (opt.msg_type == DHCPOFFER) {
869: dhcp_own_ip = htonl(btph -> yiaddr);
870: dhcp_server_ip = opt.server_ID;
871: dhcp_send_request();
872: dhcp_state = DHCP_STATE_REQUEST;
873: }
874: return 0;
875: case DHCP_STATE_REQUEST :
876: switch (opt.msg_type) {
877: case DHCPNACK :
878: dhcp_own_ip = 0;
879: dhcp_server_ip = 0;
880: dhcp_state = DHCP_STATE_FAULT;
881: break;
882: case DHCPACK :
883: dhcp_own_ip = htonl(btph -> yiaddr);
884: dhcp_server_ip = opt.server_ID;
885: dhcp_siaddr_ip = htonl(btph -> siaddr);
886: if (opt.flag[DHCP_TFTP_SERVER]) {
887: strcpy((char *) dhcp_tftp_name, (char *) opt.tftp_server);
888: }
889: else {
890: strcpy((char *) dhcp_tftp_name, "");
891: if ((opt.overload != DHCP_OVERLOAD_SNAME &&
892: opt.overload != DHCP_OVERLOAD_BOTH) &&
893: !dhcp_siaddr_ip) {
894: strncpy((char *) dhcp_tftp_name,
895: (char *) btph->sname,
896: sizeof(btph -> sname));
897: dhcp_tftp_name[sizeof(btph->sname)] = 0;
898: }
899: }
900:
901: if (opt.flag[DHCP_BOOTFILE]) {
902: strcpy((char *) dhcp_filename, (char *) opt.bootfile);
903: }
904: else {
905: strcpy((char *) dhcp_filename, "");
906: if (opt.overload != DHCP_OVERLOAD_FILE &&
907: opt.overload != DHCP_OVERLOAD_BOTH &&
908: strlen((char *) btph -> file)) {
909: strncpy((char *) dhcp_filename,
910: (char *) btph->file,
911: sizeof(btph->file));
912: dhcp_filename[sizeof(btph -> file)] = 0;
913: }
914: }
915:
916: dhcp_state = DHCP_STATE_SUCCESS;
917: break;
918: default:
919: break; // Unused DHCP-message - do nothing
920: }
921: break;
922: default :
923: return -1; // Illegal DHCP-client state
924: }
925: }
926:
927: if (dhcp_state == DHCP_STATE_SUCCESS) {
928:
929: // initialize network entity with real own_ip
930: // to be able to answer for foreign requests
931: set_ipv4_address(dhcp_own_ip);
932:
933: /* Subnet mask */
934: if (opt.flag[DHCP_MASK]) {
935: /* Router */
936: if (opt.flag[DHCP_ROUTER]) {
937: set_ipv4_router(opt.router_IP);
938: set_ipv4_netmask(opt.subnet_mask);
939: }
940: }
941:
942: /* DNS-server */
943: if (opt.flag[DHCP_DNS]) {
944: dns_init(opt.dns_IP);
945: }
946: }
947:
948: return 0;
949: }
950:
951: /**
952: * DHCP: Converts "255.255.255.255" -> 32-bit long IP
953: *
954: * @param str string to be converted
955: * @param ip in case of SUCCESS - 32-bit long IP
956: in case of FAULT - zero
957: * @return TRUE - IP converted successfully;
958: * FALSE - error condition occurs (e.g. bad format)
959: */
960: static uint8_t
961: strtoip(int8_t * str, uint32_t * ip) {
962: int8_t ** ptr = &str;
963: int16_t i = 0, res, len;
964: char octet[256];
965:
966: * ip = 0;
967:
968: while (**ptr != 0) {
969: if (i > 3 || !isdigit(**ptr))
970: return 0;
971: if (strstr((char *) * ptr, ".") != NULL) {
972: len = (int16_t) ((int8_t *) strstr((char *) * ptr, ".") -
973: (int8_t *) (* ptr));
974: strncpy(octet, (char *) * ptr, len); octet[len] = 0;
975: * ptr += len;
976: }
977: else {
978: strcpy(octet, (char *) * ptr);
979: * ptr += strlen(octet);
980: }
981: res = strtol(octet, NULL, 10);
982: if ((res > 255) || (res < 0))
983: return 0;
984: * ip = ((* ip) << 8) + res;
985: i++;
986: if (** ptr == '.')
987: (*ptr)++;
988: }
989:
990: if (i != 4)
991: return 0;
992: return 1;
993: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.