1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <errno.h>
31 #include <stdarg.h>
32 #include <limits.h>
33 #include <ctype.h>
34 #include <libgen.h>
35 #include <sys/isa_defs.h>
36 #include <sys/socket.h>
37 #include <net/if_arp.h>
38 #include <netinet/in.h>
39 #include <arpa/inet.h>
40 #include <sys/sysmacros.h>
41 #include <libinetutil.h>
42 #include <libdlpi.h>
43 #include <netinet/dhcp6.h>
44
45 #include "dhcp_symbol.h"
46 #include "dhcp_inittab.h"
47
48 static void inittab_msg(const char *, ...);
49 static uchar_t category_to_code(const char *);
50 static boolean_t encode_number(uint8_t, uint8_t, boolean_t, uint8_t,
51 const char *, uint8_t *, int *);
52 static boolean_t decode_number(uint8_t, uint8_t, boolean_t, uint8_t,
53 const uint8_t *, char *, int *);
54 static dhcp_symbol_t *inittab_lookup(uchar_t, char, const char *, int32_t,
55 size_t *);
56 static dsym_category_t itabcode_to_dsymcode(uchar_t);
57 static boolean_t parse_entry(char *, char **);
58
59 /*
60 * forward declaration of our internal inittab_table[]. too bulky to put
61 * up front -- check the end of this file for its definition.
62 *
63 * Note: we have only an IPv4 version here. The inittab_verify() function is
64 * used by the DHCP server and manager. We'll need a new function if the
65 * server is extended to DHCPv6.
66 */
67 static dhcp_symbol_t inittab_table[];
68
69 /*
70 * the number of fields in the inittab and names for the fields. note that
71 * this order is meaningful to parse_entry(); other functions should just
72 * use them as indexes into the array returned from parse_entry().
73 */
74 #define ITAB_FIELDS 7
75 enum { ITAB_NAME, ITAB_CODE, ITAB_TYPE, ITAB_GRAN, ITAB_MAX, ITAB_CONS,
76 ITAB_CAT };
77
78 /*
79 * the category_map_entry_t is used to map the inittab category codes to
80 * the dsym codes. the reason the codes are different is that the inittab
81 * needs to have the codes be ORable such that queries can retrieve more
82 * than one category at a time. this map is also used to map the inittab
83 * string representation of a category to its numerical code.
84 */
85 typedef struct category_map_entry {
86 dsym_category_t cme_dsymcode;
87 char *cme_name;
88 uchar_t cme_itabcode;
89 } category_map_entry_t;
90
91 static category_map_entry_t category_map[] = {
92 { DSYM_STANDARD, "STANDARD", ITAB_CAT_STANDARD },
93 { DSYM_FIELD, "FIELD", ITAB_CAT_FIELD },
94 { DSYM_INTERNAL, "INTERNAL", ITAB_CAT_INTERNAL },
95 { DSYM_VENDOR, "VENDOR", ITAB_CAT_VENDOR },
96 { DSYM_SITE, "SITE", ITAB_CAT_SITE }
97 };
98
99 /*
100 * inittab_load(): returns all inittab entries with the specified criteria
101 *
102 * input: uchar_t: the categories the consumer is interested in
103 * char: the consumer type of the caller
104 * size_t *: set to the number of entries returned
105 * output: dhcp_symbol_t *: an array of dynamically allocated entries
106 * on success, NULL upon failure
107 */
108
109 dhcp_symbol_t *
110 inittab_load(uchar_t categories, char consumer, size_t *n_entries)
111 {
112 return (inittab_lookup(categories, consumer, NULL, -1, n_entries));
113 }
114
115 /*
116 * inittab_getbyname(): returns an inittab entry with the specified criteria
117 *
118 * input: int: the categories the consumer is interested in
119 * char: the consumer type of the caller
120 * char *: the name of the inittab entry the consumer wants
121 * output: dhcp_symbol_t *: a dynamically allocated dhcp_symbol structure
122 * on success, NULL upon failure
123 */
124
125 dhcp_symbol_t *
126 inittab_getbyname(uchar_t categories, char consumer, const char *name)
127 {
128 return (inittab_lookup(categories, consumer, name, -1, NULL));
129 }
130
131 /*
132 * inittab_getbycode(): returns an inittab entry with the specified criteria
133 *
134 * input: uchar_t: the categories the consumer is interested in
135 * char: the consumer type of the caller
136 * uint16_t: the code of the inittab entry the consumer wants
137 * output: dhcp_symbol_t *: a dynamically allocated dhcp_symbol structure
138 * on success, NULL upon failure
139 */
140
141 dhcp_symbol_t *
142 inittab_getbycode(uchar_t categories, char consumer, uint16_t code)
143 {
144 return (inittab_lookup(categories, consumer, NULL, code, NULL));
145 }
146
147 /*
148 * inittab_lookup(): returns inittab entries with the specified criteria
149 *
150 * input: uchar_t: the categories the consumer is interested in
151 * char: the consumer type of the caller
152 * const char *: the name of the entry the caller is interested
153 * in, or NULL if the caller doesn't care
154 * int32_t: the code the caller is interested in, or -1 if the
155 * caller doesn't care
156 * size_t *: set to the number of entries returned
157 * output: dhcp_symbol_t *: dynamically allocated dhcp_symbol structures
158 * on success, NULL upon failure
159 */
160
161 static dhcp_symbol_t *
162 inittab_lookup(uchar_t categories, char consumer, const char *name,
163 int32_t code, size_t *n_entriesp)
164 {
165 FILE *inittab_fp;
166 dhcp_symbol_t *new_entries, *entries = NULL;
167 dhcp_symbol_t entry;
168 char buffer[ITAB_MAX_LINE_LEN];
169 char *fields[ITAB_FIELDS];
170 unsigned long line = 0;
171 size_t i, n_entries = 0;
172 const char *inittab_path;
173 uchar_t category_code;
174 dsym_cdtype_t type;
175
176 if (categories & ITAB_CAT_V6) {
177 inittab_path = getenv("DHCP_INITTAB6_PATH");
178 if (inittab_path == NULL)
179 inittab_path = ITAB_INITTAB6_PATH;
180 } else {
181 inittab_path = getenv("DHCP_INITTAB_PATH");
182 if (inittab_path == NULL)
183 inittab_path = ITAB_INITTAB_PATH;
184 }
185
186 inittab_fp = fopen(inittab_path, "r");
187 if (inittab_fp == NULL) {
188 inittab_msg("inittab_lookup: fopen: %s: %s",
189 inittab_path, strerror(errno));
190 return (NULL);
191 }
192
193 (void) bufsplit(",\n", 0, NULL);
194 while (fgets(buffer, sizeof (buffer), inittab_fp) != NULL) {
195
196 line++;
197
198 /*
199 * make sure the string didn't overflow our buffer
200 */
201 if (strchr(buffer, '\n') == NULL) {
202 inittab_msg("inittab_lookup: line %li: too long, "
203 "skipping", line);
204 continue;
205 }
206
207 /*
208 * skip `pure comment' lines
209 */
210 for (i = 0; buffer[i] != '\0'; i++)
211 if (isspace(buffer[i]) == 0)
212 break;
213
214 if (buffer[i] == ITAB_COMMENT_CHAR || buffer[i] == '\0')
215 continue;
216
217 /*
218 * parse the entry out into fields.
219 */
220 if (parse_entry(buffer, fields) == B_FALSE) {
221 inittab_msg("inittab_lookup: line %li: syntax error, "
222 "skipping", line);
223 continue;
224 }
225
226 /*
227 * validate the values in the entries; skip if invalid.
228 */
229 if (atoi(fields[ITAB_GRAN]) > ITAB_GRAN_MAX) {
230 inittab_msg("inittab_lookup: line %li: granularity `%s'"
231 " out of range, skipping", line, fields[ITAB_GRAN]);
232 continue;
233 }
234
235 if (atoi(fields[ITAB_MAX]) > ITAB_MAX_MAX) {
236 inittab_msg("inittab_lookup: line %li: maximum `%s' "
237 "out of range, skipping", line, fields[ITAB_MAX]);
238 continue;
239 }
240
241 if (dsym_get_type_id(fields[ITAB_TYPE], &type, B_FALSE) !=
242 DSYM_SUCCESS) {
243 inittab_msg("inittab_lookup: line %li: type `%s' "
244 "is invalid, skipping", line, fields[ITAB_TYPE]);
245 continue;
246 }
247
248 /*
249 * find out whether this entry of interest to our consumer,
250 * and if so, throw it onto the set of entries we'll return.
251 * check categories last since it's the most expensive check.
252 */
253 if (strchr(fields[ITAB_CONS], consumer) == NULL)
254 continue;
255
256 if (code != -1 && atoi(fields[ITAB_CODE]) != code)
257 continue;
258
259 if (name != NULL && strcasecmp(fields[ITAB_NAME], name) != 0)
260 continue;
261
262 category_code = category_to_code(fields[ITAB_CAT]);
263 if ((category_code & categories) == 0)
264 continue;
265
266 /*
267 * looks like a match. allocate an entry and fill it in
268 */
269 new_entries = realloc(entries, (n_entries + 1) *
270 sizeof (dhcp_symbol_t));
271
272 /*
273 * if we run out of memory, might as well return what we can
274 */
275 if (new_entries == NULL) {
276 inittab_msg("inittab_lookup: ran out of memory "
277 "allocating dhcp_symbol_t's");
278 break;
279 }
280
281 entry.ds_max = atoi(fields[ITAB_MAX]);
282 entry.ds_code = atoi(fields[ITAB_CODE]);
283 entry.ds_type = type;
284 entry.ds_gran = atoi(fields[ITAB_GRAN]);
285 entry.ds_category = itabcode_to_dsymcode(category_code);
286 entry.ds_classes.dc_cnt = 0;
287 entry.ds_classes.dc_names = NULL;
288 (void) strlcpy(entry.ds_name, fields[ITAB_NAME],
289 sizeof (entry.ds_name));
290 entry.ds_dhcpv6 = (categories & ITAB_CAT_V6) ? 1 : 0;
291
292 entries = new_entries;
293 entries[n_entries++] = entry;
294 }
295
296 if (ferror(inittab_fp) != 0) {
297 inittab_msg("inittab_lookup: error on inittab stream");
298 clearerr(inittab_fp);
299 }
300
301 (void) fclose(inittab_fp);
302
303 if (n_entriesp != NULL)
304 *n_entriesp = n_entries;
305
306 return (entries);
307 }
308
309 /*
310 * parse_entry(): parses an entry out into its constituent fields
311 *
312 * input: char *: the entry
313 * char **: an array of ITAB_FIELDS length which contains
314 * pointers into the entry on upon return
315 * output: boolean_t: B_TRUE on success, B_FALSE on failure
316 */
317
318 static boolean_t
319 parse_entry(char *entry, char **fields)
320 {
321 char *category, *spacep;
322 size_t n_fields, i;
323
324 /*
325 * due to a mistake made long ago, the first and second fields of
326 * each entry are not separated by a comma, but rather by
327 * whitespace -- have bufsplit() treat the two fields as one, then
328 * pull them apart afterwards.
329 */
330 n_fields = bufsplit(entry, ITAB_FIELDS - 1, fields);
331 if (n_fields != (ITAB_FIELDS - 1))
332 return (B_FALSE);
333
334 /*
335 * pull the first and second fields apart. this is complicated
336 * since the first field can contain embedded whitespace (so we
337 * must separate the two fields by the last span of whitespace).
338 *
339 * first, find the initial span of whitespace. if there isn't one,
340 * then the entry is malformed.
341 */
342 category = strpbrk(fields[ITAB_NAME], " \t");
343 if (category == NULL)
344 return (B_FALSE);
345
346 /*
347 * find the last span of whitespace.
348 */
349 do {
350 while (isspace(*category))
351 category++;
352
353 spacep = strpbrk(category, " \t");
354 if (spacep != NULL)
355 category = spacep;
356 } while (spacep != NULL);
357
358 /*
359 * NUL-terminate the first byte of the last span of whitespace, so
360 * that the first field doesn't have any residual trailing
361 * whitespace.
362 */
363 spacep = category - 1;
364 while (isspace(*spacep))
365 spacep--;
366
367 if (spacep <= fields[0])
368 return (B_FALSE);
369
370 *++spacep = '\0';
371
372 /*
373 * remove any whitespace from the fields.
374 */
375 for (i = 0; i < n_fields; i++) {
376 while (isspace(*fields[i]))
377 fields[i]++;
378 }
379 fields[ITAB_CAT] = category;
380
381 return (B_TRUE);
382 }
383
384 /*
385 * inittab_verify(): verifies that a given inittab entry matches an internal
386 * definition
387 *
388 * input: dhcp_symbol_t *: the inittab entry to verify
389 * dhcp_symbol_t *: if non-NULL, a place to store the internal
390 * inittab entry upon return
391 * output: int: ITAB_FAILURE, ITAB_SUCCESS, or ITAB_UNKNOWN
392 *
393 * notes: IPv4 only
394 */
395
396 int
397 inittab_verify(const dhcp_symbol_t *inittab_ent, dhcp_symbol_t *internal_ent)
398 {
399 unsigned int i;
400
401 for (i = 0; inittab_table[i].ds_name[0] != '\0'; i++) {
402
403 if (inittab_ent->ds_category != inittab_table[i].ds_category)
404 continue;
405
406 if (inittab_ent->ds_code == inittab_table[i].ds_code) {
407 if (internal_ent != NULL)
408 *internal_ent = inittab_table[i];
409
410 if (inittab_table[i].ds_type != inittab_ent->ds_type ||
411 inittab_table[i].ds_gran != inittab_ent->ds_gran ||
412 inittab_table[i].ds_max != inittab_ent->ds_max)
413 return (ITAB_FAILURE);
414
415 return (ITAB_SUCCESS);
416 }
417 }
418
419 return (ITAB_UNKNOWN);
420 }
421
422 /*
423 * get_hw_type(): interpret ",hwtype" in the input string, as part of a DUID.
424 * The hwtype string is optional, and must be 0-65535 if
425 * present.
426 *
427 * input: char **: pointer to string pointer
428 * int *: error return value
429 * output: int: hardware type, or -1 for empty, or -2 for error.
430 */
431
432 static int
433 get_hw_type(char **strp, int *ierrnop)
434 {
435 char *str = *strp;
436 ulong_t hwtype;
437
438 if (*str++ != ',') {
439 *ierrnop = ITAB_BAD_NUMBER;
440 return (-2);
441 }
442 if (*str == ',' || *str == '\0') {
443 *strp = str;
444 return (-1);
445 }
446 hwtype = strtoul(str, strp, 0);
447 if (errno != 0 || *strp == str || hwtype > 65535) {
448 *ierrnop = ITAB_BAD_NUMBER;
449 return (-2);
450 } else {
451 return ((int)hwtype);
452 }
453 }
454
455 /*
456 * get_mac_addr(): interpret ",macaddr" in the input string, as part of a DUID.
457 * The 'macaddr' may be a hex string (in any standard format),
458 * or the name of a physical interface. If an interface name
459 * is given, then the interface type is extracted as well.
460 *
461 * input: const char *: input string
462 * int *: error return value
463 * uint16_t *: hardware type output (network byte order)
464 * int: hardware type input; -1 for empty
465 * uchar_t *: output buffer for MAC address
466 * output: int: length of MAC address, or -1 for error
467 */
468
469 static int
470 get_mac_addr(const char *str, int *ierrnop, uint16_t *hwret, int hwtype,
471 uchar_t *outbuf)
472 {
473 int maclen;
474 int dig, val;
475 dlpi_handle_t dh;
476 dlpi_info_t dlinfo;
477 char chr;
478
479 if (*str != '\0') {
480 if (*str++ != ',')
481 goto failed;
482 if (dlpi_open(str, &dh, 0) != DLPI_SUCCESS) {
483 maclen = 0;
484 dig = val = 0;
485 /*
486 * Allow MAC addresses with separators matching regexp
487 * (:|-| *).
488 */
489 while ((chr = *str++) != '\0') {
490 if (isdigit(chr)) {
491 val = (val << 4) + chr - '0';
492 } else if (isxdigit(chr)) {
493 val = (val << 4) + chr -
494 (isupper(chr) ? 'A' : 'a') + 10;
495 } else if (isspace(chr) && dig == 0) {
496 continue;
497 } else if (chr == ':' || chr == '-' ||
498 isspace(chr)) {
499 dig = 1;
500 } else {
501 goto failed;
502 }
503 if (++dig == 2) {
504 *outbuf++ = val;
505 maclen++;
506 dig = val = 0;
507 }
508 }
509 } else {
510 if (dlpi_info(dh, &dlinfo, 0) != DLPI_SUCCESS) {
511 dlpi_close(dh);
512 goto failed;
513 }
514 maclen = dlinfo.di_physaddrlen;
515 (void) memcpy(outbuf, dlinfo.di_physaddr, maclen);
516 dlpi_close(dh);
517 if (hwtype == -1)
518 hwtype = dlpi_arptype(dlinfo.di_mactype);
519 }
520 }
521 if (hwtype == -1)
522 goto failed;
523 *hwret = htons(hwtype);
524 return (maclen);
525
526 failed:
527 *ierrnop = ITAB_BAD_NUMBER;
528 return (-1);
529 }
530
531 /*
532 * inittab_encode_e(): converts a string representation of a given datatype into
533 * binary; used for encoding ascii values into a form that
534 * can be put in DHCP packets to be sent on the wire.
535 *
536 * input: const dhcp_symbol_t *: the entry describing the value option
537 * const char *: the value to convert
538 * uint16_t *: set to the length of the binary data returned
539 * boolean_t: if false, return a full DHCP option
540 * int *: error return value
541 * output: uchar_t *: a dynamically allocated byte array with converted data
542 */
543
544 uchar_t *
545 inittab_encode_e(const dhcp_symbol_t *ie, const char *value, uint16_t *lengthp,
546 boolean_t just_payload, int *ierrnop)
547 {
548 int hlen = 0;
549 uint16_t length;
550 uchar_t n_entries = 0;
551 const char *valuep;
552 char *currp;
553 uchar_t *result = NULL;
554 uchar_t *optstart;
555 unsigned int i;
556 uint8_t type_size = inittab_type_to_size(ie);
557 boolean_t is_signed;
558 uint_t vallen, reslen;
559 dhcpv6_option_t *d6o;
560 int type;
561 char *cp2;
562
563 *ierrnop = 0;
564 if (type_size == 0) {
565 *ierrnop = ITAB_SYNTAX_ERROR;
566 return (NULL);
567 }
568
569 switch (ie->ds_type) {
570 case DSYM_ASCII:
571 n_entries = strlen(value); /* no NUL */
572 break;
573
574 case DSYM_OCTET:
575 vallen = strlen(value);
576 n_entries = vallen / 2;
577 n_entries += vallen % 2;
578 break;
579
580 case DSYM_DOMAIN:
581 /*
582 * Maximum (worst-case) encoded length is one byte more than
583 * the number of characters on input.
584 */
585 n_entries = strlen(value) + 1;
586 break;
587
588 case DSYM_DUID:
589 /* Worst case is ":::::" */
590 n_entries = strlen(value);
591 if (n_entries < DLPI_PHYSADDR_MAX)
592 n_entries = DLPI_PHYSADDR_MAX;
593 n_entries += sizeof (duid_llt_t);
594 break;
595
596 default:
597 /*
598 * figure out the number of entries by counting the spaces
599 * in the value string
600 */
601 for (valuep = value; valuep++ != NULL; n_entries++)
602 valuep = strchr(valuep, ' ');
603 break;
604 }
605
606 /*
607 * if we're gonna return a complete option, then include the
608 * option length and code in the size of the packet we allocate
609 */
610 if (!just_payload)
611 hlen = ie->ds_dhcpv6 ? sizeof (*d6o) : 2;
612
613 length = n_entries * type_size;
614 if (hlen + length > 0)
615 result = malloc(hlen + length);
616
617 if ((optstart = result) != NULL && !just_payload)
618 optstart += hlen;
619
620 switch (ie->ds_type) {
621
622 case DSYM_ASCII:
623
624 if (optstart == NULL) {
625 *ierrnop = ITAB_NOMEM;
626 return (NULL);
627 }
628
629 (void) memcpy(optstart, value, length);
630 break;
631
632 case DSYM_DOMAIN:
633 if (optstart == NULL) {
634 *ierrnop = ITAB_NOMEM;
635 return (NULL);
636 }
637
638 /*
639 * Note that this encoder always presents the trailing 0-octet
640 * when dealing with a list. This means that you can't have
641 * non-fully-qualified members anywhere but at the end of a
642 * list (or as the only member of the list).
643 */
644 valuep = value;
645 while (*valuep != '\0') {
646 int dig, val, inchr;
647 boolean_t escape;
648 uchar_t *flen;
649
650 /*
651 * Skip over whitespace that delimits list members.
652 */
653 if (isascii(*valuep) && isspace(*valuep)) {
654 valuep++;
655 continue;
656 }
657 dig = val = 0;
658 escape = B_FALSE;
659 flen = optstart++;
660 while ((inchr = *valuep) != '\0') {
661 valuep++;
662 /*
663 * Just copy non-ASCII text directly to the
664 * output string. This simplifies the use of
665 * other ctype macros below, as, unlike the
666 * special isascii function, they don't handle
667 * non-ASCII.
668 */
669 if (!isascii(inchr)) {
670 escape = B_FALSE;
671 *optstart++ = inchr;
672 continue;
673 }
674 if (escape) {
675 /*
676 * Handle any of \D, \DD, or \DDD for
677 * a digit escape.
678 */
679 if (isdigit(inchr)) {
680 val = val * 10 + inchr - '0';
681 if (++dig == 3) {
682 *optstart++ = val;
683 dig = val = 0;
684 escape = B_FALSE;
685 }
686 continue;
687 } else if (dig > 0) {
688 /*
689 * User terminated \D or \DD
690 * with non-digit. An error,
691 * but we can assume he means
692 * to treat as \00D or \0DD.
693 */
694 *optstart++ = val;
695 dig = val = 0;
696 }
697 /* Fall through and copy character */
698 escape = B_FALSE;
699 } else if (inchr == '\\') {
700 escape = B_TRUE;
701 continue;
702 } else if (inchr == '.') {
703 /*
704 * End of component. Write the length
705 * prefix. If the component is zero
706 * length (i.e., ".."), the just omit
707 * it.
708 */
709 *flen = (optstart - flen) - 1;
710 if (*flen > 0)
711 flen = optstart++;
712 continue;
713 } else if (isspace(inchr)) {
714 /*
715 * Unescaped space; end of domain name
716 * in list.
717 */
718 break;
719 }
720 *optstart++ = inchr;
721 }
722 /*
723 * Handle trailing escape sequence. If string ends
724 * with \, then assume user wants \ at end of encoded
725 * string. If it ends with \D or \DD, assume \00D or
726 * \0DD.
727 */
728 if (escape)
729 *optstart++ = dig > 0 ? val : '\\';
730 *flen = (optstart - flen) - 1;
731 /*
732 * If user specified FQDN with trailing '.', then above
733 * will result in zero for the last component length.
734 * We're done, and optstart already points to the start
735 * of the next in list. Otherwise, we need to write a
736 * single zero byte to end the entry, if there are more
737 * entries that will be decoded.
738 */
739 while (isascii(*valuep) && isspace(*valuep))
740 valuep++;
741 if (*flen > 0 && *valuep != '\0')
742 *optstart++ = '\0';
743 }
744 length = (optstart - result) - hlen;
745 break;
746
747 case DSYM_DUID:
748 if (optstart == NULL) {
749 *ierrnop = ITAB_NOMEM;
750 return (NULL);
751 }
752
753 errno = 0;
754 type = strtoul(value, &currp, 0);
755 if (errno != 0 || value == currp || type > 65535 ||
756 (*currp != ',' && *currp != '\0')) {
757 free(result);
758 *ierrnop = ITAB_BAD_NUMBER;
759 return (NULL);
760 }
761 switch (type) {
762 case DHCPV6_DUID_LLT: {
763 duid_llt_t dllt;
764 int hwtype;
765 ulong_t tstamp;
766 int maclen;
767
768 if ((hwtype = get_hw_type(&currp, ierrnop)) == -2) {
769 free(result);
770 return (NULL);
771 }
772 if (*currp++ != ',') {
773 free(result);
774 *ierrnop = ITAB_BAD_NUMBER;
775 return (NULL);
776 }
777 if (*currp == ',' || *currp == '\0') {
778 tstamp = time(NULL) - DUID_TIME_BASE;
779 } else {
780 tstamp = strtoul(currp, &cp2, 0);
781 if (errno != 0 || currp == cp2) {
782 free(result);
783 *ierrnop = ITAB_BAD_NUMBER;
784 return (NULL);
785 }
786 currp = cp2;
787 }
788 maclen = get_mac_addr(currp, ierrnop,
789 &dllt.dllt_hwtype, hwtype,
790 optstart + sizeof (dllt));
791 if (maclen == -1) {
792 free(result);
793 return (NULL);
794 }
795 dllt.dllt_dutype = htons(type);
796 dllt.dllt_time = htonl(tstamp);
797 (void) memcpy(optstart, &dllt, sizeof (dllt));
798 length = maclen + sizeof (dllt);
799 break;
800 }
801 case DHCPV6_DUID_EN: {
802 duid_en_t den;
803 ulong_t enterp;
804
805 if (*currp++ != ',') {
806 free(result);
807 *ierrnop = ITAB_BAD_NUMBER;
808 return (NULL);
809 }
810 enterp = strtoul(currp, &cp2, 0);
811 DHCPV6_SET_ENTNUM(&den, enterp);
812 if (errno != 0 || currp == cp2 ||
813 enterp != DHCPV6_GET_ENTNUM(&den) ||
814 (*cp2 != ',' && *cp2 != '\0')) {
815 free(result);
816 *ierrnop = ITAB_BAD_NUMBER;
817 return (NULL);
818 }
819 if (*cp2 == ',')
820 cp2++;
821 vallen = strlen(cp2);
822 reslen = (vallen + 1) / 2;
823 if (hexascii_to_octet(cp2, vallen,
824 optstart + sizeof (den), &reslen) != 0) {
825 free(result);
826 *ierrnop = ITAB_BAD_NUMBER;
827 return (NULL);
828 }
829 den.den_dutype = htons(type);
830 (void) memcpy(optstart, &den, sizeof (den));
831 length = reslen + sizeof (den);
832 break;
833 }
834 case DHCPV6_DUID_LL: {
835 duid_ll_t dll;
836 int hwtype;
837 int maclen;
838
839 if ((hwtype = get_hw_type(&currp, ierrnop)) == -2) {
840 free(result);
841 return (NULL);
842 }
843 maclen = get_mac_addr(currp, ierrnop, &dll.dll_hwtype,
844 hwtype, optstart + sizeof (dll));
845 if (maclen == -1) {
846 free(result);
847 return (NULL);
848 }
849 dll.dll_dutype = htons(type);
850 (void) memcpy(optstart, &dll, sizeof (dll));
851 length = maclen + sizeof (dll);
852 break;
853 }
854 default:
855 if (*currp == ',')
856 currp++;
857 vallen = strlen(currp);
858 reslen = (vallen + 1) / 2;
859 if (hexascii_to_octet(currp, vallen, optstart + 2,
860 &reslen) != 0) {
861 free(result);
862 *ierrnop = ITAB_BAD_NUMBER;
863 return (NULL);
864 }
865 optstart[0] = type >> 8;
866 optstart[1] = type;
867 length = reslen + 2;
868 break;
869 }
870 break;
871
872 case DSYM_OCTET:
873
874 if (optstart == NULL) {
875 *ierrnop = ITAB_BAD_OCTET;
876 return (NULL);
877 }
878
879 reslen = length;
880 /* Call libinetutil function to decode */
881 if (hexascii_to_octet(value, vallen, optstart, &reslen) != 0) {
882 free(result);
883 *ierrnop = ITAB_BAD_OCTET;
884 return (NULL);
885 }
886 break;
887
888 case DSYM_IP:
889 case DSYM_IPV6:
890
891 if (optstart == NULL) {
892 *ierrnop = ITAB_BAD_IPADDR;
893 return (NULL);
894 }
895 if (n_entries % ie->ds_gran != 0) {
896 *ierrnop = ITAB_BAD_GRAN;
897 inittab_msg("inittab_encode: number of entries "
898 "not compatible with option granularity");
899 free(result);
900 return (NULL);
901 }
902
903 for (valuep = value, i = 0; i < n_entries; i++, valuep++) {
904
905 currp = strchr(valuep, ' ');
906 if (currp != NULL)
907 *currp = '\0';
908 if (inet_pton(ie->ds_type == DSYM_IP ? AF_INET :
909 AF_INET6, valuep, optstart) != 1) {
910 *ierrnop = ITAB_BAD_IPADDR;
911 inittab_msg("inittab_encode: bogus ip address");
912 free(result);
913 return (NULL);
914 }
915
916 valuep = currp;
917 if (valuep == NULL) {
918 if (i < (n_entries - 1)) {
919 *ierrnop = ITAB_NOT_ENOUGH_IP;
920 inittab_msg("inittab_encode: too few "
921 "ip addresses");
922 free(result);
923 return (NULL);
924 }
925 break;
926 }
927 optstart += type_size;
928 }
929 break;
930
931 case DSYM_NUMBER: /* FALLTHRU */
932 case DSYM_UNUMBER8: /* FALLTHRU */
933 case DSYM_SNUMBER8: /* FALLTHRU */
934 case DSYM_UNUMBER16: /* FALLTHRU */
935 case DSYM_SNUMBER16: /* FALLTHRU */
936 case DSYM_UNUMBER24: /* FALLTHRU */
937 case DSYM_UNUMBER32: /* FALLTHRU */
938 case DSYM_SNUMBER32: /* FALLTHRU */
939 case DSYM_UNUMBER64: /* FALLTHRU */
940 case DSYM_SNUMBER64:
941
942 if (optstart == NULL) {
943 *ierrnop = ITAB_BAD_NUMBER;
944 return (NULL);
945 }
946
947 is_signed = (ie->ds_type == DSYM_SNUMBER64 ||
948 ie->ds_type == DSYM_SNUMBER32 ||
949 ie->ds_type == DSYM_SNUMBER16 ||
950 ie->ds_type == DSYM_SNUMBER8);
951
952 if (encode_number(n_entries, type_size, is_signed, 0, value,
953 optstart, ierrnop) == B_FALSE) {
954 free(result);
955 return (NULL);
956 }
957 break;
958
959 default:
960 if (ie->ds_type == DSYM_BOOL)
961 *ierrnop = ITAB_BAD_BOOLEAN;
962 else
963 *ierrnop = ITAB_SYNTAX_ERROR;
964
965 inittab_msg("inittab_encode: unsupported type `%d'",
966 ie->ds_type);
967
968 free(result);
969 return (NULL);
970 }
971
972 /*
973 * if just_payload is false, then we need to add the option
974 * code and length fields in.
975 */
976 if (!just_payload) {
977 if (ie->ds_dhcpv6) {
978 /* LINTED: alignment */
979 d6o = (dhcpv6_option_t *)result;
980 d6o->d6o_code = htons(ie->ds_code);
981 d6o->d6o_len = htons(length);
982 } else {
983 result[0] = ie->ds_code;
984 result[1] = length;
985 }
986 }
987
988 if (lengthp != NULL)
989 *lengthp = length + hlen;
990
991 return (result);
992 }
993
994 /*
995 * inittab_decode_e(): converts a binary representation of a given datatype into
996 * a string; used for decoding DHCP options in a packet off
997 * the wire into ascii
998 *
999 * input: dhcp_symbol_t *: the entry describing the payload option
1000 * uchar_t *: the payload to convert
1001 * uint16_t: the payload length (only used if just_payload is true)
1002 * boolean_t: if false, payload is assumed to be a DHCP option
1003 * int *: set to extended error code if error occurs.
1004 * output: char *: a dynamically allocated string containing the converted data
1005 */
1006
1007 char *
1008 inittab_decode_e(const dhcp_symbol_t *ie, const uchar_t *payload,
1009 uint16_t length, boolean_t just_payload, int *ierrnop)
1010 {
1011 char *resultp, *result = NULL;
1012 uint_t n_entries;
1013 struct in_addr in_addr;
1014 in6_addr_t in6_addr;
1015 uint8_t type_size = inittab_type_to_size(ie);
1016 boolean_t is_signed;
1017 int type;
1018
1019 *ierrnop = 0;
1020 if (type_size == 0) {
1021 *ierrnop = ITAB_SYNTAX_ERROR;
1022 return (NULL);
1023 }
1024
1025 if (!just_payload) {
1026 if (ie->ds_dhcpv6) {
1027 dhcpv6_option_t d6o;
1028
1029 (void) memcpy(&d6o, payload, sizeof (d6o));
1030 length = ntohs(d6o.d6o_len);
1031 payload += sizeof (d6o);
1032 } else {
1033 length = payload[1];
1034 payload += 2;
1035 }
1036 }
1037
1038 /*
1039 * figure out the number of elements to convert. note that
1040 * for ds_type NUMBER, the granularity is really 1 since the
1041 * value of ds_gran is the number of bytes in the number.
1042 */
1043 if (ie->ds_type == DSYM_NUMBER)
1044 n_entries = MIN(ie->ds_max, length / type_size);
1045 else
1046 n_entries = MIN(ie->ds_max * ie->ds_gran, length / type_size);
1047
1048 if (n_entries == 0)
1049 n_entries = length / type_size;
1050
1051 if ((length % type_size) != 0) {
1052 inittab_msg("inittab_decode: length of string not compatible "
1053 "with option type `%i'", ie->ds_type);
1054 *ierrnop = ITAB_BAD_STRING;
1055 return (NULL);
1056 }
1057
1058 switch (ie->ds_type) {
1059
1060 case DSYM_ASCII:
1061
1062 result = malloc(n_entries + 1);
1063 if (result == NULL) {
1064 *ierrnop = ITAB_NOMEM;
1065 return (NULL);
1066 }
1067
1068 (void) memcpy(result, payload, n_entries);
1069 result[n_entries] = '\0';
1070 break;
1071
1072 case DSYM_DOMAIN:
1073
1074 /*
1075 * A valid, decoded RFC 1035 domain string or sequence of
1076 * strings is always the same size as the encoded form, but we
1077 * allow for RFC 1035 \DDD and \\ and \. escaping.
1078 *
1079 * Decoding stops at the end of the input or the first coding
1080 * violation. Coding violations result in discarding the
1081 * offending list entry entirely. Note that we ignore the 255
1082 * character overall limit on domain names.
1083 */
1084 if ((result = malloc(4 * length + 1)) == NULL) {
1085 *ierrnop = ITAB_NOMEM;
1086 return (NULL);
1087 }
1088 resultp = result;
1089 while (length > 0) {
1090 char *dstart;
1091 int slen;
1092
1093 dstart = resultp;
1094 while (length > 0) {
1095 slen = *payload++;
1096 length--;
1097 /* Upper two bits of length must be zero */
1098 if ((slen & 0xc0) != 0 || slen > length) {
1099 length = 0;
1100 resultp = dstart;
1101 break;
1102 }
1103 if (resultp != dstart)
1104 *resultp++ = '.';
1105 if (slen == 0)
1106 break;
1107 length -= slen;
1108 while (slen > 0) {
1109 if (!isascii(*payload) ||
1110 !isgraph(*payload)) {
1111 (void) snprintf(resultp, 5,
1112 "\\%03d",
1113 *(unsigned char *)payload);
1114 resultp += 4;
1115 payload++;
1116 } else {
1117 if (*payload == '.' ||
1118 *payload == '\\')
1119 *resultp++ = '\\';
1120 *resultp++ = *payload++;
1121 }
1122 slen--;
1123 }
1124 }
1125 if (resultp != dstart && length > 0)
1126 *resultp++ = ' ';
1127 }
1128 *resultp = '\0';
1129 break;
1130
1131 case DSYM_DUID:
1132
1133 /*
1134 * First, determine the type of DUID. We need at least two
1135 * octets worth of data to grab the type code. Once we have
1136 * that, the number of octets required for representation
1137 * depends on the type.
1138 */
1139
1140 if (length < 2) {
1141 *ierrnop = ITAB_BAD_GRAN;
1142 return (NULL);
1143 }
1144 type = (payload[0] << 8) + payload[1];
1145 switch (type) {
1146 case DHCPV6_DUID_LLT: {
1147 duid_llt_t dllt;
1148
1149 if (length < sizeof (dllt)) {
1150 *ierrnop = ITAB_BAD_GRAN;
1151 return (NULL);
1152 }
1153 (void) memcpy(&dllt, payload, sizeof (dllt));
1154 payload += sizeof (dllt);
1155 length -= sizeof (dllt);
1156 n_entries = sizeof ("1,65535,4294967295,") +
1157 length * 3;
1158 if ((result = malloc(n_entries)) == NULL) {
1159 *ierrnop = ITAB_NOMEM;
1160 return (NULL);
1161 }
1162 (void) snprintf(result, n_entries, "%d,%u,%u,", type,
1163 ntohs(dllt.dllt_hwtype), ntohl(dllt.dllt_time));
1164 break;
1165 }
1166 case DHCPV6_DUID_EN: {
1167 duid_en_t den;
1168
1169 if (length < sizeof (den)) {
1170 *ierrnop = ITAB_BAD_GRAN;
1171 return (NULL);
1172 }
1173 (void) memcpy(&den, payload, sizeof (den));
1174 payload += sizeof (den);
1175 length -= sizeof (den);
1176 n_entries = sizeof ("2,4294967295,") + length * 2;
1177 if ((result = malloc(n_entries)) == NULL) {
1178 *ierrnop = ITAB_NOMEM;
1179 return (NULL);
1180 }
1181 (void) snprintf(result, n_entries, "%d,%u,", type,
1182 DHCPV6_GET_ENTNUM(&den));
1183 break;
1184 }
1185 case DHCPV6_DUID_LL: {
1186 duid_ll_t dll;
1187
1188 if (length < sizeof (dll)) {
1189 *ierrnop = ITAB_BAD_GRAN;
1190 return (NULL);
1191 }
1192 (void) memcpy(&dll, payload, sizeof (dll));
1193 payload += sizeof (dll);
1194 length -= sizeof (dll);
1195 n_entries = sizeof ("3,65535,") + length * 3;
1196 if ((result = malloc(n_entries)) == NULL) {
1197 *ierrnop = ITAB_NOMEM;
1198 return (NULL);
1199 }
1200 (void) snprintf(result, n_entries, "%d,%u,", type,
1201 ntohs(dll.dll_hwtype));
1202 break;
1203 }
1204 default:
1205 n_entries = sizeof ("0,") + length * 2;
1206 if ((result = malloc(n_entries)) == NULL) {
1207 *ierrnop = ITAB_NOMEM;
1208 return (NULL);
1209 }
1210 (void) snprintf(result, n_entries, "%d,", type);
1211 break;
1212 }
1213 resultp = result + strlen(result);
1214 n_entries -= strlen(result);
1215 if (type == DHCPV6_DUID_LLT || type == DHCPV6_DUID_LL) {
1216 if (length > 0) {
1217 resultp += snprintf(resultp, 3, "%02X",
1218 *payload++);
1219 length--;
1220 }
1221 while (length-- > 0) {
1222 resultp += snprintf(resultp, 4, ":%02X",
1223 *payload++);
1224 }
1225 } else {
1226 while (length-- > 0) {
1227 resultp += snprintf(resultp, 3, "%02X",
1228 *payload++);
1229 }
1230 }
1231 break;
1232
1233 case DSYM_OCTET:
1234
1235 result = malloc(n_entries * (sizeof ("0xNN") + 1));
1236 if (result == NULL) {
1237 *ierrnop = ITAB_NOMEM;
1238 return (NULL);
1239 }
1240
1241 result[0] = '\0';
1242 resultp = result;
1243 if (n_entries > 0) {
1244 resultp += sprintf(resultp, "0x%02X", *payload++);
1245 n_entries--;
1246 }
1247 while (n_entries-- > 0)
1248 resultp += sprintf(resultp, " 0x%02X", *payload++);
1249
1250 break;
1251
1252 case DSYM_IP:
1253 case DSYM_IPV6:
1254 if ((length / type_size) % ie->ds_gran != 0) {
1255 *ierrnop = ITAB_BAD_GRAN;
1256 inittab_msg("inittab_decode: number of entries "
1257 "not compatible with option granularity");
1258 return (NULL);
1259 }
1260
1261 result = malloc(n_entries * (ie->ds_type == DSYM_IP ?
1262 INET_ADDRSTRLEN : INET6_ADDRSTRLEN));
1263 if (result == NULL) {
1264 *ierrnop = ITAB_NOMEM;
1265 return (NULL);
1266 }
1267
1268 for (resultp = result; n_entries != 0; n_entries--) {
1269 if (ie->ds_type == DSYM_IP) {
1270 (void) memcpy(&in_addr.s_addr, payload,
1271 sizeof (ipaddr_t));
1272 (void) strcpy(resultp, inet_ntoa(in_addr));
1273 } else {
1274 (void) memcpy(&in6_addr, payload,
1275 sizeof (in6_addr));
1276 (void) inet_ntop(AF_INET6, &in6_addr, resultp,
1277 INET6_ADDRSTRLEN);
1278 }
1279 resultp += strlen(resultp);
1280 if (n_entries > 1)
1281 *resultp++ = ' ';
1282 payload += type_size;
1283 }
1284 *resultp = '\0';
1285 break;
1286
1287 case DSYM_NUMBER: /* FALLTHRU */
1288 case DSYM_UNUMBER8: /* FALLTHRU */
1289 case DSYM_SNUMBER8: /* FALLTHRU */
1290 case DSYM_UNUMBER16: /* FALLTHRU */
1291 case DSYM_SNUMBER16: /* FALLTHRU */
1292 case DSYM_UNUMBER32: /* FALLTHRU */
1293 case DSYM_SNUMBER32: /* FALLTHRU */
1294 case DSYM_UNUMBER64: /* FALLTHRU */
1295 case DSYM_SNUMBER64:
1296
1297 is_signed = (ie->ds_type == DSYM_SNUMBER64 ||
1298 ie->ds_type == DSYM_SNUMBER32 ||
1299 ie->ds_type == DSYM_SNUMBER16 ||
1300 ie->ds_type == DSYM_SNUMBER8);
1301
1302 result = malloc(n_entries * ITAB_MAX_NUMBER_LEN);
1303 if (result == NULL) {
1304 *ierrnop = ITAB_NOMEM;
1305 return (NULL);
1306 }
1307
1308 if (decode_number(n_entries, type_size, is_signed, ie->ds_gran,
1309 payload, result, ierrnop) == B_FALSE) {
1310 free(result);
1311 return (NULL);
1312 }
1313 break;
1314
1315 default:
1316 inittab_msg("inittab_decode: unsupported type `%d'",
1317 ie->ds_type);
1318 break;
1319 }
1320
1321 return (result);
1322 }
1323
1324 /*
1325 * inittab_encode(): converts a string representation of a given datatype into
1326 * binary; used for encoding ascii values into a form that
1327 * can be put in DHCP packets to be sent on the wire.
1328 *
1329 * input: dhcp_symbol_t *: the entry describing the value option
1330 * const char *: the value to convert
1331 * uint16_t *: set to the length of the binary data returned
1332 * boolean_t: if false, return a full DHCP option
1333 * output: uchar_t *: a dynamically allocated byte array with converted data
1334 */
1335
1336 uchar_t *
1337 inittab_encode(const dhcp_symbol_t *ie, const char *value, uint16_t *lengthp,
1338 boolean_t just_payload)
1339 {
1340 int ierrno;
1341
1342 return (inittab_encode_e(ie, value, lengthp, just_payload, &ierrno));
1343 }
1344
1345 /*
1346 * inittab_decode(): converts a binary representation of a given datatype into
1347 * a string; used for decoding DHCP options in a packet off
1348 * the wire into ascii
1349 *
1350 * input: dhcp_symbol_t *: the entry describing the payload option
1351 * uchar_t *: the payload to convert
1352 * uint16_t: the payload length (only used if just_payload is true)
1353 * boolean_t: if false, payload is assumed to be a DHCP option
1354 * output: char *: a dynamically allocated string containing the converted data
1355 */
1356
1357 char *
1358 inittab_decode(const dhcp_symbol_t *ie, const uchar_t *payload, uint16_t length,
1359 boolean_t just_payload)
1360 {
1361 int ierrno;
1362
1363 return (inittab_decode_e(ie, payload, length, just_payload, &ierrno));
1364 }
1365
1366 /*
1367 * inittab_msg(): prints diagnostic messages if INITTAB_DEBUG is set
1368 *
1369 * const char *: a printf-like format string
1370 * ...: arguments to the format string
1371 * output: void
1372 */
1373
1374 /*PRINTFLIKE1*/
1375 static void
1376 inittab_msg(const char *fmt, ...)
1377 {
1378 enum { INITTAB_MSG_CHECK, INITTAB_MSG_RETURN, INITTAB_MSG_OUTPUT };
1379
1380 va_list ap;
1381 char buf[512];
1382 static int action = INITTAB_MSG_CHECK;
1383
1384 /*
1385 * check DHCP_INITTAB_DEBUG the first time in; thereafter, use
1386 * the the cached result (stored in `action').
1387 */
1388 switch (action) {
1389
1390 case INITTAB_MSG_CHECK:
1391
1392 if (getenv("DHCP_INITTAB_DEBUG") == NULL) {
1393 action = INITTAB_MSG_RETURN;
1394 return;
1395 }
1396
1397 action = INITTAB_MSG_OUTPUT;
1398
1399 /* FALLTHRU into INITTAB_MSG_OUTPUT */
1400
1401 case INITTAB_MSG_OUTPUT:
1402
1403 va_start(ap, fmt);
1404
1405 (void) snprintf(buf, sizeof (buf), "inittab: %s\n", fmt);
1406 (void) vfprintf(stderr, buf, ap);
1407
1408 va_end(ap);
1409 break;
1410
1411 case INITTAB_MSG_RETURN:
1412
1413 return;
1414 }
1415 }
1416
1417 /*
1418 * decode_number(): decodes a sequence of numbers from binary into ascii;
1419 * binary is coming off of the network, so it is in nbo
1420 *
1421 * input: uint8_t: the number of "granularity" numbers to decode
1422 * uint8_t: the length of each number
1423 * boolean_t: whether the numbers should be considered signed
1424 * uint8_t: the number of numbers per granularity
1425 * const uint8_t *: where to decode the numbers from
1426 * char *: where to decode the numbers to
1427 * output: boolean_t: true on successful conversion, false on failure
1428 */
1429
1430 static boolean_t
1431 decode_number(uint8_t n_entries, uint8_t size, boolean_t is_signed,
1432 uint8_t granularity, const uint8_t *from, char *to, int *ierrnop)
1433 {
1434 uint16_t uint16;
1435 uint32_t uint32;
1436 uint64_t uint64;
1437
1438 if (granularity != 0) {
1439 if ((granularity % n_entries) != 0) {
1440 inittab_msg("decode_number: number of entries "
1441 "not compatible with option granularity");
1442 *ierrnop = ITAB_BAD_GRAN;
1443 return (B_FALSE);
1444 }
1445 }
1446
1447 for (; n_entries != 0; n_entries--, from += size) {
1448
1449 switch (size) {
1450
1451 case 1:
1452 to += sprintf(to, is_signed ? "%d" : "%u", *from);
1453 break;
1454
1455 case 2:
1456 (void) memcpy(&uint16, from, 2);
1457 to += sprintf(to, is_signed ? "%hd" : "%hu",
1458 ntohs(uint16));
1459 break;
1460
1461 case 3:
1462 uint32 = 0;
1463 (void) memcpy((uchar_t *)&uint32 + 1, from, 3);
1464 to += sprintf(to, is_signed ? "%ld" : "%lu",
1465 ntohl(uint32));
1466 break;
1467
1468 case 4:
1469 (void) memcpy(&uint32, from, 4);
1470 to += sprintf(to, is_signed ? "%ld" : "%lu",
1471 ntohl(uint32));
1472 break;
1473
1474 case 8:
1475 (void) memcpy(&uint64, from, 8);
1476 to += sprintf(to, is_signed ? "%lld" : "%llu",
1477 ntohll(uint64));
1478 break;
1479
1480 default:
1481 *ierrnop = ITAB_BAD_NUMBER;
1482 inittab_msg("decode_number: unknown integer size `%d'",
1483 size);
1484 return (B_FALSE);
1485 }
1486 if (n_entries > 0)
1487 *to++ = ' ';
1488 }
1489
1490 *to = '\0';
1491 return (B_TRUE);
1492 }
1493
1494 /*
1495 * encode_number(): encodes a sequence of numbers from ascii into binary;
1496 * number will end up on the wire so it needs to be in nbo
1497 *
1498 * input: uint8_t: the number of "granularity" numbers to encode
1499 * uint8_t: the length of each number
1500 * boolean_t: whether the numbers should be considered signed
1501 * uint8_t: the number of numbers per granularity
1502 * const uint8_t *: where to encode the numbers from
1503 * char *: where to encode the numbers to
1504 * int *: set to extended error code if error occurs.
1505 * output: boolean_t: true on successful conversion, false on failure
1506 */
1507
1508 static boolean_t /* ARGSUSED */
1509 encode_number(uint8_t n_entries, uint8_t size, boolean_t is_signed,
1510 uint8_t granularity, const char *from, uint8_t *to, int *ierrnop)
1511 {
1512 uint8_t i;
1513 uint16_t uint16;
1514 uint32_t uint32;
1515 uint64_t uint64;
1516 char *endptr;
1517
1518 if (granularity != 0) {
1519 if ((granularity % n_entries) != 0) {
1520 *ierrnop = ITAB_BAD_GRAN;
1521 inittab_msg("encode_number: number of entries "
1522 "not compatible with option granularity");
1523 return (B_FALSE);
1524 }
1525 }
1526
1527 for (i = 0; i < n_entries; i++, from++, to += size) {
1528
1529 /*
1530 * totally obscure c factoid: it is legal to pass a
1531 * string representing a negative number to strtoul().
1532 * in this case, strtoul() will return an unsigned
1533 * long that if cast to a long, would represent the
1534 * negative number. we take advantage of this to
1535 * cut down on code here.
1536 */
1537
1538 errno = 0;
1539 switch (size) {
1540
1541 case 1:
1542 *to = strtoul(from, &endptr, 0);
1543 if (errno != 0 || from == endptr) {
1544 goto error;
1545 }
1546 break;
1547
1548 case 2:
1549 uint16 = htons(strtoul(from, &endptr, 0));
1550 if (errno != 0 || from == endptr) {
1551 goto error;
1552 }
1553 (void) memcpy(to, &uint16, 2);
1554 break;
1555
1556 case 3:
1557 uint32 = htonl(strtoul(from, &endptr, 0));
1558 if (errno != 0 || from == endptr) {
1559 goto error;
1560 }
1561 (void) memcpy(to, (uchar_t *)&uint32 + 1, 3);
1562 break;
1563
1564 case 4:
1565 uint32 = htonl(strtoul(from, &endptr, 0));
1566 if (errno != 0 || from == endptr) {
1567 goto error;
1568 }
1569 (void) memcpy(to, &uint32, 4);
1570 break;
1571
1572 case 8:
1573 uint64 = htonll(strtoull(from, &endptr, 0));
1574 if (errno != 0 || from == endptr) {
1575 goto error;
1576 }
1577 (void) memcpy(to, &uint64, 8);
1578 break;
1579
1580 default:
1581 inittab_msg("encode_number: unsupported integer "
1582 "size `%d'", size);
1583 return (B_FALSE);
1584 }
1585
1586 from = strchr(from, ' ');
1587 if (from == NULL)
1588 break;
1589 }
1590
1591 return (B_TRUE);
1592
1593 error:
1594 *ierrnop = ITAB_BAD_NUMBER;
1595 inittab_msg("encode_number: cannot convert to integer");
1596 return (B_FALSE);
1597 }
1598
1599 /*
1600 * inittab_type_to_size(): given an inittab entry, returns size of one entry of
1601 * its type
1602 *
1603 * input: dhcp_symbol_t *: an entry of the given type
1604 * output: uint8_t: the size in bytes of an entry of that type
1605 */
1606
1607 uint8_t
1608 inittab_type_to_size(const dhcp_symbol_t *ie)
1609 {
1610 switch (ie->ds_type) {
1611
1612 case DSYM_DUID:
1613 case DSYM_DOMAIN:
1614 case DSYM_ASCII:
1615 case DSYM_OCTET:
1616 case DSYM_SNUMBER8:
1617 case DSYM_UNUMBER8:
1618
1619 return (1);
1620
1621 case DSYM_SNUMBER16:
1622 case DSYM_UNUMBER16:
1623
1624 return (2);
1625
1626 case DSYM_UNUMBER24:
1627
1628 return (3);
1629
1630 case DSYM_SNUMBER32:
1631 case DSYM_UNUMBER32:
1632 case DSYM_IP:
1633
1634 return (4);
1635
1636 case DSYM_SNUMBER64:
1637 case DSYM_UNUMBER64:
1638
1639 return (8);
1640
1641 case DSYM_NUMBER:
1642
1643 return (ie->ds_gran);
1644
1645 case DSYM_IPV6:
1646
1647 return (sizeof (in6_addr_t));
1648 }
1649
1650 return (0);
1651 }
1652
1653 /*
1654 * itabcode_to_dsymcode(): maps an inittab category code to its dsym
1655 * representation
1656 *
1657 * input: uchar_t: the inittab category code
1658 * output: dsym_category_t: the dsym category code
1659 */
1660
1661 static dsym_category_t
1662 itabcode_to_dsymcode(uchar_t itabcode)
1663 {
1664
1665 unsigned int i;
1666
1667 for (i = 0; i < ITAB_CAT_COUNT; i++)
1668 if (category_map[i].cme_itabcode == itabcode)
1669 return (category_map[i].cme_dsymcode);
1670
1671 return (DSYM_BAD_CAT);
1672 }
1673
1674 /*
1675 * category_to_code(): maps a category name to its numeric representation
1676 *
1677 * input: const char *: the category name
1678 * output: uchar_t: its internal code (numeric representation)
1679 */
1680
1681 static uchar_t
1682 category_to_code(const char *category)
1683 {
1684 unsigned int i;
1685
1686 for (i = 0; i < ITAB_CAT_COUNT; i++)
1687 if (strcasecmp(category_map[i].cme_name, category) == 0)
1688 return (category_map[i].cme_itabcode);
1689
1690 return (0);
1691 }
1692
1693 /*
1694 * our internal table of DHCP option values, used by inittab_verify()
1695 */
1696 static dhcp_symbol_t inittab_table[] =
1697 {
1698 { DSYM_INTERNAL, 1024, "Hostname", DSYM_BOOL, 0, 0 },
1699 { DSYM_INTERNAL, 1025, "LeaseNeg", DSYM_BOOL, 0, 0 },
1700 { DSYM_INTERNAL, 1026, "EchoVC", DSYM_BOOL, 0, 0 },
1701 { DSYM_INTERNAL, 1027, "BootPath", DSYM_ASCII, 1, 128 },
1702 { DSYM_FIELD, 0, "Opcode", DSYM_UNUMBER8, 1, 1 },
1703 { DSYM_FIELD, 1, "Htype", DSYM_UNUMBER8, 1, 1 },
1704 { DSYM_FIELD, 2, "HLen", DSYM_UNUMBER8, 1, 1 },
1705 { DSYM_FIELD, 3, "Hops", DSYM_UNUMBER8, 1, 1 },
1706 { DSYM_FIELD, 4, "Xid", DSYM_UNUMBER32, 1, 1 },
1707 { DSYM_FIELD, 8, "Secs", DSYM_UNUMBER16, 1, 1 },
1708 { DSYM_FIELD, 10, "Flags", DSYM_OCTET, 1, 2 },
1709 { DSYM_FIELD, 12, "Ciaddr", DSYM_IP, 1, 1 },
1710 { DSYM_FIELD, 16, "Yiaddr", DSYM_IP, 1, 1 },
1711 { DSYM_FIELD, 20, "BootSrvA", DSYM_IP, 1, 1 },
1712 { DSYM_FIELD, 24, "Giaddr", DSYM_IP, 1, 1 },
1713 { DSYM_FIELD, 28, "Chaddr", DSYM_OCTET, 1, 16 },
1714 { DSYM_FIELD, 44, "BootSrvN", DSYM_ASCII, 1, 64 },
1715 { DSYM_FIELD, 108, "BootFile", DSYM_ASCII, 1, 128 },
1716 { DSYM_FIELD, 236, "Magic", DSYM_OCTET, 1, 4 },
1717 { DSYM_FIELD, 240, "Options", DSYM_OCTET, 1, 60 },
1718 { DSYM_STANDARD, 1, "Subnet", DSYM_IP, 1, 1 },
1719 { DSYM_STANDARD, 2, "UTCoffst", DSYM_SNUMBER32, 1, 1 },
1720 { DSYM_STANDARD, 3, "Router", DSYM_IP, 1, 0 },
1721 { DSYM_STANDARD, 4, "Timeserv", DSYM_IP, 1, 0 },
1722 { DSYM_STANDARD, 5, "IEN116ns", DSYM_IP, 1, 0 },
1723 { DSYM_STANDARD, 6, "DNSserv", DSYM_IP, 1, 0 },
1724 { DSYM_STANDARD, 7, "Logserv", DSYM_IP, 1, 0 },
1725 { DSYM_STANDARD, 8, "Cookie", DSYM_IP, 1, 0 },
1726 { DSYM_STANDARD, 9, "Lprserv", DSYM_IP, 1, 0 },
1727 { DSYM_STANDARD, 10, "Impress", DSYM_IP, 1, 0 },
1728 { DSYM_STANDARD, 11, "Resource", DSYM_IP, 1, 0 },
1729 { DSYM_STANDARD, 12, "Hostname", DSYM_ASCII, 1, 0 },
1730 { DSYM_STANDARD, 13, "Bootsize", DSYM_UNUMBER16, 1, 1 },
1731 { DSYM_STANDARD, 14, "Dumpfile", DSYM_ASCII, 1, 0 },
1732 { DSYM_STANDARD, 15, "DNSdmain", DSYM_ASCII, 1, 0 },
1733 { DSYM_STANDARD, 16, "Swapserv", DSYM_IP, 1, 1 },
1734 { DSYM_STANDARD, 17, "Rootpath", DSYM_ASCII, 1, 0 },
1735 { DSYM_STANDARD, 18, "ExtendP", DSYM_ASCII, 1, 0 },
1736 { DSYM_STANDARD, 19, "IpFwdF", DSYM_UNUMBER8, 1, 1 },
1737 { DSYM_STANDARD, 20, "NLrouteF", DSYM_UNUMBER8, 1, 1 },
1738 { DSYM_STANDARD, 21, "PFilter", DSYM_IP, 2, 0 },
1739 { DSYM_STANDARD, 22, "MaxIpSiz", DSYM_UNUMBER16, 1, 1 },
1740 { DSYM_STANDARD, 23, "IpTTL", DSYM_UNUMBER8, 1, 1 },
1741 { DSYM_STANDARD, 24, "PathTO", DSYM_UNUMBER32, 1, 1 },
1742 { DSYM_STANDARD, 25, "PathTbl", DSYM_UNUMBER16, 1, 0 },
1743 { DSYM_STANDARD, 26, "MTU", DSYM_UNUMBER16, 1, 1 },
1744 { DSYM_STANDARD, 27, "SameMtuF", DSYM_UNUMBER8, 1, 1 },
1745 { DSYM_STANDARD, 28, "Broadcst", DSYM_IP, 1, 1 },
1746 { DSYM_STANDARD, 29, "MaskDscF", DSYM_UNUMBER8, 1, 1 },
1747 { DSYM_STANDARD, 30, "MaskSupF", DSYM_UNUMBER8, 1, 1 },
1748 { DSYM_STANDARD, 31, "RDiscvyF", DSYM_UNUMBER8, 1, 1 },
1749 { DSYM_STANDARD, 32, "RSolictS", DSYM_IP, 1, 1 },
1750 { DSYM_STANDARD, 33, "StaticRt", DSYM_IP, 2, 0 },
1751 { DSYM_STANDARD, 34, "TrailerF", DSYM_UNUMBER8, 1, 1 },
1752 { DSYM_STANDARD, 35, "ArpTimeO", DSYM_UNUMBER32, 1, 1 },
1753 { DSYM_STANDARD, 36, "EthEncap", DSYM_UNUMBER8, 1, 1 },
1754 { DSYM_STANDARD, 37, "TcpTTL", DSYM_UNUMBER8, 1, 1 },
1755 { DSYM_STANDARD, 38, "TcpKaInt", DSYM_UNUMBER32, 1, 1 },
1756 { DSYM_STANDARD, 39, "TcpKaGbF", DSYM_UNUMBER8, 1, 1 },
1757 { DSYM_STANDARD, 40, "NISdmain", DSYM_ASCII, 1, 0 },
1758 { DSYM_STANDARD, 41, "NISservs", DSYM_IP, 1, 0 },
1759 { DSYM_STANDARD, 42, "NTPservs", DSYM_IP, 1, 0 },
1760 { DSYM_STANDARD, 43, "Vendor", DSYM_OCTET, 1, 0 },
1761 { DSYM_STANDARD, 44, "NetBNms", DSYM_IP, 1, 0 },
1762 { DSYM_STANDARD, 45, "NetBDsts", DSYM_IP, 1, 0 },
1763 { DSYM_STANDARD, 46, "NetBNdT", DSYM_UNUMBER8, 1, 1 },
1764 { DSYM_STANDARD, 47, "NetBScop", DSYM_ASCII, 1, 0 },
1765 { DSYM_STANDARD, 48, "XFontSrv", DSYM_IP, 1, 0 },
1766 { DSYM_STANDARD, 49, "XDispMgr", DSYM_IP, 1, 0 },
1767 { DSYM_STANDARD, 50, "ReqIP", DSYM_IP, 1, 1 },
1768 { DSYM_STANDARD, 51, "LeaseTim", DSYM_UNUMBER32, 1, 1 },
1769 { DSYM_STANDARD, 52, "OptOvrld", DSYM_UNUMBER8, 1, 1 },
1770 { DSYM_STANDARD, 53, "DHCPType", DSYM_UNUMBER8, 1, 1 },
1771 { DSYM_STANDARD, 54, "ServerID", DSYM_IP, 1, 1 },
1772 { DSYM_STANDARD, 55, "ReqList", DSYM_OCTET, 1, 0 },
1773 { DSYM_STANDARD, 56, "Message", DSYM_ASCII, 1, 0 },
1774 { DSYM_STANDARD, 57, "DHCP_MTU", DSYM_UNUMBER16, 1, 1 },
1775 { DSYM_STANDARD, 58, "T1Time", DSYM_UNUMBER32, 1, 1 },
1776 { DSYM_STANDARD, 59, "T2Time", DSYM_UNUMBER32, 1, 1 },
1777 { DSYM_STANDARD, 60, "ClassID", DSYM_ASCII, 1, 0 },
1778 { DSYM_STANDARD, 61, "ClientID", DSYM_OCTET, 1, 0 },
1779 { DSYM_STANDARD, 62, "NW_dmain", DSYM_ASCII, 1, 0 },
1780 { DSYM_STANDARD, 63, "NWIPOpts", DSYM_OCTET, 1, 128 },
1781 { DSYM_STANDARD, 64, "NIS+dom", DSYM_ASCII, 1, 0 },
1782 { DSYM_STANDARD, 65, "NIS+serv", DSYM_IP, 1, 0 },
1783 { DSYM_STANDARD, 66, "TFTPsrvN", DSYM_ASCII, 1, 64 },
1784 { DSYM_STANDARD, 67, "OptBootF", DSYM_ASCII, 1, 128 },
1785 { DSYM_STANDARD, 68, "MblIPAgt", DSYM_IP, 1, 0 },
1786 { DSYM_STANDARD, 69, "SMTPserv", DSYM_IP, 1, 0 },
1787 { DSYM_STANDARD, 70, "POP3serv", DSYM_IP, 1, 0 },
1788 { DSYM_STANDARD, 71, "NNTPserv", DSYM_IP, 1, 0 },
1789 { DSYM_STANDARD, 72, "WWWservs", DSYM_IP, 1, 0 },
1790 { DSYM_STANDARD, 73, "Fingersv", DSYM_IP, 1, 0 },
1791 { DSYM_STANDARD, 74, "IRCservs", DSYM_IP, 1, 0 },
1792 { DSYM_STANDARD, 75, "STservs", DSYM_IP, 1, 0 },
1793 { DSYM_STANDARD, 76, "STDAservs", DSYM_IP, 1, 0 },
1794 { DSYM_STANDARD, 77, "UserClas", DSYM_ASCII, 1, 0 },
1795 { DSYM_STANDARD, 78, "SLP_DA", DSYM_OCTET, 1, 0 },
1796 { DSYM_STANDARD, 79, "SLP_SS", DSYM_OCTET, 1, 0 },
1797 { DSYM_STANDARD, 82, "AgentOpt", DSYM_OCTET, 1, 0 },
1798 { DSYM_STANDARD, 89, "FQDN", DSYM_OCTET, 1, 0 },
1799 { 0, 0, "", 0, 0, 0 }
1800 };