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
| OPTION_REQ
, 0x0c }, /* DHCP_HOST_NAME */
33 { OPTION_U16
, 0x0d }, /* DHCP_BOOT_SIZE */
34 { OPTION_STRING
| 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_STRING
, 0x28 }, /* DHCP_NIS_DOMAIN */
41 { OPTION_IP
| OPTION_LIST
, 0x29 }, /* DHCP_NIS_SERVER */
42 { OPTION_IP
| OPTION_LIST
| OPTION_REQ
, 0x2a }, /* DHCP_NTP_SERVER */
43 { OPTION_IP
| OPTION_LIST
, 0x2c }, /* DHCP_WINS_SERVER */
44 { OPTION_U32
, 0x33 }, /* DHCP_LEASE_TIME */
45 { OPTION_IP
, 0x36 }, /* DHCP_SERVER_ID */
46 { OPTION_STRING
, 0x38 }, /* DHCP_ERR_MESSAGE */
47 //TODO: must be combined with 'sname' and 'file' handling:
48 { OPTION_STRING
, 0x42 }, /* DHCP_TFTP_SERVER_NAME */
49 { OPTION_STRING
, 0x43 }, /* DHCP_BOOT_FILE */
50 //TODO: not a string, but a set of LASCII strings:
51 // { OPTION_STRING , 0x4D }, /* DHCP_USER_CLASS */
52 #if ENABLE_FEATURE_UDHCP_RFC3397
53 { OPTION_DNS_STRING
| OPTION_LIST
, 0x77 }, /* DHCP_DOMAIN_SEARCH */
54 { OPTION_SIP_SERVERS
, 0x78 }, /* DHCP_SIP_SERVERS */
56 { OPTION_STATIC_ROUTES
| OPTION_REQ
, 0x79 }, /* DHCP_STATIC_ROUTES */
57 { OPTION_IP
| OPTION_LIST
| OPTION_REQ
, 0x21 }, /* DHCP_ROUTES */
58 { OPTION_STATIC_ROUTES
| OPTION_REQ
, 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
59 #if ENABLE_FEATURE_UDHCP_RFC5969
60 { OPTION_6RD
, 0xd4 }, /* DHCP_6RD */
61 { OPTION_6RD
, 0x96 }, /* DHCP_COMCAST_6RD */
63 { OPTION_STRING
, 0xfc }, /* DHCP_WPAD */
65 /* Options below have no match in dhcp_option_strings[],
66 * are not passed to dhcpc scripts, and cannot be specified
67 * with "option XXX YYY" syntax in dhcpd config file.
68 * These entries are only used internally by udhcp[cd]
69 * to correctly encode options into packets.
72 { OPTION_IP
, 0x32 }, /* DHCP_REQUESTED_IP */
73 { OPTION_U8
, 0x35 }, /* DHCP_MESSAGE_TYPE */
74 { OPTION_U16
, 0x39 }, /* DHCP_MAX_SIZE */
75 //looks like these opts will work just fine even without these defs:
76 // { OPTION_STRING , 0x3c }, /* DHCP_VENDOR */
77 // /* not really a string: */
78 // { OPTION_STRING , 0x3d }, /* DHCP_CLIENT_ID */
79 { 0, 0 } /* zeroed terminating entry */
82 /* Used for converting options from incoming packets to env variables
83 * for udhcpc stript, and for setting options for udhcpd via
84 * "opt OPTION_NAME OPTION_VALUE" directives in udhcpd.conf file.
86 /* Must match dhcp_optflags[] order */
87 const char dhcp_option_strings
[] ALIGN1
=
88 "subnet" "\0" /* DHCP_SUBNET */
89 "timezone" "\0" /* DHCP_TIME_OFFSET */
90 "router" "\0" /* DHCP_ROUTER */
91 // "timesrv" "\0" /* DHCP_TIME_SERVER */
92 // "namesrv" "\0" /* DHCP_NAME_SERVER */
93 "dns" "\0" /* DHCP_DNS_SERVER */
94 // "logsrv" "\0" /* DHCP_LOG_SERVER */
95 // "cookiesrv" "\0" /* DHCP_COOKIE_SERVER */
96 "lprsrv" "\0" /* DHCP_LPR_SERVER */
97 "hostname" "\0" /* DHCP_HOST_NAME */
98 "bootsize" "\0" /* DHCP_BOOT_SIZE */
99 "domain" "\0" /* DHCP_DOMAIN_NAME */
100 "swapsrv" "\0" /* DHCP_SWAP_SERVER */
101 "rootpath" "\0" /* DHCP_ROOT_PATH */
102 "ipttl" "\0" /* DHCP_IP_TTL */
103 "mtu" "\0" /* DHCP_MTU */
104 "broadcast" "\0" /* DHCP_BROADCAST */
105 "nisdomain" "\0" /* DHCP_NIS_DOMAIN */
106 "nissrv" "\0" /* DHCP_NIS_SERVER */
107 "ntpsrv" "\0" /* DHCP_NTP_SERVER */
108 "wins" "\0" /* DHCP_WINS_SERVER */
109 "lease" "\0" /* DHCP_LEASE_TIME */
110 "serverid" "\0" /* DHCP_SERVER_ID */
111 "message" "\0" /* DHCP_ERR_MESSAGE */
112 "tftp" "\0" /* DHCP_TFTP_SERVER_NAME */
113 "bootfile" "\0" /* DHCP_BOOT_FILE */
114 // "userclass" "\0" /* DHCP_USER_CLASS */
115 #if ENABLE_FEATURE_UDHCP_RFC3397
116 "search" "\0" /* DHCP_DOMAIN_SEARCH */
117 // doesn't work in udhcpd.conf since OPTION_SIP_SERVERS
118 // is not handled yet by "string->option" conversion code:
119 "sipsrv" "\0" /* DHCP_SIP_SERVERS */
121 // doesn't work in udhcpd.conf since OPTION_STATIC_ROUTES
122 // is not handled yet by "string->option" conversion code:
123 "staticroutes" "\0"/* DHCP_STATIC_ROUTES */
124 "routes" "\0" /* DHCP_ROUTES */
125 "msstaticroutes""\0"/* DHCP_MS_STATIC_ROUTES */
126 #if ENABLE_FEATURE_UDHCP_RFC5969
127 "6rd" "\0" /* DHCP_6RD */
128 "comcast6rd" "\0" /* DHCP_COMCAST_6RD */
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 #if ENABLE_FEATURE_UDHCP_RFC3397
147 [OPTION_DNS_STRING
] = 1, /* ignored by both udhcp_str2optset and xmalloc_optname_optval */
148 [OPTION_SIP_SERVERS
] = 1,
155 /* Just like OPTION_STRING, we use minimum length here */
156 [OPTION_STATIC_ROUTES
] = 5,
157 #if ENABLE_FEATURE_UDHCP_RFC5969
163 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
164 static void log_option(const char *pfx
, const uint8_t *opt
)
166 if (dhcp_verbose
>= 2) {
167 char buf
[256 * 2 + 2];
168 *bin2hex(buf
, (void*) (opt
+ OPT_DATA
), opt
[OPT_LEN
]) = '\0';
169 bb_info_msg("%s: 0x%02x %s", pfx
, opt
[OPT_CODE
], buf
);
173 # define log_option(pfx, opt) ((void)0)
176 unsigned FAST_FUNC
udhcp_option_idx(const char *name
)
178 int n
= index_in_strings(dhcp_option_strings
, name
);
183 char buf
[sizeof(dhcp_option_strings
)];
185 const char *s
= dhcp_option_strings
;
186 while (s
< dhcp_option_strings
+ sizeof(dhcp_option_strings
) - 2) {
187 *d
++ = (*s
== '\0' ? ' ' : *s
);
191 bb_error_msg_and_die("unknown option '%s', known options: %s", name
, buf
);
195 /* Get an option with bounds checking (warning, result is not aligned) */
196 uint8_t* FAST_FUNC
udhcp_get_option(struct dhcp_packet
*packet
, int code
)
203 FILE_FIELD101
= FILE_FIELD
* 0x101,
204 SNAME_FIELD101
= SNAME_FIELD
* 0x101,
207 /* option bytes: [code][len][data1][data2]..[dataLEN] */
208 optionptr
= packet
->options
;
209 rem
= sizeof(packet
->options
);
212 bb_error_msg("bad packet, malformed option field");
215 if (optionptr
[OPT_CODE
] == DHCP_PADDING
) {
220 if (optionptr
[OPT_CODE
] == DHCP_END
) {
221 if ((overload
& FILE_FIELD101
) == FILE_FIELD
) {
222 /* can use packet->file, and didn't look at it yet */
223 overload
|= FILE_FIELD101
; /* "we looked at it" */
224 optionptr
= packet
->file
;
225 rem
= sizeof(packet
->file
);
228 if ((overload
& SNAME_FIELD101
) == SNAME_FIELD
) {
229 /* can use packet->sname, and didn't look at it yet */
230 overload
|= SNAME_FIELD101
; /* "we looked at it" */
231 optionptr
= packet
->sname
;
232 rem
= sizeof(packet
->sname
);
237 len
= 2 + optionptr
[OPT_LEN
];
240 continue; /* complain and return NULL */
242 if (optionptr
[OPT_CODE
] == code
) {
243 log_option("Option found", optionptr
);
244 return optionptr
+ OPT_DATA
;
247 if (optionptr
[OPT_CODE
] == DHCP_OPTION_OVERLOAD
) {
248 overload
|= optionptr
[OPT_DATA
];
254 /* log3 because udhcpc uses it a lot - very noisy */
255 log3("Option 0x%02x not found", code
);
259 /* Return the position of the 'end' option (no bounds checking) */
260 int FAST_FUNC
udhcp_end_option(uint8_t *optionptr
)
264 while (optionptr
[i
] != DHCP_END
) {
265 if (optionptr
[i
] != DHCP_PADDING
)
266 i
+= optionptr
[i
+ OPT_LEN
] + OPT_DATA
-1;
272 /* Add an option (supplied in binary form) to the options.
273 * Option format: [code][len][data1][data2]..[dataLEN]
275 void FAST_FUNC
udhcp_add_binary_option(struct dhcp_packet
*packet
, uint8_t *addopt
)
278 uint8_t *optionptr
= packet
->options
;
279 unsigned end
= udhcp_end_option(optionptr
);
281 len
= OPT_DATA
+ addopt
[OPT_LEN
];
282 /* end position + (option code/length + addopt length) + end option */
283 if (end
+ len
+ 1 >= DHCP_OPTIONS_BUFSIZE
) {
284 //TODO: learn how to use overflow option if we exhaust packet->options[]
285 bb_error_msg("option 0x%02x did not fit into the packet",
289 log_option("Adding option", addopt
);
290 memcpy(optionptr
+ end
, addopt
, len
);
291 optionptr
[end
+ len
] = DHCP_END
;
294 /* Add an one to four byte option to a packet */
295 void FAST_FUNC
udhcp_add_simple_option(struct dhcp_packet
*packet
, uint8_t code
, uint32_t data
)
297 const struct dhcp_optflag
*dh
;
299 for (dh
= dhcp_optflags
; dh
->code
; dh
++) {
300 if (dh
->code
== code
) {
301 uint8_t option
[6], len
;
303 option
[OPT_CODE
] = code
;
304 len
= dhcp_option_lengths
[dh
->flags
& OPTION_TYPE_MASK
];
305 option
[OPT_LEN
] = len
;
307 data
<<= 8 * (4 - len
);
308 /* Assignment is unaligned! */
309 move_to_unaligned32(&option
[OPT_DATA
], data
);
310 udhcp_add_binary_option(packet
, option
);
315 bb_error_msg("can't add option 0x%02x", code
);
318 /* Find option 'code' in opt_list */
319 struct option_set
* FAST_FUNC
udhcp_find_option(struct option_set
*opt_list
, uint8_t code
)
321 while (opt_list
&& opt_list
->data
[OPT_CODE
] < code
)
322 opt_list
= opt_list
->next
;
324 if (opt_list
&& opt_list
->data
[OPT_CODE
] == code
)
329 /* Parse string to IP in network order */
330 int FAST_FUNC
udhcp_str2nip(const char *str
, void *arg
)
332 len_and_sockaddr
*lsa
;
334 lsa
= host_and_af2sockaddr(str
, 0, AF_INET
);
337 *(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 /* add space separator between STRING options in a list */
419 existing
->data
[OPT_DATA
+ old_len
] = ' ';
422 memcpy(existing
->data
+ OPT_DATA
+ old_len
, buffer
, length
);
423 existing
->data
[OPT_LEN
] = old_len
+ length
;
424 } /* else, ignore the data, we could put this in a second option in the future */
425 } /* else, ignore the new data */
431 int FAST_FUNC
udhcp_str2optset(const char *const_str
, void *arg
)
433 struct option_set
**opt_list
= arg
;
434 char *opt
, *val
, *endptr
;
436 const struct dhcp_optflag
*optflag
;
437 struct dhcp_optflag bin_optflag
;
440 char buffer
[8] ALIGNED(4);
441 uint16_t *result_u16
= (uint16_t *) buffer
;
442 uint32_t *result_u32
= (uint32_t *) buffer
;
444 /* Cheat, the only *const* str possible is "" */
445 str
= (char *) const_str
;
446 opt
= strtok(str
, " \t=");
450 optcode
= bb_strtou(opt
, NULL
, 0);
451 if (!errno
&& optcode
< 255) {
452 /* Raw (numeric) option code */
453 bin_optflag
.flags
= OPTION_BIN
;
454 bin_optflag
.code
= optcode
;
455 optflag
= &bin_optflag
;
457 optflag
= &dhcp_optflags
[udhcp_option_idx(opt
)];
462 val
= strtok(NULL
, ", \t");
465 length
= dhcp_option_lengths
[optflag
->flags
& OPTION_TYPE_MASK
];
467 opt
= buffer
; /* new meaning for variable opt */
468 switch (optflag
->flags
& OPTION_TYPE_MASK
) {
470 retval
= udhcp_str2nip(val
, buffer
);
473 retval
= udhcp_str2nip(val
, buffer
);
474 val
= strtok(NULL
, ", \t/-");
478 retval
= udhcp_str2nip(val
, buffer
+ 4);
481 #if ENABLE_FEATURE_UDHCP_RFC3397
482 case OPTION_DNS_STRING
:
484 length
= strnlen(val
, 254);
490 // case OPTION_BOOLEAN: {
491 // static const char no_yes[] ALIGN1 = "no\0yes\0";
492 // buffer[0] = retval = index_in_strings(no_yes, val);
493 // retval++; /* 0 - bad; 1: "no" 2: "yes" */
497 buffer
[0] = strtoul(val
, &endptr
, 0);
498 retval
= (endptr
[0] == '\0');
500 /* htonX are macros in older libc's, using temp var
501 * in code below for safety */
502 /* TODO: use bb_strtoX? */
504 unsigned long tmp
= strtoul(val
, &endptr
, 0);
505 *result_u16
= htons(tmp
);
506 retval
= (endptr
[0] == '\0' /*&& tmp < 0x10000*/);
509 // case OPTION_S16: {
510 // long tmp = strtol(val, &endptr, 0);
511 // *result_u16 = htons(tmp);
512 // retval = (endptr[0] == '\0');
516 unsigned long tmp
= strtoul(val
, &endptr
, 0);
517 *result_u32
= htonl(tmp
);
518 retval
= (endptr
[0] == '\0');
522 long tmp
= strtol(val
, &endptr
, 0);
523 *result_u32
= htonl(tmp
);
524 retval
= (endptr
[0] == '\0');
527 case OPTION_BIN
: /* handled in attach_option() */
534 attach_option(opt_list
, optflag
, opt
, length
);
535 } while (retval
&& optflag
->flags
& OPTION_LIST
);
540 /* note: ip is a pointer to an IPv6 in network order, possibly misaliged */
541 int FAST_FUNC
sprint_nip6(char *dest
, /*const char *pre,*/ const uint8_t *ip
)
543 char hexstrbuf
[16 * 2];
544 bin2hex(hexstrbuf
, (void*)ip
, 16);
545 return sprintf(dest
, /* "%s" */
546 "%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s",