xref: /titanic_41/usr/src/lib/libdhcputil/common/dhcp_inittab.c (revision e4d060fb4c00d44cd578713eb9a921f594b733b8)
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 };
1801