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_bind(dh, DLPI_ANY_SAP, NULL) != 511 DLPI_SUCCESS || dlpi_info(dh, &dlinfo, 0) != 512 DLPI_SUCCESS) { 513 dlpi_close(dh); 514 goto failed; 515 } 516 maclen = dlinfo.di_physaddrlen; 517 (void) memcpy(outbuf, dlinfo.di_physaddr, maclen); 518 dlpi_close(dh); 519 if (hwtype == -1) 520 hwtype = dlpi_arptype(dlinfo.di_mactype); 521 } 522 } 523 if (hwtype == -1) 524 goto failed; 525 *hwret = htons(hwtype); 526 return (maclen); 527 528 failed: 529 *ierrnop = ITAB_BAD_NUMBER; 530 return (-1); 531 } 532 533 /* 534 * inittab_encode_e(): converts a string representation of a given datatype into 535 * binary; used for encoding ascii values into a form that 536 * can be put in DHCP packets to be sent on the wire. 537 * 538 * input: const dhcp_symbol_t *: the entry describing the value option 539 * const char *: the value to convert 540 * uint16_t *: set to the length of the binary data returned 541 * boolean_t: if false, return a full DHCP option 542 * int *: error return value 543 * output: uchar_t *: a dynamically allocated byte array with converted data 544 */ 545 546 uchar_t * 547 inittab_encode_e(const dhcp_symbol_t *ie, const char *value, uint16_t *lengthp, 548 boolean_t just_payload, int *ierrnop) 549 { 550 int hlen = 0; 551 uint16_t length; 552 uchar_t n_entries = 0; 553 const char *valuep; 554 char *currp; 555 uchar_t *result = NULL; 556 uchar_t *optstart; 557 unsigned int i; 558 uint8_t type_size = inittab_type_to_size(ie); 559 boolean_t is_signed; 560 uint_t vallen, reslen; 561 dhcpv6_option_t *d6o; 562 int type; 563 char *cp2; 564 565 *ierrnop = 0; 566 if (type_size == 0) { 567 *ierrnop = ITAB_SYNTAX_ERROR; 568 return (NULL); 569 } 570 571 switch (ie->ds_type) { 572 case DSYM_ASCII: 573 n_entries = strlen(value); /* no NUL */ 574 break; 575 576 case DSYM_OCTET: 577 vallen = strlen(value); 578 n_entries = vallen / 2; 579 n_entries += vallen % 2; 580 break; 581 582 case DSYM_DOMAIN: 583 /* 584 * Maximum (worst-case) encoded length is one byte more than 585 * the number of characters on input. 586 */ 587 n_entries = strlen(value) + 1; 588 break; 589 590 case DSYM_DUID: 591 /* Worst case is ":::::" */ 592 n_entries = strlen(value); 593 if (n_entries < DLPI_PHYSADDR_MAX) 594 n_entries = DLPI_PHYSADDR_MAX; 595 n_entries += sizeof (duid_llt_t); 596 break; 597 598 default: 599 /* 600 * figure out the number of entries by counting the spaces 601 * in the value string 602 */ 603 for (valuep = value; valuep++ != NULL; n_entries++) 604 valuep = strchr(valuep, ' '); 605 break; 606 } 607 608 /* 609 * if we're gonna return a complete option, then include the 610 * option length and code in the size of the packet we allocate 611 */ 612 if (!just_payload) 613 hlen = ie->ds_dhcpv6 ? sizeof (*d6o) : 2; 614 615 length = n_entries * type_size; 616 if (hlen + length > 0) 617 result = malloc(hlen + length); 618 619 if ((optstart = result) != NULL && !just_payload) 620 optstart += hlen; 621 622 switch (ie->ds_type) { 623 624 case DSYM_ASCII: 625 626 if (optstart == NULL) { 627 *ierrnop = ITAB_NOMEM; 628 return (NULL); 629 } 630 631 (void) memcpy(optstart, value, length); 632 break; 633 634 case DSYM_DOMAIN: 635 if (optstart == NULL) { 636 *ierrnop = ITAB_NOMEM; 637 return (NULL); 638 } 639 640 /* 641 * Note that this encoder always presents the trailing 0-octet 642 * when dealing with a list. This means that you can't have 643 * non-fully-qualified members anywhere but at the end of a 644 * list (or as the only member of the list). 645 */ 646 valuep = value; 647 while (*valuep != '\0') { 648 int dig, val, inchr; 649 boolean_t escape; 650 uchar_t *flen; 651 652 /* 653 * Skip over whitespace that delimits list members. 654 */ 655 if (isascii(*valuep) && isspace(*valuep)) { 656 valuep++; 657 continue; 658 } 659 dig = val = 0; 660 escape = B_FALSE; 661 flen = optstart++; 662 while ((inchr = *valuep) != '\0') { 663 valuep++; 664 /* 665 * Just copy non-ASCII text directly to the 666 * output string. This simplifies the use of 667 * other ctype macros below, as, unlike the 668 * special isascii function, they don't handle 669 * non-ASCII. 670 */ 671 if (!isascii(inchr)) { 672 escape = B_FALSE; 673 *optstart++ = inchr; 674 continue; 675 } 676 if (escape) { 677 /* 678 * Handle any of \D, \DD, or \DDD for 679 * a digit escape. 680 */ 681 if (isdigit(inchr)) { 682 val = val * 10 + inchr - '0'; 683 if (++dig == 3) { 684 *optstart++ = val; 685 dig = val = 0; 686 escape = B_FALSE; 687 } 688 continue; 689 } else if (dig > 0) { 690 /* 691 * User terminated \D or \DD 692 * with non-digit. An error, 693 * but we can assume he means 694 * to treat as \00D or \0DD. 695 */ 696 *optstart++ = val; 697 dig = val = 0; 698 } 699 /* Fall through and copy character */ 700 escape = B_FALSE; 701 } else if (inchr == '\\') { 702 escape = B_TRUE; 703 continue; 704 } else if (inchr == '.') { 705 /* 706 * End of component. Write the length 707 * prefix. If the component is zero 708 * length (i.e., ".."), the just omit 709 * it. 710 */ 711 *flen = (optstart - flen) - 1; 712 if (*flen > 0) 713 flen = optstart++; 714 continue; 715 } else if (isspace(inchr)) { 716 /* 717 * Unescaped space; end of domain name 718 * in list. 719 */ 720 break; 721 } 722 *optstart++ = inchr; 723 } 724 /* 725 * Handle trailing escape sequence. If string ends 726 * with \, then assume user wants \ at end of encoded 727 * string. If it ends with \D or \DD, assume \00D or 728 * \0DD. 729 */ 730 if (escape) 731 *optstart++ = dig > 0 ? val : '\\'; 732 *flen = (optstart - flen) - 1; 733 /* 734 * If user specified FQDN with trailing '.', then above 735 * will result in zero for the last component length. 736 * We're done, and optstart already points to the start 737 * of the next in list. Otherwise, we need to write a 738 * single zero byte to end the entry, if there are more 739 * entries that will be decoded. 740 */ 741 while (isascii(*valuep) && isspace(*valuep)) 742 valuep++; 743 if (*flen > 0 && *valuep != '\0') 744 *optstart++ = '\0'; 745 } 746 length = (optstart - result) - hlen; 747 break; 748 749 case DSYM_DUID: 750 if (optstart == NULL) { 751 *ierrnop = ITAB_NOMEM; 752 return (NULL); 753 } 754 755 errno = 0; 756 type = strtoul(value, &currp, 0); 757 if (errno != 0 || value == currp || type > 65535 || 758 (*currp != ',' && *currp != '\0')) { 759 free(result); 760 *ierrnop = ITAB_BAD_NUMBER; 761 return (NULL); 762 } 763 switch (type) { 764 case DHCPV6_DUID_LLT: { 765 duid_llt_t dllt; 766 int hwtype; 767 ulong_t tstamp; 768 int maclen; 769 770 if ((hwtype = get_hw_type(&currp, ierrnop)) == -2) { 771 free(result); 772 return (NULL); 773 } 774 if (*currp++ != ',') { 775 free(result); 776 *ierrnop = ITAB_BAD_NUMBER; 777 return (NULL); 778 } 779 if (*currp == ',' || *currp == '\0') { 780 tstamp = time(NULL) - DUID_TIME_BASE; 781 } else { 782 tstamp = strtoul(currp, &cp2, 0); 783 if (errno != 0 || currp == cp2) { 784 free(result); 785 *ierrnop = ITAB_BAD_NUMBER; 786 return (NULL); 787 } 788 currp = cp2; 789 } 790 maclen = get_mac_addr(currp, ierrnop, 791 &dllt.dllt_hwtype, hwtype, 792 optstart + sizeof (dllt)); 793 if (maclen == -1) { 794 free(result); 795 return (NULL); 796 } 797 dllt.dllt_dutype = htons(type); 798 dllt.dllt_time = htonl(tstamp); 799 (void) memcpy(optstart, &dllt, sizeof (dllt)); 800 length = maclen + sizeof (dllt); 801 break; 802 } 803 case DHCPV6_DUID_EN: { 804 duid_en_t den; 805 ulong_t enterp; 806 807 if (*currp++ != ',') { 808 free(result); 809 *ierrnop = ITAB_BAD_NUMBER; 810 return (NULL); 811 } 812 enterp = strtoul(currp, &cp2, 0); 813 DHCPV6_SET_ENTNUM(&den, enterp); 814 if (errno != 0 || currp == cp2 || 815 enterp != DHCPV6_GET_ENTNUM(&den) || 816 (*cp2 != ',' && *cp2 != '\0')) { 817 free(result); 818 *ierrnop = ITAB_BAD_NUMBER; 819 return (NULL); 820 } 821 if (*cp2 == ',') 822 cp2++; 823 vallen = strlen(cp2); 824 reslen = (vallen + 1) / 2; 825 if (hexascii_to_octet(cp2, vallen, 826 optstart + sizeof (den), &reslen) != 0) { 827 free(result); 828 *ierrnop = ITAB_BAD_NUMBER; 829 return (NULL); 830 } 831 den.den_dutype = htons(type); 832 (void) memcpy(optstart, &den, sizeof (den)); 833 length = reslen + sizeof (den); 834 break; 835 } 836 case DHCPV6_DUID_LL: { 837 duid_ll_t dll; 838 int hwtype; 839 int maclen; 840 841 if ((hwtype = get_hw_type(&currp, ierrnop)) == -2) { 842 free(result); 843 return (NULL); 844 } 845 maclen = get_mac_addr(currp, ierrnop, &dll.dll_hwtype, 846 hwtype, optstart + sizeof (dll)); 847 if (maclen == -1) { 848 free(result); 849 return (NULL); 850 } 851 dll.dll_dutype = htons(type); 852 (void) memcpy(optstart, &dll, sizeof (dll)); 853 length = maclen + sizeof (dll); 854 break; 855 } 856 default: 857 if (*currp == ',') 858 currp++; 859 vallen = strlen(currp); 860 reslen = (vallen + 1) / 2; 861 if (hexascii_to_octet(currp, vallen, optstart + 2, 862 &reslen) != 0) { 863 free(result); 864 *ierrnop = ITAB_BAD_NUMBER; 865 return (NULL); 866 } 867 optstart[0] = type >> 8; 868 optstart[1] = type; 869 length = reslen + 2; 870 break; 871 } 872 break; 873 874 case DSYM_OCTET: 875 876 if (optstart == NULL) { 877 *ierrnop = ITAB_BAD_OCTET; 878 return (NULL); 879 } 880 881 reslen = length; 882 /* Call libinetutil function to decode */ 883 if (hexascii_to_octet(value, vallen, optstart, &reslen) != 0) { 884 free(result); 885 *ierrnop = ITAB_BAD_OCTET; 886 return (NULL); 887 } 888 break; 889 890 case DSYM_IP: 891 case DSYM_IPV6: 892 893 if (optstart == NULL) { 894 *ierrnop = ITAB_BAD_IPADDR; 895 return (NULL); 896 } 897 if (n_entries % ie->ds_gran != 0) { 898 *ierrnop = ITAB_BAD_GRAN; 899 inittab_msg("inittab_encode: number of entries " 900 "not compatible with option granularity"); 901 free(result); 902 return (NULL); 903 } 904 905 for (valuep = value, i = 0; i < n_entries; i++, valuep++) { 906 907 currp = strchr(valuep, ' '); 908 if (currp != NULL) 909 *currp = '\0'; 910 if (inet_pton(ie->ds_type == DSYM_IP ? AF_INET : 911 AF_INET6, valuep, optstart) != 1) { 912 *ierrnop = ITAB_BAD_IPADDR; 913 inittab_msg("inittab_encode: bogus ip address"); 914 free(result); 915 return (NULL); 916 } 917 918 valuep = currp; 919 if (valuep == NULL) { 920 if (i < (n_entries - 1)) { 921 *ierrnop = ITAB_NOT_ENOUGH_IP; 922 inittab_msg("inittab_encode: too few " 923 "ip addresses"); 924 free(result); 925 return (NULL); 926 } 927 break; 928 } 929 optstart += type_size; 930 } 931 break; 932 933 case DSYM_NUMBER: /* FALLTHRU */ 934 case DSYM_UNUMBER8: /* FALLTHRU */ 935 case DSYM_SNUMBER8: /* FALLTHRU */ 936 case DSYM_UNUMBER16: /* FALLTHRU */ 937 case DSYM_SNUMBER16: /* FALLTHRU */ 938 case DSYM_UNUMBER24: /* FALLTHRU */ 939 case DSYM_UNUMBER32: /* FALLTHRU */ 940 case DSYM_SNUMBER32: /* FALLTHRU */ 941 case DSYM_UNUMBER64: /* FALLTHRU */ 942 case DSYM_SNUMBER64: 943 944 if (optstart == NULL) { 945 *ierrnop = ITAB_BAD_NUMBER; 946 return (NULL); 947 } 948 949 is_signed = (ie->ds_type == DSYM_SNUMBER64 || 950 ie->ds_type == DSYM_SNUMBER32 || 951 ie->ds_type == DSYM_SNUMBER16 || 952 ie->ds_type == DSYM_SNUMBER8); 953 954 if (encode_number(n_entries, type_size, is_signed, 0, value, 955 optstart, ierrnop) == B_FALSE) { 956 free(result); 957 return (NULL); 958 } 959 break; 960 961 default: 962 if (ie->ds_type == DSYM_BOOL) 963 *ierrnop = ITAB_BAD_BOOLEAN; 964 else 965 *ierrnop = ITAB_SYNTAX_ERROR; 966 967 inittab_msg("inittab_encode: unsupported type `%d'", 968 ie->ds_type); 969 970 free(result); 971 return (NULL); 972 } 973 974 /* 975 * if just_payload is false, then we need to add the option 976 * code and length fields in. 977 */ 978 if (!just_payload) { 979 if (ie->ds_dhcpv6) { 980 /* LINTED: alignment */ 981 d6o = (dhcpv6_option_t *)result; 982 d6o->d6o_code = htons(ie->ds_code); 983 d6o->d6o_len = htons(length); 984 } else { 985 result[0] = ie->ds_code; 986 result[1] = length; 987 } 988 } 989 990 if (lengthp != NULL) 991 *lengthp = length + hlen; 992 993 return (result); 994 } 995 996 /* 997 * inittab_decode_e(): converts a binary representation of a given datatype into 998 * a string; used for decoding DHCP options in a packet off 999 * the wire into ascii 1000 * 1001 * input: dhcp_symbol_t *: the entry describing the payload option 1002 * uchar_t *: the payload to convert 1003 * uint16_t: the payload length (only used if just_payload is true) 1004 * boolean_t: if false, payload is assumed to be a DHCP option 1005 * int *: set to extended error code if error occurs. 1006 * output: char *: a dynamically allocated string containing the converted data 1007 */ 1008 1009 char * 1010 inittab_decode_e(const dhcp_symbol_t *ie, const uchar_t *payload, 1011 uint16_t length, boolean_t just_payload, int *ierrnop) 1012 { 1013 char *resultp, *result = NULL; 1014 uint_t n_entries; 1015 struct in_addr in_addr; 1016 in6_addr_t in6_addr; 1017 uint8_t type_size = inittab_type_to_size(ie); 1018 boolean_t is_signed; 1019 int type; 1020 1021 *ierrnop = 0; 1022 if (type_size == 0) { 1023 *ierrnop = ITAB_SYNTAX_ERROR; 1024 return (NULL); 1025 } 1026 1027 if (!just_payload) { 1028 if (ie->ds_dhcpv6) { 1029 dhcpv6_option_t d6o; 1030 1031 (void) memcpy(&d6o, payload, sizeof (d6o)); 1032 length = ntohs(d6o.d6o_len); 1033 payload += sizeof (d6o); 1034 } else { 1035 length = payload[1]; 1036 payload += 2; 1037 } 1038 } 1039 1040 /* 1041 * figure out the number of elements to convert. note that 1042 * for ds_type NUMBER, the granularity is really 1 since the 1043 * value of ds_gran is the number of bytes in the number. 1044 */ 1045 if (ie->ds_type == DSYM_NUMBER) 1046 n_entries = MIN(ie->ds_max, length / type_size); 1047 else 1048 n_entries = MIN(ie->ds_max * ie->ds_gran, length / type_size); 1049 1050 if (n_entries == 0) 1051 n_entries = length / type_size; 1052 1053 if ((length % type_size) != 0) { 1054 inittab_msg("inittab_decode: length of string not compatible " 1055 "with option type `%i'", ie->ds_type); 1056 *ierrnop = ITAB_BAD_STRING; 1057 return (NULL); 1058 } 1059 1060 switch (ie->ds_type) { 1061 1062 case DSYM_ASCII: 1063 1064 result = malloc(n_entries + 1); 1065 if (result == NULL) { 1066 *ierrnop = ITAB_NOMEM; 1067 return (NULL); 1068 } 1069 1070 (void) memcpy(result, payload, n_entries); 1071 result[n_entries] = '\0'; 1072 break; 1073 1074 case DSYM_DOMAIN: 1075 1076 /* 1077 * A valid, decoded RFC 1035 domain string or sequence of 1078 * strings is always the same size as the encoded form, but we 1079 * allow for RFC 1035 \DDD and \\ and \. escaping. 1080 * 1081 * Decoding stops at the end of the input or the first coding 1082 * violation. Coding violations result in discarding the 1083 * offending list entry entirely. Note that we ignore the 255 1084 * character overall limit on domain names. 1085 */ 1086 if ((result = malloc(4 * length + 1)) == NULL) { 1087 *ierrnop = ITAB_NOMEM; 1088 return (NULL); 1089 } 1090 resultp = result; 1091 while (length > 0) { 1092 char *dstart; 1093 int slen; 1094 1095 dstart = resultp; 1096 while (length > 0) { 1097 slen = *payload++; 1098 length--; 1099 /* Upper two bits of length must be zero */ 1100 if ((slen & 0xc0) != 0 || slen > length) { 1101 length = 0; 1102 resultp = dstart; 1103 break; 1104 } 1105 if (resultp != dstart) 1106 *resultp++ = '.'; 1107 if (slen == 0) 1108 break; 1109 length -= slen; 1110 while (slen > 0) { 1111 if (!isascii(*payload) || 1112 !isgraph(*payload)) { 1113 (void) snprintf(resultp, 5, 1114 "\\%03d", 1115 *(unsigned char *)payload); 1116 resultp += 4; 1117 payload++; 1118 } else { 1119 if (*payload == '.' || 1120 *payload == '\\') 1121 *resultp++ = '\\'; 1122 *resultp++ = *payload++; 1123 } 1124 slen--; 1125 } 1126 } 1127 if (resultp != dstart && length > 0) 1128 *resultp++ = ' '; 1129 } 1130 *resultp = '\0'; 1131 break; 1132 1133 case DSYM_DUID: 1134 1135 /* 1136 * First, determine the type of DUID. We need at least two 1137 * octets worth of data to grab the type code. Once we have 1138 * that, the number of octets required for representation 1139 * depends on the type. 1140 */ 1141 1142 if (length < 2) { 1143 *ierrnop = ITAB_BAD_GRAN; 1144 return (NULL); 1145 } 1146 type = (payload[0] << 8) + payload[1]; 1147 switch (type) { 1148 case DHCPV6_DUID_LLT: { 1149 duid_llt_t dllt; 1150 1151 if (length < sizeof (dllt)) { 1152 *ierrnop = ITAB_BAD_GRAN; 1153 return (NULL); 1154 } 1155 (void) memcpy(&dllt, payload, sizeof (dllt)); 1156 payload += sizeof (dllt); 1157 length -= sizeof (dllt); 1158 n_entries = sizeof ("1,65535,4294967295,") + 1159 length * 3; 1160 if ((result = malloc(n_entries)) == NULL) { 1161 *ierrnop = ITAB_NOMEM; 1162 return (NULL); 1163 } 1164 (void) snprintf(result, n_entries, "%d,%u,%u,", type, 1165 ntohs(dllt.dllt_hwtype), ntohl(dllt.dllt_time)); 1166 break; 1167 } 1168 case DHCPV6_DUID_EN: { 1169 duid_en_t den; 1170 1171 if (length < sizeof (den)) { 1172 *ierrnop = ITAB_BAD_GRAN; 1173 return (NULL); 1174 } 1175 (void) memcpy(&den, payload, sizeof (den)); 1176 payload += sizeof (den); 1177 length -= sizeof (den); 1178 n_entries = sizeof ("2,4294967295,") + length * 2; 1179 if ((result = malloc(n_entries)) == NULL) { 1180 *ierrnop = ITAB_NOMEM; 1181 return (NULL); 1182 } 1183 (void) snprintf(result, n_entries, "%d,%u,", type, 1184 DHCPV6_GET_ENTNUM(&den)); 1185 break; 1186 } 1187 case DHCPV6_DUID_LL: { 1188 duid_ll_t dll; 1189 1190 if (length < sizeof (dll)) { 1191 *ierrnop = ITAB_BAD_GRAN; 1192 return (NULL); 1193 } 1194 (void) memcpy(&dll, payload, sizeof (dll)); 1195 payload += sizeof (dll); 1196 length -= sizeof (dll); 1197 n_entries = sizeof ("3,65535,") + length * 3; 1198 if ((result = malloc(n_entries)) == NULL) { 1199 *ierrnop = ITAB_NOMEM; 1200 return (NULL); 1201 } 1202 (void) snprintf(result, n_entries, "%d,%u,", type, 1203 ntohs(dll.dll_hwtype)); 1204 break; 1205 } 1206 default: 1207 n_entries = sizeof ("0,") + length * 2; 1208 if ((result = malloc(n_entries)) == NULL) { 1209 *ierrnop = ITAB_NOMEM; 1210 return (NULL); 1211 } 1212 (void) snprintf(result, n_entries, "%d,", type); 1213 break; 1214 } 1215 resultp = result + strlen(result); 1216 n_entries -= strlen(result); 1217 if (type == DHCPV6_DUID_LLT || type == DHCPV6_DUID_LL) { 1218 if (length > 0) { 1219 resultp += snprintf(resultp, 3, "%02X", 1220 *payload++); 1221 length--; 1222 } 1223 while (length-- > 0) { 1224 resultp += snprintf(resultp, 4, ":%02X", 1225 *payload++); 1226 } 1227 } else { 1228 while (length-- > 0) { 1229 resultp += snprintf(resultp, 3, "%02X", 1230 *payload++); 1231 } 1232 } 1233 break; 1234 1235 case DSYM_OCTET: 1236 1237 result = malloc(n_entries * (sizeof ("0xNN") + 1)); 1238 if (result == NULL) { 1239 *ierrnop = ITAB_NOMEM; 1240 return (NULL); 1241 } 1242 1243 result[0] = '\0'; 1244 resultp = result; 1245 if (n_entries > 0) { 1246 resultp += sprintf(resultp, "0x%02X", *payload++); 1247 n_entries--; 1248 } 1249 while (n_entries-- > 0) 1250 resultp += sprintf(resultp, " 0x%02X", *payload++); 1251 1252 break; 1253 1254 case DSYM_IP: 1255 case DSYM_IPV6: 1256 if ((length / type_size) % ie->ds_gran != 0) { 1257 *ierrnop = ITAB_BAD_GRAN; 1258 inittab_msg("inittab_decode: number of entries " 1259 "not compatible with option granularity"); 1260 return (NULL); 1261 } 1262 1263 result = malloc(n_entries * (ie->ds_type == DSYM_IP ? 1264 INET_ADDRSTRLEN : INET6_ADDRSTRLEN)); 1265 if (result == NULL) { 1266 *ierrnop = ITAB_NOMEM; 1267 return (NULL); 1268 } 1269 1270 for (resultp = result; n_entries != 0; n_entries--) { 1271 if (ie->ds_type == DSYM_IP) { 1272 (void) memcpy(&in_addr.s_addr, payload, 1273 sizeof (ipaddr_t)); 1274 (void) strcpy(resultp, inet_ntoa(in_addr)); 1275 } else { 1276 (void) memcpy(&in6_addr, payload, 1277 sizeof (in6_addr)); 1278 (void) inet_ntop(AF_INET6, &in6_addr, resultp, 1279 INET6_ADDRSTRLEN); 1280 } 1281 resultp += strlen(resultp); 1282 if (n_entries > 1) 1283 *resultp++ = ' '; 1284 payload += type_size; 1285 } 1286 *resultp = '\0'; 1287 break; 1288 1289 case DSYM_NUMBER: /* FALLTHRU */ 1290 case DSYM_UNUMBER8: /* FALLTHRU */ 1291 case DSYM_SNUMBER8: /* FALLTHRU */ 1292 case DSYM_UNUMBER16: /* FALLTHRU */ 1293 case DSYM_SNUMBER16: /* FALLTHRU */ 1294 case DSYM_UNUMBER32: /* FALLTHRU */ 1295 case DSYM_SNUMBER32: /* FALLTHRU */ 1296 case DSYM_UNUMBER64: /* FALLTHRU */ 1297 case DSYM_SNUMBER64: 1298 1299 is_signed = (ie->ds_type == DSYM_SNUMBER64 || 1300 ie->ds_type == DSYM_SNUMBER32 || 1301 ie->ds_type == DSYM_SNUMBER16 || 1302 ie->ds_type == DSYM_SNUMBER8); 1303 1304 result = malloc(n_entries * ITAB_MAX_NUMBER_LEN); 1305 if (result == NULL) { 1306 *ierrnop = ITAB_NOMEM; 1307 return (NULL); 1308 } 1309 1310 if (decode_number(n_entries, type_size, is_signed, ie->ds_gran, 1311 payload, result, ierrnop) == B_FALSE) { 1312 free(result); 1313 return (NULL); 1314 } 1315 break; 1316 1317 default: 1318 inittab_msg("inittab_decode: unsupported type `%d'", 1319 ie->ds_type); 1320 break; 1321 } 1322 1323 return (result); 1324 } 1325 1326 /* 1327 * inittab_encode(): converts a string representation of a given datatype into 1328 * binary; used for encoding ascii values into a form that 1329 * can be put in DHCP packets to be sent on the wire. 1330 * 1331 * input: dhcp_symbol_t *: the entry describing the value option 1332 * const char *: the value to convert 1333 * uint16_t *: set to the length of the binary data returned 1334 * boolean_t: if false, return a full DHCP option 1335 * output: uchar_t *: a dynamically allocated byte array with converted data 1336 */ 1337 1338 uchar_t * 1339 inittab_encode(const dhcp_symbol_t *ie, const char *value, uint16_t *lengthp, 1340 boolean_t just_payload) 1341 { 1342 int ierrno; 1343 1344 return (inittab_encode_e(ie, value, lengthp, just_payload, &ierrno)); 1345 } 1346 1347 /* 1348 * inittab_decode(): converts a binary representation of a given datatype into 1349 * a string; used for decoding DHCP options in a packet off 1350 * the wire into ascii 1351 * 1352 * input: dhcp_symbol_t *: the entry describing the payload option 1353 * uchar_t *: the payload to convert 1354 * uint16_t: the payload length (only used if just_payload is true) 1355 * boolean_t: if false, payload is assumed to be a DHCP option 1356 * output: char *: a dynamically allocated string containing the converted data 1357 */ 1358 1359 char * 1360 inittab_decode(const dhcp_symbol_t *ie, const uchar_t *payload, uint16_t length, 1361 boolean_t just_payload) 1362 { 1363 int ierrno; 1364 1365 return (inittab_decode_e(ie, payload, length, just_payload, &ierrno)); 1366 } 1367 1368 /* 1369 * inittab_msg(): prints diagnostic messages if INITTAB_DEBUG is set 1370 * 1371 * const char *: a printf-like format string 1372 * ...: arguments to the format string 1373 * output: void 1374 */ 1375 1376 /*PRINTFLIKE1*/ 1377 static void 1378 inittab_msg(const char *fmt, ...) 1379 { 1380 enum { INITTAB_MSG_CHECK, INITTAB_MSG_RETURN, INITTAB_MSG_OUTPUT }; 1381 1382 va_list ap; 1383 char buf[512]; 1384 static int action = INITTAB_MSG_CHECK; 1385 1386 /* 1387 * check DHCP_INITTAB_DEBUG the first time in; thereafter, use 1388 * the the cached result (stored in `action'). 1389 */ 1390 switch (action) { 1391 1392 case INITTAB_MSG_CHECK: 1393 1394 if (getenv("DHCP_INITTAB_DEBUG") == NULL) { 1395 action = INITTAB_MSG_RETURN; 1396 return; 1397 } 1398 1399 action = INITTAB_MSG_OUTPUT; 1400 1401 /* FALLTHRU into INITTAB_MSG_OUTPUT */ 1402 1403 case INITTAB_MSG_OUTPUT: 1404 1405 va_start(ap, fmt); 1406 1407 (void) snprintf(buf, sizeof (buf), "inittab: %s\n", fmt); 1408 (void) vfprintf(stderr, buf, ap); 1409 1410 va_end(ap); 1411 break; 1412 1413 case INITTAB_MSG_RETURN: 1414 1415 return; 1416 } 1417 } 1418 1419 /* 1420 * decode_number(): decodes a sequence of numbers from binary into ascii; 1421 * binary is coming off of the network, so it is in nbo 1422 * 1423 * input: uint8_t: the number of "granularity" numbers to decode 1424 * uint8_t: the length of each number 1425 * boolean_t: whether the numbers should be considered signed 1426 * uint8_t: the number of numbers per granularity 1427 * const uint8_t *: where to decode the numbers from 1428 * char *: where to decode the numbers to 1429 * output: boolean_t: true on successful conversion, false on failure 1430 */ 1431 1432 static boolean_t 1433 decode_number(uint8_t n_entries, uint8_t size, boolean_t is_signed, 1434 uint8_t granularity, const uint8_t *from, char *to, int *ierrnop) 1435 { 1436 uint16_t uint16; 1437 uint32_t uint32; 1438 uint64_t uint64; 1439 1440 if (granularity != 0) { 1441 if ((granularity % n_entries) != 0) { 1442 inittab_msg("decode_number: number of entries " 1443 "not compatible with option granularity"); 1444 *ierrnop = ITAB_BAD_GRAN; 1445 return (B_FALSE); 1446 } 1447 } 1448 1449 for (; n_entries != 0; n_entries--, from += size) { 1450 1451 switch (size) { 1452 1453 case 1: 1454 to += sprintf(to, is_signed ? "%d" : "%u", *from); 1455 break; 1456 1457 case 2: 1458 (void) memcpy(&uint16, from, 2); 1459 to += sprintf(to, is_signed ? "%hd" : "%hu", 1460 ntohs(uint16)); 1461 break; 1462 1463 case 3: 1464 uint32 = 0; 1465 (void) memcpy((uchar_t *)&uint32 + 1, from, 3); 1466 to += sprintf(to, is_signed ? "%ld" : "%lu", 1467 ntohl(uint32)); 1468 break; 1469 1470 case 4: 1471 (void) memcpy(&uint32, from, 4); 1472 to += sprintf(to, is_signed ? "%ld" : "%lu", 1473 ntohl(uint32)); 1474 break; 1475 1476 case 8: 1477 (void) memcpy(&uint64, from, 8); 1478 to += sprintf(to, is_signed ? "%lld" : "%llu", 1479 ntohll(uint64)); 1480 break; 1481 1482 default: 1483 *ierrnop = ITAB_BAD_NUMBER; 1484 inittab_msg("decode_number: unknown integer size `%d'", 1485 size); 1486 return (B_FALSE); 1487 } 1488 if (n_entries > 0) 1489 *to++ = ' '; 1490 } 1491 1492 *to = '\0'; 1493 return (B_TRUE); 1494 } 1495 1496 /* 1497 * encode_number(): encodes a sequence of numbers from ascii into binary; 1498 * number will end up on the wire so it needs to be in nbo 1499 * 1500 * input: uint8_t: the number of "granularity" numbers to encode 1501 * uint8_t: the length of each number 1502 * boolean_t: whether the numbers should be considered signed 1503 * uint8_t: the number of numbers per granularity 1504 * const uint8_t *: where to encode the numbers from 1505 * char *: where to encode the numbers to 1506 * int *: set to extended error code if error occurs. 1507 * output: boolean_t: true on successful conversion, false on failure 1508 */ 1509 1510 static boolean_t /* ARGSUSED */ 1511 encode_number(uint8_t n_entries, uint8_t size, boolean_t is_signed, 1512 uint8_t granularity, const char *from, uint8_t *to, int *ierrnop) 1513 { 1514 uint8_t i; 1515 uint16_t uint16; 1516 uint32_t uint32; 1517 uint64_t uint64; 1518 char *endptr; 1519 1520 if (granularity != 0) { 1521 if ((granularity % n_entries) != 0) { 1522 *ierrnop = ITAB_BAD_GRAN; 1523 inittab_msg("encode_number: number of entries " 1524 "not compatible with option granularity"); 1525 return (B_FALSE); 1526 } 1527 } 1528 1529 for (i = 0; i < n_entries; i++, from++, to += size) { 1530 1531 /* 1532 * totally obscure c factoid: it is legal to pass a 1533 * string representing a negative number to strtoul(). 1534 * in this case, strtoul() will return an unsigned 1535 * long that if cast to a long, would represent the 1536 * negative number. we take advantage of this to 1537 * cut down on code here. 1538 */ 1539 1540 errno = 0; 1541 switch (size) { 1542 1543 case 1: 1544 *to = strtoul(from, &endptr, 0); 1545 if (errno != 0 || from == endptr) { 1546 goto error; 1547 } 1548 break; 1549 1550 case 2: 1551 uint16 = htons(strtoul(from, &endptr, 0)); 1552 if (errno != 0 || from == endptr) { 1553 goto error; 1554 } 1555 (void) memcpy(to, &uint16, 2); 1556 break; 1557 1558 case 3: 1559 uint32 = htonl(strtoul(from, &endptr, 0)); 1560 if (errno != 0 || from == endptr) { 1561 goto error; 1562 } 1563 (void) memcpy(to, (uchar_t *)&uint32 + 1, 3); 1564 break; 1565 1566 case 4: 1567 uint32 = htonl(strtoul(from, &endptr, 0)); 1568 if (errno != 0 || from == endptr) { 1569 goto error; 1570 } 1571 (void) memcpy(to, &uint32, 4); 1572 break; 1573 1574 case 8: 1575 uint64 = htonll(strtoull(from, &endptr, 0)); 1576 if (errno != 0 || from == endptr) { 1577 goto error; 1578 } 1579 (void) memcpy(to, &uint64, 8); 1580 break; 1581 1582 default: 1583 inittab_msg("encode_number: unsupported integer " 1584 "size `%d'", size); 1585 return (B_FALSE); 1586 } 1587 1588 from = strchr(from, ' '); 1589 if (from == NULL) 1590 break; 1591 } 1592 1593 return (B_TRUE); 1594 1595 error: 1596 *ierrnop = ITAB_BAD_NUMBER; 1597 inittab_msg("encode_number: cannot convert to integer"); 1598 return (B_FALSE); 1599 } 1600 1601 /* 1602 * inittab_type_to_size(): given an inittab entry, returns size of one entry of 1603 * its type 1604 * 1605 * input: dhcp_symbol_t *: an entry of the given type 1606 * output: uint8_t: the size in bytes of an entry of that type 1607 */ 1608 1609 uint8_t 1610 inittab_type_to_size(const dhcp_symbol_t *ie) 1611 { 1612 switch (ie->ds_type) { 1613 1614 case DSYM_DUID: 1615 case DSYM_DOMAIN: 1616 case DSYM_ASCII: 1617 case DSYM_OCTET: 1618 case DSYM_SNUMBER8: 1619 case DSYM_UNUMBER8: 1620 1621 return (1); 1622 1623 case DSYM_SNUMBER16: 1624 case DSYM_UNUMBER16: 1625 1626 return (2); 1627 1628 case DSYM_UNUMBER24: 1629 1630 return (3); 1631 1632 case DSYM_SNUMBER32: 1633 case DSYM_UNUMBER32: 1634 case DSYM_IP: 1635 1636 return (4); 1637 1638 case DSYM_SNUMBER64: 1639 case DSYM_UNUMBER64: 1640 1641 return (8); 1642 1643 case DSYM_NUMBER: 1644 1645 return (ie->ds_gran); 1646 1647 case DSYM_IPV6: 1648 1649 return (sizeof (in6_addr_t)); 1650 } 1651 1652 return (0); 1653 } 1654 1655 /* 1656 * itabcode_to_dsymcode(): maps an inittab category code to its dsym 1657 * representation 1658 * 1659 * input: uchar_t: the inittab category code 1660 * output: dsym_category_t: the dsym category code 1661 */ 1662 1663 static dsym_category_t 1664 itabcode_to_dsymcode(uchar_t itabcode) 1665 { 1666 1667 unsigned int i; 1668 1669 for (i = 0; i < ITAB_CAT_COUNT; i++) 1670 if (category_map[i].cme_itabcode == itabcode) 1671 return (category_map[i].cme_dsymcode); 1672 1673 return (DSYM_BAD_CAT); 1674 } 1675 1676 /* 1677 * category_to_code(): maps a category name to its numeric representation 1678 * 1679 * input: const char *: the category name 1680 * output: uchar_t: its internal code (numeric representation) 1681 */ 1682 1683 static uchar_t 1684 category_to_code(const char *category) 1685 { 1686 unsigned int i; 1687 1688 for (i = 0; i < ITAB_CAT_COUNT; i++) 1689 if (strcasecmp(category_map[i].cme_name, category) == 0) 1690 return (category_map[i].cme_itabcode); 1691 1692 return (0); 1693 } 1694 1695 /* 1696 * our internal table of DHCP option values, used by inittab_verify() 1697 */ 1698 static dhcp_symbol_t inittab_table[] = 1699 { 1700 { DSYM_INTERNAL, 1024, "Hostname", DSYM_BOOL, 0, 0 }, 1701 { DSYM_INTERNAL, 1025, "LeaseNeg", DSYM_BOOL, 0, 0 }, 1702 { DSYM_INTERNAL, 1026, "EchoVC", DSYM_BOOL, 0, 0 }, 1703 { DSYM_INTERNAL, 1027, "BootPath", DSYM_ASCII, 1, 128 }, 1704 { DSYM_FIELD, 0, "Opcode", DSYM_UNUMBER8, 1, 1 }, 1705 { DSYM_FIELD, 1, "Htype", DSYM_UNUMBER8, 1, 1 }, 1706 { DSYM_FIELD, 2, "HLen", DSYM_UNUMBER8, 1, 1 }, 1707 { DSYM_FIELD, 3, "Hops", DSYM_UNUMBER8, 1, 1 }, 1708 { DSYM_FIELD, 4, "Xid", DSYM_UNUMBER32, 1, 1 }, 1709 { DSYM_FIELD, 8, "Secs", DSYM_UNUMBER16, 1, 1 }, 1710 { DSYM_FIELD, 10, "Flags", DSYM_OCTET, 1, 2 }, 1711 { DSYM_FIELD, 12, "Ciaddr", DSYM_IP, 1, 1 }, 1712 { DSYM_FIELD, 16, "Yiaddr", DSYM_IP, 1, 1 }, 1713 { DSYM_FIELD, 20, "BootSrvA", DSYM_IP, 1, 1 }, 1714 { DSYM_FIELD, 24, "Giaddr", DSYM_IP, 1, 1 }, 1715 { DSYM_FIELD, 28, "Chaddr", DSYM_OCTET, 1, 16 }, 1716 { DSYM_FIELD, 44, "BootSrvN", DSYM_ASCII, 1, 64 }, 1717 { DSYM_FIELD, 108, "BootFile", DSYM_ASCII, 1, 128 }, 1718 { DSYM_FIELD, 236, "Magic", DSYM_OCTET, 1, 4 }, 1719 { DSYM_FIELD, 240, "Options", DSYM_OCTET, 1, 60 }, 1720 { DSYM_STANDARD, 1, "Subnet", DSYM_IP, 1, 1 }, 1721 { DSYM_STANDARD, 2, "UTCoffst", DSYM_SNUMBER32, 1, 1 }, 1722 { DSYM_STANDARD, 3, "Router", DSYM_IP, 1, 0 }, 1723 { DSYM_STANDARD, 4, "Timeserv", DSYM_IP, 1, 0 }, 1724 { DSYM_STANDARD, 5, "IEN116ns", DSYM_IP, 1, 0 }, 1725 { DSYM_STANDARD, 6, "DNSserv", DSYM_IP, 1, 0 }, 1726 { DSYM_STANDARD, 7, "Logserv", DSYM_IP, 1, 0 }, 1727 { DSYM_STANDARD, 8, "Cookie", DSYM_IP, 1, 0 }, 1728 { DSYM_STANDARD, 9, "Lprserv", DSYM_IP, 1, 0 }, 1729 { DSYM_STANDARD, 10, "Impress", DSYM_IP, 1, 0 }, 1730 { DSYM_STANDARD, 11, "Resource", DSYM_IP, 1, 0 }, 1731 { DSYM_STANDARD, 12, "Hostname", DSYM_ASCII, 1, 0 }, 1732 { DSYM_STANDARD, 13, "Bootsize", DSYM_UNUMBER16, 1, 1 }, 1733 { DSYM_STANDARD, 14, "Dumpfile", DSYM_ASCII, 1, 0 }, 1734 { DSYM_STANDARD, 15, "DNSdmain", DSYM_ASCII, 1, 0 }, 1735 { DSYM_STANDARD, 16, "Swapserv", DSYM_IP, 1, 1 }, 1736 { DSYM_STANDARD, 17, "Rootpath", DSYM_ASCII, 1, 0 }, 1737 { DSYM_STANDARD, 18, "ExtendP", DSYM_ASCII, 1, 0 }, 1738 { DSYM_STANDARD, 19, "IpFwdF", DSYM_UNUMBER8, 1, 1 }, 1739 { DSYM_STANDARD, 20, "NLrouteF", DSYM_UNUMBER8, 1, 1 }, 1740 { DSYM_STANDARD, 21, "PFilter", DSYM_IP, 2, 0 }, 1741 { DSYM_STANDARD, 22, "MaxIpSiz", DSYM_UNUMBER16, 1, 1 }, 1742 { DSYM_STANDARD, 23, "IpTTL", DSYM_UNUMBER8, 1, 1 }, 1743 { DSYM_STANDARD, 24, "PathTO", DSYM_UNUMBER32, 1, 1 }, 1744 { DSYM_STANDARD, 25, "PathTbl", DSYM_UNUMBER16, 1, 0 }, 1745 { DSYM_STANDARD, 26, "MTU", DSYM_UNUMBER16, 1, 1 }, 1746 { DSYM_STANDARD, 27, "SameMtuF", DSYM_UNUMBER8, 1, 1 }, 1747 { DSYM_STANDARD, 28, "Broadcst", DSYM_IP, 1, 1 }, 1748 { DSYM_STANDARD, 29, "MaskDscF", DSYM_UNUMBER8, 1, 1 }, 1749 { DSYM_STANDARD, 30, "MaskSupF", DSYM_UNUMBER8, 1, 1 }, 1750 { DSYM_STANDARD, 31, "RDiscvyF", DSYM_UNUMBER8, 1, 1 }, 1751 { DSYM_STANDARD, 32, "RSolictS", DSYM_IP, 1, 1 }, 1752 { DSYM_STANDARD, 33, "StaticRt", DSYM_IP, 2, 0 }, 1753 { DSYM_STANDARD, 34, "TrailerF", DSYM_UNUMBER8, 1, 1 }, 1754 { DSYM_STANDARD, 35, "ArpTimeO", DSYM_UNUMBER32, 1, 1 }, 1755 { DSYM_STANDARD, 36, "EthEncap", DSYM_UNUMBER8, 1, 1 }, 1756 { DSYM_STANDARD, 37, "TcpTTL", DSYM_UNUMBER8, 1, 1 }, 1757 { DSYM_STANDARD, 38, "TcpKaInt", DSYM_UNUMBER32, 1, 1 }, 1758 { DSYM_STANDARD, 39, "TcpKaGbF", DSYM_UNUMBER8, 1, 1 }, 1759 { DSYM_STANDARD, 40, "NISdmain", DSYM_ASCII, 1, 0 }, 1760 { DSYM_STANDARD, 41, "NISservs", DSYM_IP, 1, 0 }, 1761 { DSYM_STANDARD, 42, "NTPservs", DSYM_IP, 1, 0 }, 1762 { DSYM_STANDARD, 43, "Vendor", DSYM_OCTET, 1, 0 }, 1763 { DSYM_STANDARD, 44, "NetBNms", DSYM_IP, 1, 0 }, 1764 { DSYM_STANDARD, 45, "NetBDsts", DSYM_IP, 1, 0 }, 1765 { DSYM_STANDARD, 46, "NetBNdT", DSYM_UNUMBER8, 1, 1 }, 1766 { DSYM_STANDARD, 47, "NetBScop", DSYM_ASCII, 1, 0 }, 1767 { DSYM_STANDARD, 48, "XFontSrv", DSYM_IP, 1, 0 }, 1768 { DSYM_STANDARD, 49, "XDispMgr", DSYM_IP, 1, 0 }, 1769 { DSYM_STANDARD, 50, "ReqIP", DSYM_IP, 1, 1 }, 1770 { DSYM_STANDARD, 51, "LeaseTim", DSYM_UNUMBER32, 1, 1 }, 1771 { DSYM_STANDARD, 52, "OptOvrld", DSYM_UNUMBER8, 1, 1 }, 1772 { DSYM_STANDARD, 53, "DHCPType", DSYM_UNUMBER8, 1, 1 }, 1773 { DSYM_STANDARD, 54, "ServerID", DSYM_IP, 1, 1 }, 1774 { DSYM_STANDARD, 55, "ReqList", DSYM_OCTET, 1, 0 }, 1775 { DSYM_STANDARD, 56, "Message", DSYM_ASCII, 1, 0 }, 1776 { DSYM_STANDARD, 57, "DHCP_MTU", DSYM_UNUMBER16, 1, 1 }, 1777 { DSYM_STANDARD, 58, "T1Time", DSYM_UNUMBER32, 1, 1 }, 1778 { DSYM_STANDARD, 59, "T2Time", DSYM_UNUMBER32, 1, 1 }, 1779 { DSYM_STANDARD, 60, "ClassID", DSYM_ASCII, 1, 0 }, 1780 { DSYM_STANDARD, 61, "ClientID", DSYM_OCTET, 1, 0 }, 1781 { DSYM_STANDARD, 62, "NW_dmain", DSYM_ASCII, 1, 0 }, 1782 { DSYM_STANDARD, 63, "NWIPOpts", DSYM_OCTET, 1, 128 }, 1783 { DSYM_STANDARD, 64, "NIS+dom", DSYM_ASCII, 1, 0 }, 1784 { DSYM_STANDARD, 65, "NIS+serv", DSYM_IP, 1, 0 }, 1785 { DSYM_STANDARD, 66, "TFTPsrvN", DSYM_ASCII, 1, 64 }, 1786 { DSYM_STANDARD, 67, "OptBootF", DSYM_ASCII, 1, 128 }, 1787 { DSYM_STANDARD, 68, "MblIPAgt", DSYM_IP, 1, 0 }, 1788 { DSYM_STANDARD, 69, "SMTPserv", DSYM_IP, 1, 0 }, 1789 { DSYM_STANDARD, 70, "POP3serv", DSYM_IP, 1, 0 }, 1790 { DSYM_STANDARD, 71, "NNTPserv", DSYM_IP, 1, 0 }, 1791 { DSYM_STANDARD, 72, "WWWservs", DSYM_IP, 1, 0 }, 1792 { DSYM_STANDARD, 73, "Fingersv", DSYM_IP, 1, 0 }, 1793 { DSYM_STANDARD, 74, "IRCservs", DSYM_IP, 1, 0 }, 1794 { DSYM_STANDARD, 75, "STservs", DSYM_IP, 1, 0 }, 1795 { DSYM_STANDARD, 76, "STDAservs", DSYM_IP, 1, 0 }, 1796 { DSYM_STANDARD, 77, "UserClas", DSYM_ASCII, 1, 0 }, 1797 { DSYM_STANDARD, 78, "SLP_DA", DSYM_OCTET, 1, 0 }, 1798 { DSYM_STANDARD, 79, "SLP_SS", DSYM_OCTET, 1, 0 }, 1799 { DSYM_STANDARD, 82, "AgentOpt", DSYM_OCTET, 1, 0 }, 1800 { DSYM_STANDARD, 89, "FQDN", DSYM_OCTET, 1, 0 }, 1801 { 0, 0, "", 0, 0, 0 } 1802 }; 1803