1 /* vi: set sw=4 ts=4: */
3 * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
5 * Licensed under GPLv2, see file LICENSE in this source tree.
9 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
10 unsigned dhcp_verbose
;
13 const uint8_t MAC_BCAST_ADDR
[6] ALIGN2
= {
14 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
17 /* Supported options are easily added here.
18 * See RFC2132 for more options.
19 * OPTION_REQ: these options are requested by udhcpc (unless -o).
21 const struct dhcp_optflag dhcp_optflags
[] = {
23 { OPTION_IP
| OPTION_REQ
, 0x01 }, /* DHCP_SUBNET */
24 { OPTION_S32
, 0x02 }, /* DHCP_TIME_OFFSET */
25 { OPTION_IP
| OPTION_LIST
| OPTION_REQ
, 0x03 }, /* DHCP_ROUTER */
26 // { OPTION_IP | OPTION_LIST , 0x04 }, /* DHCP_TIME_SERVER */
27 // { OPTION_IP | OPTION_LIST , 0x05 }, /* DHCP_NAME_SERVER */
28 { OPTION_IP
| OPTION_LIST
| OPTION_REQ
, 0x06 }, /* DHCP_DNS_SERVER */
29 // { OPTION_IP | OPTION_LIST , 0x07 }, /* DHCP_LOG_SERVER */
30 // { OPTION_IP | OPTION_LIST , 0x08 }, /* DHCP_COOKIE_SERVER */
31 { OPTION_IP
| OPTION_LIST
, 0x09 }, /* DHCP_LPR_SERVER */
32 { OPTION_STRING_HOST
| OPTION_REQ
, 0x0c }, /* DHCP_HOST_NAME */
33 { OPTION_U16
, 0x0d }, /* DHCP_BOOT_SIZE */
34 { OPTION_STRING_HOST
| OPTION_REQ
, 0x0f }, /* DHCP_DOMAIN_NAME */
35 { OPTION_IP
, 0x10 }, /* DHCP_SWAP_SERVER */
36 { OPTION_STRING
, 0x11 }, /* DHCP_ROOT_PATH */
37 { OPTION_U8
, 0x17 }, /* DHCP_IP_TTL */
38 { OPTION_U16
, 0x1a }, /* DHCP_MTU */
39 { OPTION_IP
| OPTION_REQ
, 0x1c }, /* DHCP_BROADCAST */
40 { OPTION_IP_PAIR
| OPTION_LIST
, 0x21 }, /* DHCP_ROUTES */
41 { OPTION_STRING_HOST
, 0x28 }, /* DHCP_NIS_DOMAIN */
42 { OPTION_IP
| OPTION_LIST
, 0x29 }, /* DHCP_NIS_SERVER */
43 { OPTION_IP
| OPTION_LIST
| OPTION_REQ
, 0x2a }, /* DHCP_NTP_SERVER */
44 { OPTION_IP
| OPTION_LIST
, 0x2c }, /* DHCP_WINS_SERVER */
45 { OPTION_U32
, 0x33 }, /* DHCP_LEASE_TIME */
46 { OPTION_IP
, 0x36 }, /* DHCP_SERVER_ID */
47 { OPTION_STRING
, 0x38 }, /* DHCP_ERR_MESSAGE */
48 //TODO: must be combined with 'sname' and 'file' handling:
49 { OPTION_STRING_HOST
, 0x42 }, /* DHCP_TFTP_SERVER_NAME */
50 { OPTION_STRING
, 0x43 }, /* DHCP_BOOT_FILE */
51 //TODO: not a string, but a set of LASCII strings:
52 // { OPTION_STRING , 0x4D }, /* DHCP_USER_CLASS */
53 #if ENABLE_FEATURE_UDHCP_RFC3397
54 { OPTION_DNS_STRING
| OPTION_LIST
, 0x77 }, /* DHCP_DOMAIN_SEARCH */
55 { OPTION_SIP_SERVERS
, 0x78 }, /* DHCP_SIP_SERVERS */
57 { OPTION_STATIC_ROUTES
| OPTION_LIST
, 0x79 }, /* DHCP_STATIC_ROUTES */
58 #if ENABLE_FEATURE_UDHCP_8021Q
59 { OPTION_U16
, 0x84 }, /* DHCP_VLAN_ID */
60 { OPTION_U8
, 0x85 }, /* DHCP_VLAN_PRIORITY */
62 { OPTION_6RD
, 0xd4 }, /* DHCP_6RD */
63 { OPTION_STATIC_ROUTES
| OPTION_LIST
, 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
64 { OPTION_STRING
, 0xfc }, /* DHCP_WPAD */
66 /* Options below have no match in dhcp_option_strings[],
67 * are not passed to dhcpc scripts, and cannot be specified
68 * with "option XXX YYY" syntax in dhcpd config file.
69 * These entries are only used internally by udhcp[cd]
70 * to correctly encode options into packets.
73 { OPTION_IP
, 0x32 }, /* DHCP_REQUESTED_IP */
74 { OPTION_U8
, 0x35 }, /* DHCP_MESSAGE_TYPE */
75 { OPTION_U16
, 0x39 }, /* DHCP_MAX_SIZE */
76 //looks like these opts will work just fine even without these defs:
77 // { OPTION_STRING , 0x3c }, /* DHCP_VENDOR */
78 // /* not really a string: */
79 // { OPTION_STRING , 0x3d }, /* DHCP_CLIENT_ID */
80 { 0, 0 } /* zeroed terminating entry */
83 /* Used for converting options from incoming packets to env variables
84 * for udhcpc stript, and for setting options for udhcpd via
85 * "opt OPTION_NAME OPTION_VALUE" directives in udhcpd.conf file.
87 /* Must match dhcp_optflags[] order */
88 const char dhcp_option_strings
[] ALIGN1
=
89 "subnet" "\0" /* DHCP_SUBNET */
90 "timezone" "\0" /* DHCP_TIME_OFFSET */
91 "router" "\0" /* DHCP_ROUTER */
92 // "timesrv" "\0" /* DHCP_TIME_SERVER */
93 // "namesrv" "\0" /* DHCP_NAME_SERVER */
94 "dns" "\0" /* DHCP_DNS_SERVER */
95 // "logsrv" "\0" /* DHCP_LOG_SERVER */
96 // "cookiesrv" "\0" /* DHCP_COOKIE_SERVER */
97 "lprsrv" "\0" /* DHCP_LPR_SERVER */
98 "hostname" "\0" /* DHCP_HOST_NAME */
99 "bootsize" "\0" /* DHCP_BOOT_SIZE */
100 "domain" "\0" /* DHCP_DOMAIN_NAME */
101 "swapsrv" "\0" /* DHCP_SWAP_SERVER */
102 "rootpath" "\0" /* DHCP_ROOT_PATH */
103 "ipttl" "\0" /* DHCP_IP_TTL */
104 "mtu" "\0" /* DHCP_MTU */
105 "broadcast" "\0" /* DHCP_BROADCAST */
106 "routes" "\0" /* DHCP_ROUTES */
107 "nisdomain" "\0" /* DHCP_NIS_DOMAIN */
108 "nissrv" "\0" /* DHCP_NIS_SERVER */
109 "ntpsrv" "\0" /* DHCP_NTP_SERVER */
110 "wins" "\0" /* DHCP_WINS_SERVER */
111 "lease" "\0" /* DHCP_LEASE_TIME */
112 "serverid" "\0" /* DHCP_SERVER_ID */
113 "message" "\0" /* DHCP_ERR_MESSAGE */
114 "tftp" "\0" /* DHCP_TFTP_SERVER_NAME */
115 "bootfile" "\0" /* DHCP_BOOT_FILE */
116 // "userclass" "\0" /* DHCP_USER_CLASS */
117 #if ENABLE_FEATURE_UDHCP_RFC3397
118 "search" "\0" /* DHCP_DOMAIN_SEARCH */
119 // doesn't work in udhcpd.conf since OPTION_SIP_SERVERS
120 // is not handled yet by "string->option" conversion code:
121 "sipsrv" "\0" /* DHCP_SIP_SERVERS */
123 "staticroutes" "\0"/* DHCP_STATIC_ROUTES */
124 #if ENABLE_FEATURE_UDHCP_8021Q
125 "vlanid" "\0" /* DHCP_VLAN_ID */
126 "vlanpriority" "\0"/* DHCP_VLAN_PRIORITY */
128 "ip6rd" "\0" /* DHCP_6RD */
129 "msstaticroutes""\0"/* DHCP_MS_STATIC_ROUTES */
130 "wpad" "\0" /* DHCP_WPAD */
133 /* Lengths of the option types in binary form.
135 * udhcp_str2optset: to determine how many bytes to allocate.
136 * xmalloc_optname_optval: to estimate string length
137 * from binary option length: (option[LEN] / dhcp_option_lengths[opt_type])
138 * is the number of elements, multiply in by one element's string width
139 * (len_of_option_as_string[opt_type]) and you know how wide string you need.
141 const uint8_t dhcp_option_lengths
[] ALIGN1
= {
143 [OPTION_IP_PAIR
] = 8,
144 // [OPTION_BOOLEAN] = 1,
145 [OPTION_STRING
] = 1, /* ignored by udhcp_str2optset */
146 [OPTION_STRING_HOST
] = 1, /* ignored by udhcp_str2optset */
147 #if ENABLE_FEATURE_UDHCP_RFC3397
148 [OPTION_DNS_STRING
] = 1, /* ignored by both udhcp_str2optset and xmalloc_optname_optval */
149 [OPTION_SIP_SERVERS
] = 1,
156 /* Just like OPTION_STRING, we use minimum length here */
157 [OPTION_STATIC_ROUTES
] = 5,
158 [OPTION_6RD
] = 22, /* ignored by udhcp_str2optset */
162 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
163 static void log_option(const char *pfx
, const uint8_t *opt
)
165 if (dhcp_verbose
>= 2) {
166 char buf
[256 * 2 + 2];
167 *bin2hex(buf
, (void*) (opt
+ OPT_DATA
), opt
[OPT_LEN
]) = '\0';
168 bb_info_msg("%s: 0x%02x %s", pfx
, opt
[OPT_CODE
], buf
);
172 # define log_option(pfx, opt) ((void)0)
175 unsigned FAST_FUNC
udhcp_option_idx(const char *name
)
177 int n
= index_in_strings(dhcp_option_strings
, name
);
182 char buf
[sizeof(dhcp_option_strings
)];
184 const char *s
= dhcp_option_strings
;
185 while (s
< dhcp_option_strings
+ sizeof(dhcp_option_strings
) - 2) {
186 *d
++ = (*s
== '\0' ? ' ' : *s
);
190 bb_error_msg_and_die("unknown option '%s', known options: %s", name
, buf
);
194 /* Get an option with bounds checking (warning, result is not aligned) */
195 uint8_t* FAST_FUNC
udhcp_get_option(struct dhcp_packet
*packet
, int code
)
202 FILE_FIELD101
= FILE_FIELD
* 0x101,
203 SNAME_FIELD101
= SNAME_FIELD
* 0x101,
206 /* option bytes: [code][len][data1][data2]..[dataLEN] */
207 optionptr
= packet
->options
;
208 rem
= sizeof(packet
->options
);
211 bb_error_msg("bad packet, malformed option field");
214 if (optionptr
[OPT_CODE
] == DHCP_PADDING
) {
219 if (optionptr
[OPT_CODE
] == DHCP_END
) {
220 if ((overload
& FILE_FIELD101
) == FILE_FIELD
) {
221 /* can use packet->file, and didn't look at it yet */
222 overload
|= FILE_FIELD101
; /* "we looked at it" */
223 optionptr
= packet
->file
;
224 rem
= sizeof(packet
->file
);
227 if ((overload
& SNAME_FIELD101
) == SNAME_FIELD
) {
228 /* can use packet->sname, and didn't look at it yet */
229 overload
|= SNAME_FIELD101
; /* "we looked at it" */
230 optionptr
= packet
->sname
;
231 rem
= sizeof(packet
->sname
);
236 len
= 2 + optionptr
[OPT_LEN
];
239 continue; /* complain and return NULL */
241 if (optionptr
[OPT_CODE
] == code
) {
242 log_option("Option found", optionptr
);
243 return optionptr
+ OPT_DATA
;
246 if (optionptr
[OPT_CODE
] == DHCP_OPTION_OVERLOAD
) {
247 overload
|= optionptr
[OPT_DATA
];
253 /* log3 because udhcpc uses it a lot - very noisy */
254 log3("Option 0x%02x not found", code
);
258 /* Return the position of the 'end' option (no bounds checking) */
259 int FAST_FUNC
udhcp_end_option(uint8_t *optionptr
)
263 while (optionptr
[i
] != DHCP_END
) {
264 if (optionptr
[i
] != DHCP_PADDING
)
265 i
+= optionptr
[i
+ OPT_LEN
] + OPT_DATA
-1;
271 /* Add an option (supplied in binary form) to the options.
272 * Option format: [code][len][data1][data2]..[dataLEN]
274 void FAST_FUNC
udhcp_add_binary_option(struct dhcp_packet
*packet
, uint8_t *addopt
)
277 uint8_t *optionptr
= packet
->options
;
278 unsigned end
= udhcp_end_option(optionptr
);
280 len
= OPT_DATA
+ addopt
[OPT_LEN
];
281 /* end position + (option code/length + addopt length) + end option */
282 if (end
+ len
+ 1 >= DHCP_OPTIONS_BUFSIZE
) {
283 //TODO: learn how to use overflow option if we exhaust packet->options[]
284 bb_error_msg("option 0x%02x did not fit into the packet",
288 log_option("Adding option", addopt
);
289 memcpy(optionptr
+ end
, addopt
, len
);
290 optionptr
[end
+ len
] = DHCP_END
;
293 /* Add an one to four byte option to a packet */
294 void FAST_FUNC
udhcp_add_simple_option(struct dhcp_packet
*packet
, uint8_t code
, uint32_t data
)
296 const struct dhcp_optflag
*dh
;
298 for (dh
= dhcp_optflags
; dh
->code
; dh
++) {
299 if (dh
->code
== code
) {
300 uint8_t option
[6], len
;
302 option
[OPT_CODE
] = code
;
303 len
= dhcp_option_lengths
[dh
->flags
& OPTION_TYPE_MASK
];
304 option
[OPT_LEN
] = len
;
306 data
<<= 8 * (4 - len
);
307 /* Assignment is unaligned! */
308 move_to_unaligned32(&option
[OPT_DATA
], data
);
309 udhcp_add_binary_option(packet
, option
);
314 bb_error_msg("can't add option 0x%02x", code
);
317 /* Find option 'code' in opt_list */
318 struct option_set
* FAST_FUNC
udhcp_find_option(struct option_set
*opt_list
, uint8_t code
)
320 while (opt_list
&& opt_list
->data
[OPT_CODE
] < code
)
321 opt_list
= opt_list
->next
;
323 if (opt_list
&& opt_list
->data
[OPT_CODE
] == code
)
328 /* Parse string to IP in network order */
329 int FAST_FUNC
udhcp_str2nip(const char *str
, void *arg
)
331 len_and_sockaddr
*lsa
;
333 lsa
= host_and_af2sockaddr(str
, 0, AF_INET
);
336 /* arg maybe unaligned */
337 move_to_unaligned32((uint32_t*)arg
, lsa
->u
.sin
.sin_addr
.s_addr
);
343 * Parse string option representation to binary form and add it to opt_list.
344 * Called to parse "udhcpc -x OPTNAME:OPTVAL"
345 * and to parse udhcpd.conf's "opt OPTNAME OPTVAL" directives.
347 /* helper for the helper */
348 static char *allocate_tempopt_if_needed(
349 const struct dhcp_optflag
*optflag
,
353 char *allocated
= NULL
;
354 if ((optflag
->flags
& OPTION_TYPE_MASK
) == OPTION_BIN
) {
356 allocated
= xstrdup(buffer
); /* more than enough */
357 end
= hex2bin(allocated
, buffer
, 255);
359 bb_error_msg_and_die("malformed hex string '%s'", buffer
);
360 *length_p
= end
- allocated
;
364 /* helper: add an option to the opt_list */
365 static NOINLINE
void attach_option(
366 struct option_set
**opt_list
,
367 const struct dhcp_optflag
*optflag
,
371 struct option_set
*existing
, *new, **curr
;
372 char *allocated
= NULL
;
374 existing
= udhcp_find_option(*opt_list
, optflag
->code
);
376 log2("Attaching option %02x to list", optflag
->code
);
377 allocated
= allocate_tempopt_if_needed(optflag
, buffer
, &length
);
378 #if ENABLE_FEATURE_UDHCP_RFC3397
379 if ((optflag
->flags
& OPTION_TYPE_MASK
) == OPTION_DNS_STRING
) {
380 /* reuse buffer and length for RFC1035-formatted string */
381 allocated
= buffer
= (char *)dname_enc(NULL
, 0, buffer
, &length
);
384 /* make a new option */
385 new = xmalloc(sizeof(*new));
386 new->data
= xmalloc(length
+ OPT_DATA
);
387 new->data
[OPT_CODE
] = optflag
->code
;
388 new->data
[OPT_LEN
] = length
;
389 memcpy(new->data
+ OPT_DATA
, (allocated
? allocated
: buffer
), length
);
392 while (*curr
&& (*curr
)->data
[OPT_CODE
] < optflag
->code
)
393 curr
= &(*curr
)->next
;
400 if (optflag
->flags
& OPTION_LIST
) {
403 /* add it to an existing option */
404 log2("Attaching option %02x to existing member of list", optflag
->code
);
405 allocated
= allocate_tempopt_if_needed(optflag
, buffer
, &length
);
406 old_len
= existing
->data
[OPT_LEN
];
407 #if ENABLE_FEATURE_UDHCP_RFC3397
408 if ((optflag
->flags
& OPTION_TYPE_MASK
) == OPTION_DNS_STRING
) {
409 /* reuse buffer and length for RFC1035-formatted string */
410 allocated
= buffer
= (char *)dname_enc(existing
->data
+ OPT_DATA
, old_len
, buffer
, &length
);
413 if (old_len
+ length
< 255) {
414 /* actually 255 is ok too, but adding a space can overlow it */
416 existing
->data
= xrealloc(existing
->data
, OPT_DATA
+ 1 + old_len
+ length
);
417 if ((optflag
->flags
& OPTION_TYPE_MASK
) == OPTION_STRING
418 || (optflag
->flags
& OPTION_TYPE_MASK
) == OPTION_STRING_HOST
420 /* add space separator between STRING options in a list */
421 existing
->data
[OPT_DATA
+ old_len
] = ' ';
424 memcpy(existing
->data
+ OPT_DATA
+ old_len
, buffer
, length
);
425 existing
->data
[OPT_LEN
] = old_len
+ length
;
426 } /* else, ignore the data, we could put this in a second option in the future */
427 } /* else, ignore the new data */
433 int FAST_FUNC
udhcp_str2optset(const char *const_str
, void *arg
)
435 struct option_set
**opt_list
= arg
;
438 const struct dhcp_optflag
*optflag
;
439 struct dhcp_optflag bin_optflag
;
442 /* IP_PAIR needs 8 bytes, STATIC_ROUTES needs 9 max */
443 char buffer
[9] ALIGNED(4);
444 uint16_t *result_u16
= (uint16_t *) buffer
;
445 uint32_t *result_u32
= (uint32_t *) buffer
;
447 /* Cheat, the only *const* str possible is "" */
448 str
= (char *) const_str
;
449 opt
= strtok(str
, " \t=");
453 optcode
= bb_strtou(opt
, NULL
, 0);
454 if (!errno
&& optcode
< 255) {
455 /* Raw (numeric) option code */
456 bin_optflag
.flags
= OPTION_BIN
;
457 bin_optflag
.code
= optcode
;
458 optflag
= &bin_optflag
;
460 optflag
= &dhcp_optflags
[udhcp_option_idx(opt
)];
465 val
= strtok(NULL
, ", \t");
468 length
= dhcp_option_lengths
[optflag
->flags
& OPTION_TYPE_MASK
];
470 opt
= buffer
; /* new meaning for variable opt */
471 switch (optflag
->flags
& OPTION_TYPE_MASK
) {
473 retval
= udhcp_str2nip(val
, buffer
);
476 retval
= udhcp_str2nip(val
, buffer
);
477 val
= strtok(NULL
, ", \t/-");
481 retval
= udhcp_str2nip(val
, buffer
+ 4);
484 case OPTION_STRING_HOST
:
485 #if ENABLE_FEATURE_UDHCP_RFC3397
486 case OPTION_DNS_STRING
:
488 length
= strnlen(val
, 254);
494 // case OPTION_BOOLEAN: {
495 // static const char no_yes[] ALIGN1 = "no\0yes\0";
496 // buffer[0] = retval = index_in_strings(no_yes, val);
497 // retval++; /* 0 - bad; 1: "no" 2: "yes" */
501 buffer
[0] = bb_strtou32(val
, NULL
, 0);
502 retval
= (errno
== 0);
504 /* htonX are macros in older libc's, using temp var
505 * in code below for safety */
506 /* TODO: use bb_strtoX? */
508 uint32_t tmp
= bb_strtou32(val
, NULL
, 0);
509 *result_u16
= htons(tmp
);
510 retval
= (errno
== 0 /*&& tmp < 0x10000*/);
513 // case OPTION_S16: {
514 // long tmp = bb_strtoi32(val, NULL, 0);
515 // *result_u16 = htons(tmp);
516 // retval = (errno == 0);
520 uint32_t tmp
= bb_strtou32(val
, NULL
, 0);
521 *result_u32
= htonl(tmp
);
522 retval
= (errno
== 0);
526 int32_t tmp
= bb_strtoi32(val
, NULL
, 0);
527 *result_u32
= htonl(tmp
);
528 retval
= (errno
== 0);
531 case OPTION_STATIC_ROUTES
: {
532 /* Input: "a.b.c.d/m" */
533 /* Output: mask(1 byte),pfx(0-4 bytes),gw(4 bytes) */
535 char *slash
= strchr(val
, '/');
538 retval
= udhcp_str2nip(val
, buffer
+ 1);
539 buffer
[0] = mask
= bb_strtou(slash
+ 1, NULL
, 10);
540 val
= strtok(NULL
, ", \t/-");
541 if (!val
|| mask
> 32 || errno
)
544 length
= ((mask
+ 7) >> 3) + 5;
545 retval
= udhcp_str2nip(val
, buffer
+ (length
- 4));
550 case OPTION_BIN
: /* handled in attach_option() */
557 attach_option(opt_list
, optflag
, opt
, length
);
558 } while (retval
&& (optflag
->flags
& OPTION_LIST
));
563 /* note: ip is a pointer to an IPv6 in network order, possibly misaliged */
564 int FAST_FUNC
sprint_nip6(char *dest
, /*const char *pre,*/ const uint8_t *ip
)
566 char hexstrbuf
[16 * 2];
567 bin2hex(hexstrbuf
, (void*)ip
, 16);
568 return sprintf(dest
, /* "%s" */
569 "%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s",