1 /* vi: set sw=4 ts=4: */
2 /*
3 * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
4 *
5 * Licensed under GPLv2, see file LICENSE in this source tree.
6 */
7 #include "common.h"
8
9 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
10 unsigned dhcp_verbose;
11 #endif
12
13 const uint8_t MAC_BCAST_ADDR[6] ALIGN2 = {
14 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
15 };
16
17 #if ENABLE_UDHCPC || ENABLE_UDHCPD
18 /* Supported options are easily added here, they need to be sorted.
19 * See RFC2132 for more options.
20 * OPTION_REQ: these options are requested by udhcpc (unless -o).
21 */
22 const struct dhcp_optflag dhcp_optflags[] = {
23 /* flags code */
24 { OPTION_IP | OPTION_REQ, 0x01 }, /* DHCP_SUBNET */
25 { OPTION_S32 , 0x02 }, /* DHCP_TIME_OFFSET */
26 { OPTION_IP | OPTION_LIST | OPTION_REQ, 0x03 }, /* DHCP_ROUTER */
27 // { OPTION_IP | OPTION_LIST , 0x04 }, /* DHCP_TIME_SERVER */
28 // { OPTION_IP | OPTION_LIST , 0x05 }, /* DHCP_NAME_SERVER */
29 { OPTION_IP | OPTION_LIST | OPTION_REQ, 0x06 }, /* DHCP_DNS_SERVER */
30 // { OPTION_IP | OPTION_LIST , 0x07 }, /* DHCP_LOG_SERVER */
31 // { OPTION_IP | OPTION_LIST , 0x08 }, /* DHCP_COOKIE_SERVER */
32 { OPTION_IP | OPTION_LIST , 0x09 }, /* DHCP_LPR_SERVER */
33 { OPTION_STRING_HOST | OPTION_REQ, 0x0c }, /* DHCP_HOST_NAME */
34 { OPTION_U16 , 0x0d }, /* DHCP_BOOT_SIZE */
35 { OPTION_STRING_HOST | OPTION_REQ, 0x0f }, /* DHCP_DOMAIN_NAME */
36 { OPTION_IP , 0x10 }, /* DHCP_SWAP_SERVER */
37 { OPTION_STRING , 0x11 }, /* DHCP_ROOT_PATH */
38 { OPTION_U8 , 0x17 }, /* DHCP_IP_TTL */
39 { OPTION_U16 , 0x1a }, /* DHCP_MTU */
40 //TODO: why do we request DHCP_BROADCAST? Can't we assume that
41 //in the unlikely case it is different from typical N.N.255.255,
42 //server would let us know anyway?
43 { OPTION_IP | OPTION_REQ, 0x1c }, /* DHCP_BROADCAST */
44 { OPTION_IP_PAIR | OPTION_LIST , 0x21 }, /* DHCP_ROUTES */
45 { OPTION_STRING_HOST , 0x28 }, /* DHCP_NIS_DOMAIN */
46 { OPTION_IP | OPTION_LIST , 0x29 }, /* DHCP_NIS_SERVER */
47 { OPTION_IP | OPTION_LIST | OPTION_REQ, 0x2a }, /* DHCP_NTP_SERVER */
48 { OPTION_IP | OPTION_LIST , 0x2c }, /* DHCP_WINS_SERVER */
49 { OPTION_U32 , 0x33 }, /* DHCP_LEASE_TIME */
50 { OPTION_IP , 0x36 }, /* DHCP_SERVER_ID */
51 { OPTION_STRING , 0x38 }, /* DHCP_ERR_MESSAGE */
52 { OPTION_STRING , 0x3c }, /* DHCP_VENDOR */
53 //TODO: must be combined with 'sname' and 'file' handling:
54 { OPTION_STRING_HOST , 0x42 }, /* DHCP_TFTP_SERVER_NAME */
55 { OPTION_STRING , 0x43 }, /* DHCP_BOOT_FILE */
56 //TODO: not a string, but a set of LASCII strings:
57 // { OPTION_STRING , 0x4D }, /* DHCP_USER_CLASS */
58 { OPTION_STRING , 0x64 }, /* DHCP_PCODE */
59 { OPTION_STRING , 0x65 }, /* DHCP_TCODE */
60 #if ENABLE_FEATURE_UDHCP_RFC3397
61 { OPTION_DNS_STRING | OPTION_LIST , 0x77 }, /* DHCP_DOMAIN_SEARCH */
62 { OPTION_SIP_SERVERS , 0x78 }, /* DHCP_SIP_SERVERS */
63 #endif
64 { OPTION_STATIC_ROUTES | OPTION_LIST , 0x79 }, /* DHCP_STATIC_ROUTES */
65 #if ENABLE_FEATURE_UDHCP_8021Q
66 { OPTION_U16 , 0x84 }, /* DHCP_VLAN_ID */
67 { OPTION_U8 , 0x85 }, /* DHCP_VLAN_PRIORITY */
68 #endif
69 { OPTION_STRING , 0xd1 }, /* DHCP_PXE_CONF_FILE */
70 { OPTION_STRING , 0xd2 }, /* DHCP_PXE_PATH_PREFIX */
71 { OPTION_U32 , 0xd3 }, /* DHCP_REBOOT_TIME */
72 { OPTION_6RD , 0xd4 }, /* DHCP_6RD */
73 { OPTION_STATIC_ROUTES | OPTION_LIST , 0xf9 }, /* DHCP_MS_STATIC_ROUTES */
74 { OPTION_STRING , 0xfc }, /* DHCP_WPAD */
75
76 /* Options below have no match in dhcp_option_strings[],
77 * are not passed to dhcpc scripts, and cannot be specified
78 * with "option XXX YYY" syntax in dhcpd config file.
79 * These entries are only used internally by udhcp[cd]
80 * to correctly encode options into packets.
81 */
82
83 { OPTION_IP , 0x32 }, /* DHCP_REQUESTED_IP */
84 { OPTION_U8 , 0x35 }, /* DHCP_MESSAGE_TYPE */
85 { OPTION_U16 , 0x39 }, /* DHCP_MAX_SIZE */
86 //looks like these opts will work just fine even without these defs:
87 // /* not really a string: */
88 // { OPTION_STRING , 0x3d }, /* DHCP_CLIENT_ID */
89 { 0, 0 } /* zeroed terminating entry */
90 };
91
92 /* Used for converting options from incoming packets to env variables
93 * for udhcpc script, and for setting options for udhcpd via
94 * "opt OPTION_NAME OPTION_VALUE" directives in udhcpd.conf file.
95 */
96 /* Must match dhcp_optflags[] order */
97 const char dhcp_option_strings[] ALIGN1 =
98 "subnet" "\0" /* DHCP_SUBNET */
99 "timezone" "\0" /* DHCP_TIME_OFFSET */
100 "router" "\0" /* DHCP_ROUTER */
101 // "timesrv" "\0" /* DHCP_TIME_SERVER */
102 // "namesrv" "\0" /* DHCP_NAME_SERVER */
103 "dns" "\0" /* DHCP_DNS_SERVER */
104 // "logsrv" "\0" /* DHCP_LOG_SERVER */
105 // "cookiesrv" "\0" /* DHCP_COOKIE_SERVER */
106 "lprsrv" "\0" /* DHCP_LPR_SERVER */
107 "hostname" "\0" /* DHCP_HOST_NAME */
108 "bootsize" "\0" /* DHCP_BOOT_SIZE */
109 "domain" "\0" /* DHCP_DOMAIN_NAME */
110 "swapsrv" "\0" /* DHCP_SWAP_SERVER */
111 "rootpath" "\0" /* DHCP_ROOT_PATH */
112 "ipttl" "\0" /* DHCP_IP_TTL */
113 "mtu" "\0" /* DHCP_MTU */
114 "broadcast" "\0" /* DHCP_BROADCAST */
115 "routes" "\0" /* DHCP_ROUTES */
116 "nisdomain" "\0" /* DHCP_NIS_DOMAIN */
117 "nissrv" "\0" /* DHCP_NIS_SERVER */
118 "ntpsrv" "\0" /* DHCP_NTP_SERVER */
119 "wins" "\0" /* DHCP_WINS_SERVER */
120 "lease" "\0" /* DHCP_LEASE_TIME */
121 "serverid" "\0" /* DHCP_SERVER_ID */
122 "message" "\0" /* DHCP_ERR_MESSAGE */
123 "vendor" "\0" /* DHCP_VENDOR */
124 "tftp" "\0" /* DHCP_TFTP_SERVER_NAME*/
125 "bootfile" "\0" /* DHCP_BOOT_FILE */
126 // "userclass" "\0" /* DHCP_USER_CLASS */
127 "tzstr" "\0" /* DHCP_PCODE */
128 "tzdbstr" "\0" /* DHCP_TCODE */
129 #if ENABLE_FEATURE_UDHCP_RFC3397
130 "search" "\0" /* DHCP_DOMAIN_SEARCH */
131 // doesn't work in udhcpd.conf since OPTION_SIP_SERVERS
132 // is not handled yet by "string->option" conversion code:
133 "sipsrv" "\0" /* DHCP_SIP_SERVERS */
134 #endif
135 "staticroutes" "\0" /* DHCP_STATIC_ROUTES */
136 #if ENABLE_FEATURE_UDHCP_8021Q
137 "vlanid" "\0" /* DHCP_VLAN_ID */
138 "vlanpriority" "\0" /* DHCP_VLAN_PRIORITY */
139 #endif
140 "pxeconffile" "\0" /* DHCP_PXE_CONF_FILE */
141 "pxepathprefix" "\0" /* DHCP_PXE_PATH_PREFIX */
142 "reboottime" "\0" /* DHCP_REBOOT_TIME */
143 "ip6rd" "\0" /* DHCP_6RD */
144 "msstaticroutes" "\0" /* DHCP_MS_STATIC_ROUTES*/
145 "wpad" "\0" /* DHCP_WPAD */
146 ;
147 #endif
148
149 /* Lengths of the option types in binary form.
150 * Used by:
151 * udhcp_str2optset: to determine how many bytes to allocate.
152 * xmalloc_optname_optval: to estimate string length
153 * from binary option length: (option[LEN] / dhcp_option_lengths[opt_type])
154 * is the number of elements, multiply it by one element's string width
155 * (len_of_option_as_string[opt_type]) and you know how wide string you need.
156 */
157 const uint8_t dhcp_option_lengths[] ALIGN1 = {
158 [OPTION_IP] = 4,
159 [OPTION_IP_PAIR] = 8,
160 // [OPTION_BOOLEAN] = 1,
161 [OPTION_STRING] = 1, /* ignored by udhcp_str2optset */
162 [OPTION_STRING_HOST] = 1, /* ignored by udhcp_str2optset */
163 #if ENABLE_FEATURE_UDHCP_RFC3397
164 [OPTION_DNS_STRING] = 1, /* ignored by both udhcp_str2optset and xmalloc_optname_optval */
165 [OPTION_SIP_SERVERS] = 1,
166 #endif
167 [OPTION_U8] = 1,
168 [OPTION_U16] = 2,
169 // [OPTION_S16] = 2,
170 [OPTION_U32] = 4,
171 [OPTION_S32] = 4,
172 /* Just like OPTION_STRING, we use minimum length here */
173 [OPTION_STATIC_ROUTES] = 5,
174 [OPTION_6RD] = 12, /* ignored by udhcp_str2optset */
175 /* The above value was chosen as follows:
176 * len_of_option_as_string[] for this option is >60: it's a string of the form
177 * "32 128 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 255.255.255.255 ".
178 * Each additional ipv4 address takes 4 bytes in binary option and appends
179 * another "255.255.255.255 " 16-byte string. We can set [OPTION_6RD] = 4
180 * but this severely overestimates string length: instead of 16 bytes,
181 * it adds >60 for every 4 bytes in binary option.
182 * We cheat and declare here that option is in units of 12 bytes.
183 * This adds more than 60 bytes for every three ipv4 addresses - more than enough.
184 * (Even 16 instead of 12 should work, but let's be paranoid).
185 */
186 };
187
188 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
log1s(const char * msg)189 void FAST_FUNC log1s(const char *msg)
190 {
191 if (dhcp_verbose >= 1)
192 bb_simple_info_msg(msg);
193 }
194 #endif
195
196 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
log_option(const char * pfx,const uint8_t * opt)197 static void log_option(const char *pfx, const uint8_t *opt)
198 {
199 if (dhcp_verbose >= 2) {
200 char buf[256 * 2 + 2];
201 *bin2hex(buf, (void*) (opt + OPT_DATA), opt[OPT_LEN]) = '\0';
202 bb_info_msg("%s: 0x%02x %s", pfx, opt[OPT_CODE], buf);
203 }
204 }
205 #else
206 # define log_option(pfx, opt) ((void)0)
207 #endif
208
udhcp_option_idx(const char * name,const char * option_strings)209 unsigned FAST_FUNC udhcp_option_idx(const char *name, const char *option_strings)
210 {
211 int n = index_in_strings(option_strings, name);
212 if (n >= 0)
213 return n;
214
215 {
216 char *buf, *d;
217 const char *s;
218
219 s = option_strings;
220 while (*s)
221 s += strlen(s) + 1;
222
223 d = buf = xzalloc(s - option_strings);
224 s = option_strings;
225 while (!(*s == '\0' && s[1] == '\0')) {
226 *d++ = (*s == '\0' ? ' ' : *s);
227 s++;
228 }
229 bb_error_msg_and_die("unknown option '%s', known options: %s", name, buf);
230 }
231 }
232
233 /* Initialize state to be used between subsequent udhcp_scan_options calls */
init_scan_state(struct dhcp_packet * packet,struct dhcp_scan_state * scan_state)234 void FAST_FUNC init_scan_state(struct dhcp_packet *packet, struct dhcp_scan_state *scan_state)
235 {
236 scan_state->overload = 0;
237 scan_state->rem = sizeof(packet->options);
238 scan_state->optionptr = packet->options;
239 }
240
241 /* Iterate over packet's options, each call returning the next option.
242 * scan_state needs to be initialized with init_scan_state beforehand.
243 * Warning, result is not aligned. */
udhcp_scan_options(struct dhcp_packet * packet,struct dhcp_scan_state * scan_state)244 uint8_t* FAST_FUNC udhcp_scan_options(struct dhcp_packet *packet, struct dhcp_scan_state *scan_state)
245 {
246 int len;
247 enum {
248 FILE_FIELD101 = FILE_FIELD * 0x101,
249 SNAME_FIELD101 = SNAME_FIELD * 0x101,
250 };
251
252 /* option bytes: [code][len][data1][data2]..[dataLEN] */
253 while (1) {
254 if (scan_state->rem <= 0) {
255 complain:
256 bb_simple_error_msg("bad packet, malformed option field");
257 return NULL;
258 }
259
260 /* DHCP_PADDING and DHCP_END have no [len] byte */
261 if (scan_state->optionptr[OPT_CODE] == DHCP_PADDING) {
262 scan_state->rem--;
263 scan_state->optionptr++;
264 continue;
265 }
266 if (scan_state->optionptr[OPT_CODE] == DHCP_END) {
267 if ((scan_state->overload & FILE_FIELD101) == FILE_FIELD) {
268 /* can use packet->file, and didn't look at it yet */
269 scan_state->overload |= FILE_FIELD101; /* "we looked at it" */
270 scan_state->optionptr = packet->file;
271 scan_state->rem = sizeof(packet->file);
272 continue;
273 }
274 if ((scan_state->overload & SNAME_FIELD101) == SNAME_FIELD) {
275 /* can use packet->sname, and didn't look at it yet */
276 scan_state->overload |= SNAME_FIELD101; /* "we looked at it" */
277 scan_state->optionptr = packet->sname;
278 scan_state->rem = sizeof(packet->sname);
279 continue;
280 }
281 break;
282 }
283
284 if (scan_state->rem <= OPT_LEN) /* [len] byte exists? */
285 goto complain; /* no, complain and return NULL */
286 len = scan_state->optionptr[OPT_LEN];
287 /* Skip options with zero length.
288 * Users report that DHCP server on a TrendNet router (unknown model)
289 * provides a zero-length option 12 (Host Name)
290 * (this violates RFC 2132 section 3.14).
291 */
292 if (len == 0) {
293 scan_state->rem -= 2;
294 scan_state->optionptr += 2;
295 continue;
296 }
297 len += 2;
298 scan_state->rem -= len;
299 if (scan_state->rem < 0) /* option is longer than options field? */
300 goto complain; /* yes, complain and return NULL */
301
302 if (scan_state->optionptr[OPT_CODE] == DHCP_OPTION_OVERLOAD) {
303 /* len is known to be >= 3 now, [data] byte exists */
304 scan_state->overload |= scan_state->optionptr[OPT_DATA];
305 } else {
306 uint8_t *return_ptr = scan_state->optionptr;
307 scan_state->optionptr += len;
308 return return_ptr;
309 }
310 scan_state->optionptr += len;
311 }
312
313 return NULL;
314 }
315
316 /* Get an option with bounds checking (warning, result is not aligned) */
udhcp_get_option(struct dhcp_packet * packet,int code)317 uint8_t* FAST_FUNC udhcp_get_option(struct dhcp_packet *packet, int code)
318 {
319 uint8_t *optptr;
320 struct dhcp_scan_state scan_state;
321
322 init_scan_state(packet, &scan_state);
323 while ((optptr = udhcp_scan_options(packet, &scan_state)) != NULL) {
324 if (optptr[OPT_CODE] == code) {
325 log_option("option found", optptr);
326 return optptr + OPT_DATA;
327 }
328 }
329
330 /* log3 because udhcpc uses it a lot - very noisy */
331 log3("option 0x%02x not found", code);
332 return NULL;
333 }
334
udhcp_get_option32(struct dhcp_packet * packet,int code)335 uint8_t* FAST_FUNC udhcp_get_option32(struct dhcp_packet *packet, int code)
336 {
337 uint8_t *r = udhcp_get_option(packet, code);
338 if (r) {
339 if (r[-OPT_DATA + OPT_LEN] != 4)
340 r = NULL;
341 }
342 return r;
343 }
344
345 /* Return the position of the 'end' option (no bounds checking) */
udhcp_end_option(uint8_t * optionptr)346 int FAST_FUNC udhcp_end_option(uint8_t *optionptr)
347 {
348 int i = 0;
349
350 while (optionptr[i] != DHCP_END) {
351 if (optionptr[i] != DHCP_PADDING)
352 i += optionptr[i + OPT_LEN] + OPT_DATA-1;
353 i++;
354 }
355 return i;
356 }
357
358 /* Add an option (supplied in binary form) to the options.
359 * Option format: [code][len][data1][data2]..[dataLEN]
360 */
udhcp_add_binary_option(struct dhcp_packet * packet,uint8_t * addopt)361 void FAST_FUNC udhcp_add_binary_option(struct dhcp_packet *packet, uint8_t *addopt)
362 {
363 unsigned len;
364 uint8_t *optionptr = packet->options;
365 unsigned end = udhcp_end_option(optionptr);
366
367 len = OPT_DATA + addopt[OPT_LEN];
368 /* end position + (option code/length + addopt length) + end option */
369 if (end + len + 1 >= DHCP_OPTIONS_BUFSIZE) {
370 //TODO: learn how to use overflow option if we exhaust packet->options[]
371 bb_error_msg("option 0x%02x did not fit into the packet",
372 addopt[OPT_CODE]);
373 return;
374 }
375 log_option("adding option", addopt);
376 memcpy(optionptr + end, addopt, len);
377 optionptr[end + len] = DHCP_END;
378 }
379
380 #if ENABLE_UDHCPC || ENABLE_UDHCPD
381 /* Add an one to four byte option to a packet */
udhcp_add_simple_option(struct dhcp_packet * packet,uint8_t code,uint32_t data)382 void FAST_FUNC udhcp_add_simple_option(struct dhcp_packet *packet, uint8_t code, uint32_t data)
383 {
384 const struct dhcp_optflag *dh;
385
386 for (dh = dhcp_optflags; dh->code; dh++) {
387 if (dh->code == code) {
388 uint8_t option[6], len;
389
390 option[OPT_CODE] = code;
391 len = dhcp_option_lengths[dh->flags & OPTION_TYPE_MASK];
392 option[OPT_LEN] = len;
393 if (BB_BIG_ENDIAN)
394 data <<= 8 * (4 - len);
395 /* Assignment is unaligned! */
396 move_to_unaligned32(&option[OPT_DATA], data);
397 udhcp_add_binary_option(packet, option);
398 return;
399 }
400 }
401
402 bb_error_msg("can't add option 0x%02x", code);
403 }
404 #endif
405
406 /* Find option 'code' in opt_list */
udhcp_find_option(struct option_set * opt_list,uint8_t code,bool dhcpv6)407 struct option_set* FAST_FUNC udhcp_find_option(struct option_set *opt_list, uint8_t code, bool dhcpv6)
408 {
409 IF_NOT_UDHCPC6(bool dhcpv6 = 0;)
410 uint8_t cur_code;
411
412 for (;;) {
413 if (!opt_list)
414 return opt_list; /* NULL */
415 if (!dhcpv6) {
416 cur_code = opt_list->data[OPT_CODE];
417 } else {
418 //FIXME: add support for code > 0xff
419 if (opt_list->data[D6_OPT_CODE] != 0)
420 return NULL;
421 cur_code = opt_list->data[D6_OPT_CODE + 1];
422 }
423 if (cur_code >= code) {
424 if (cur_code == code)
425 return opt_list;
426 return NULL;
427 }
428 opt_list = opt_list->next;
429 }
430 }
431
432 /* Parse string to IP in network order */
udhcp_str2nip(const char * str,void * arg)433 int FAST_FUNC udhcp_str2nip(const char *str, void *arg)
434 {
435 len_and_sockaddr *lsa;
436
437 lsa = host_and_af2sockaddr(str, 0, AF_INET);
438 if (!lsa)
439 return 0;
440 /* arg maybe unaligned */
441 move_to_unaligned32((uint32_t*)arg, lsa->u.sin.sin_addr.s_addr);
442 free(lsa);
443 return 1;
444 }
445
udhcp_insert_new_option(struct option_set ** opt_list,unsigned code,unsigned length,bool dhcpv6)446 void* FAST_FUNC udhcp_insert_new_option(
447 struct option_set **opt_list,
448 unsigned code,
449 unsigned length,
450 bool dhcpv6)
451 {
452 IF_NOT_UDHCPC6(bool dhcpv6 = 0;)
453 struct option_set *new, **curr;
454
455 log2("attaching option %02x to list", code);
456 new = xmalloc(sizeof(*new));
457 if (!dhcpv6) {
458 new->data = xzalloc(length + OPT_DATA);
459 new->data[OPT_CODE] = code;
460 new->data[OPT_LEN] = length;
461 } else {
462 new->data = xzalloc(length + D6_OPT_DATA);
463 new->data[D6_OPT_CODE] = code >> 8;
464 new->data[D6_OPT_CODE + 1] = code & 0xff;
465 new->data[D6_OPT_LEN] = length >> 8;
466 new->data[D6_OPT_LEN + 1] = length & 0xff;
467 }
468
469 curr = opt_list;
470 //FIXME: DHCP6 codes > 255!!
471 while (*curr && (*curr)->data[OPT_CODE] < code)
472 curr = &(*curr)->next;
473
474 new->next = *curr;
475 *curr = new;
476
477 return new->data;
478 }
479
480 /* udhcp_str2optset:
481 * Parse string option representation to binary form and add it to opt_list.
482 * Called to parse "udhcpc -x OPTNAME:OPTVAL"
483 * and to parse udhcpd.conf's "opt OPTNAME OPTVAL" directives.
484 */
485 /* helper: add an option to the opt_list */
486 #if !ENABLE_UDHCPC6
487 #define attach_option(opt_list, optflag, buffer, length, dhcpv6) \
488 attach_option(opt_list, optflag, buffer, length)
489 #endif
attach_option(struct option_set ** opt_list,const struct dhcp_optflag * optflag,char * buffer,int length,bool dhcpv6)490 static NOINLINE void attach_option(
491 struct option_set **opt_list,
492 const struct dhcp_optflag *optflag,
493 char *buffer,
494 int length,
495 bool dhcpv6)
496 {
497 IF_NOT_UDHCPC6(bool dhcpv6 = 0;)
498 struct option_set *existing;
499 char *allocated = NULL;
500
501 if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_BIN) {
502 const char *end;
503 allocated = xstrdup(buffer); /* more than enough */
504 end = hex2bin(allocated, buffer, 255);
505 if (errno)
506 bb_error_msg_and_die("malformed hex string '%s'", buffer);
507 length = end - allocated;
508 buffer = allocated;
509 }
510 #if ENABLE_FEATURE_UDHCP_RFC3397
511 if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_DNS_STRING) {
512 /* reuse buffer and length for RFC1035-formatted string */
513 allocated = buffer = (char *)dname_enc(/*NULL, 0,*/ buffer, &length);
514 }
515 #endif
516
517 existing = udhcp_find_option(*opt_list, optflag->code, dhcpv6);
518 if (!existing) {
519 /* make a new option */
520 uint8_t *p = udhcp_insert_new_option(opt_list, optflag->code, length, dhcpv6);
521 if (!dhcpv6)
522 memcpy(p + OPT_DATA, buffer, length);
523 else
524 memcpy(p + D6_OPT_DATA, buffer, length);
525 goto ret;
526 }
527
528 if (optflag->flags & OPTION_LIST) {
529 unsigned old_len;
530
531 /* add it to an existing option */
532 log2("attaching option %02x to existing member of list", optflag->code);
533 old_len = existing->data[OPT_LEN];
534 if (old_len + length < 255) {
535 /* actually 255 is ok too, but adding a space can overlow it */
536
537 existing->data = xrealloc(existing->data, OPT_DATA + 1 + old_len + length);
538 // So far dhcp_optflags[] has no OPTION_STRING[_HOST] | OPTION_LIST items
539 #if 0
540 if ((optflag->flags & OPTION_TYPE_MASK) == OPTION_STRING
541 || (optflag->flags & OPTION_TYPE_MASK) == OPTION_STRING_HOST
542 ) {
543 /* add space separator between STRING options in a list */
544 existing->data[OPT_DATA + old_len] = ' ';
545 old_len++;
546 }
547 #endif
548
549 memcpy(existing->data + OPT_DATA + old_len, buffer, length);
550 existing->data[OPT_LEN] = old_len + length;
551 } /* else, ignore the data, we could put this in a second option in the future */
552 } /* else, ignore the new data */
553
554 ret:
555 free(allocated);
556 }
557
udhcp_str2optset(const char * const_str,void * arg,const struct dhcp_optflag * optflags,const char * option_strings,bool dhcpv6)558 int FAST_FUNC udhcp_str2optset(const char *const_str, void *arg,
559 const struct dhcp_optflag *optflags, const char *option_strings,
560 bool dhcpv6)
561 {
562 struct option_set **opt_list = arg;
563 char *opt;
564 char *str;
565 const struct dhcp_optflag *optflag;
566 struct dhcp_optflag userdef_optflag;
567 unsigned optcode;
568 int retval;
569 /* IP_PAIR needs 8 bytes, STATIC_ROUTES needs 9 max */
570 char buffer[9] ALIGNED(4);
571 uint16_t *result_u16 = (uint16_t *) buffer;
572 uint32_t *result_u32 = (uint32_t *) buffer;
573
574 /* Cheat, the only *const* str possible is "" */
575 str = (char *) const_str;
576 opt = strtok_r(str, " \t=:", &str);
577 if (!opt)
578 return 0;
579
580 optcode = bb_strtou(opt, NULL, 0);
581 if (!errno && optcode < 255) {
582 /* Raw (numeric) option code.
583 * Initially assume binary (hex-str), but if "str" or 'str'
584 * is seen later, switch to STRING.
585 */
586 userdef_optflag.flags = OPTION_BIN;
587 userdef_optflag.code = optcode;
588 optflag = &userdef_optflag;
589 } else {
590 optflag = &optflags[udhcp_option_idx(opt, option_strings)];
591 }
592
593 /* Loop to handle OPTION_LIST case, else execute just once */
594 retval = 0;
595 do {
596 int length;
597 char *val;
598
599 if (optflag->flags == OPTION_BIN) {
600 val = strtok_r(NULL, "", &str); /* do not split "'q w e'" */
601 if (val) trim(val);
602 } else
603 val = strtok_r(NULL, ", \t", &str);
604 if (!val)
605 break;
606
607 length = dhcp_option_lengths[optflag->flags & OPTION_TYPE_MASK];
608 retval = 0;
609 opt = buffer; /* new meaning for variable opt */
610
611 switch (optflag->flags & OPTION_TYPE_MASK) {
612 case OPTION_IP:
613 retval = udhcp_str2nip(val, buffer);
614 break;
615 case OPTION_IP_PAIR:
616 retval = udhcp_str2nip(val, buffer);
617 val = strtok_r(NULL, ", \t/-", &str);
618 if (!val)
619 retval = 0;
620 if (retval)
621 retval = udhcp_str2nip(val, buffer + 4);
622 break;
623 case_OPTION_STRING:
624 case OPTION_STRING:
625 case OPTION_STRING_HOST:
626 #if ENABLE_FEATURE_UDHCP_RFC3397
627 case OPTION_DNS_STRING:
628 #endif
629 length = strnlen(val, 254);
630 if (length > 0) {
631 opt = val;
632 retval = 1;
633 }
634 break;
635 // case OPTION_BOOLEAN: {
636 // static const char no_yes[] ALIGN1 = "no\0yes\0";
637 // buffer[0] = retval = index_in_strings(no_yes, val);
638 // retval++; /* 0 - bad; 1: "no" 2: "yes" */
639 // break;
640 // }
641 case OPTION_U8:
642 buffer[0] = bb_strtou32(val, NULL, 0);
643 retval = (errno == 0);
644 break;
645 /* htonX are macros in older libc's, using temp var
646 * in code below for safety */
647 /* TODO: use bb_strtoX? */
648 case OPTION_U16: {
649 uint32_t tmp = bb_strtou32(val, NULL, 0);
650 *result_u16 = htons(tmp);
651 retval = (errno == 0 /*&& tmp < 0x10000*/);
652 break;
653 }
654 // case OPTION_S16: {
655 // long tmp = bb_strtoi32(val, NULL, 0);
656 // *result_u16 = htons(tmp);
657 // retval = (errno == 0);
658 // break;
659 // }
660 case OPTION_U32: {
661 uint32_t tmp = bb_strtou32(val, NULL, 0);
662 *result_u32 = htonl(tmp);
663 retval = (errno == 0);
664 break;
665 }
666 case OPTION_S32: {
667 int32_t tmp = bb_strtoi32(val, NULL, 0);
668 *result_u32 = htonl(tmp);
669 retval = (errno == 0);
670 break;
671 }
672 case OPTION_STATIC_ROUTES: {
673 /* Input: "a.b.c.d/m" */
674 /* Output: mask(1 byte),pfx(0-4 bytes),gw(4 bytes) */
675 unsigned mask;
676 char *slash = strchr(val, '/');
677 if (slash) {
678 *slash = '\0';
679 retval = udhcp_str2nip(val, buffer + 1);
680 buffer[0] = mask = bb_strtou(slash + 1, NULL, 10);
681 val = strtok_r(NULL, ", \t/-", &str);
682 if (!val || mask > 32 || errno)
683 retval = 0;
684 if (retval) {
685 length = ((mask + 7) >> 3) + 5;
686 retval = udhcp_str2nip(val, buffer + (length - 4));
687 }
688 }
689 break;
690 }
691 case OPTION_BIN:
692 /* Raw (numeric) option code. Is it a string? */
693 if (val[0] == '"' || val[0] == '\'') {
694 char delim = val[0];
695 char *end = last_char_is(val + 1, delim);
696 if (end) {
697 *end = '\0';
698 val++;
699 userdef_optflag.flags = OPTION_STRING;
700 goto case_OPTION_STRING;
701 }
702 }
703 /* No: hex-str option, handled in attach_option() */
704 opt = val;
705 retval = 1;
706 break;
707 default:
708 break;
709 }
710
711 if (retval)
712 attach_option(opt_list, optflag, opt, length, dhcpv6);
713 } while (retval && (optflag->flags & OPTION_LIST));
714
715 return retval;
716 }
717
718 /* note: ip is a pointer to an IPv6 in network order, possibly misaliged */
sprint_nip6(char * dest,const uint8_t * ip)719 int FAST_FUNC sprint_nip6(char *dest, /*const char *pre,*/ const uint8_t *ip)
720 {
721 char hexstrbuf[16 * 2];
722 bin2hex(hexstrbuf, (void*)ip, 16);
723 return sprintf(dest, /* "%s" */
724 "%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s:%.4s",
725 /* pre, */
726 hexstrbuf + 0 * 4,
727 hexstrbuf + 1 * 4,
728 hexstrbuf + 2 * 4,
729 hexstrbuf + 3 * 4,
730 hexstrbuf + 4 * 4,
731 hexstrbuf + 5 * 4,
732 hexstrbuf + 6 * 4,
733 hexstrbuf + 7 * 4
734 );
735 }
736