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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Dynamic Host Configuration Protocol version 6, for IPv6. Supports 29 * RFCs 3315, 3319, 3646, 3898, 4075, 4242, 4280, 4580, 4649, and 4704. 30 */ 31 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <time.h> 36 #include <sys/types.h> 37 #include <sys/socket.h> 38 #include <netinet/in.h> 39 #include <netinet/dhcp6.h> 40 #include <arpa/inet.h> 41 #include <dhcp_impl.h> 42 #include <dhcp_inittab.h> 43 44 #include "snoop.h" 45 46 static const char *mtype_to_str(uint8_t); 47 static const char *option_to_str(uint8_t); 48 static const char *duidtype_to_str(uint16_t); 49 static const char *status_to_str(uint16_t); 50 static const char *entr_to_str(uint32_t); 51 static const char *reconf_to_str(uint8_t); 52 static const char *authproto_to_str(uint8_t); 53 static const char *authalg_to_str(uint8_t, uint8_t); 54 static const char *authrdm_to_str(uint8_t); 55 static const char *cwhat_to_str(uint8_t); 56 static const char *catype_to_str(uint8_t); 57 static void show_hex(const uint8_t *, int, const char *); 58 static void show_ascii(const uint8_t *, int, const char *); 59 static void show_address(const char *, const void *); 60 static void show_options(const uint8_t *, int); 61 62 int 63 interpret_dhcpv6(int flags, const uint8_t *data, int len) 64 { 65 int olen = len; 66 char *line, *lstart; 67 dhcpv6_relay_t d6r; 68 dhcpv6_message_t d6m; 69 uint_t optlen; 70 uint16_t statuscode; 71 72 if (len <= 0) { 73 (void) strlcpy(get_sum_line(), "DHCPv6?", MAXLINE); 74 return (0); 75 } 76 if (flags & F_SUM) { 77 uint_t ias; 78 dhcpv6_option_t *d6o; 79 in6_addr_t link, peer; 80 char linkstr[INET6_ADDRSTRLEN]; 81 char peerstr[INET6_ADDRSTRLEN]; 82 83 line = lstart = get_sum_line(); 84 line += snprintf(line, MAXLINE, "DHCPv6 %s", 85 mtype_to_str(data[0])); 86 if (data[0] == DHCPV6_MSG_RELAY_FORW || 87 data[0] == DHCPV6_MSG_RELAY_REPL) { 88 if (len < sizeof (d6r)) { 89 (void) strlcpy(line, "?", 90 MAXLINE - (line - lstart)); 91 return (olen); 92 } 93 /* Not much in DHCPv6 is aligned. */ 94 (void) memcpy(&d6r, data, sizeof (d6r)); 95 (void) memcpy(&link, d6r.d6r_linkaddr, sizeof (link)); 96 (void) memcpy(&peer, d6r.d6r_peeraddr, sizeof (peer)); 97 line += snprintf(line, MAXLINE - (line - lstart), 98 " HC=%d link=%s peer=%s", d6r.d6r_hop_count, 99 inet_ntop(AF_INET6, &link, linkstr, 100 sizeof (linkstr)), 101 inet_ntop(AF_INET6, &peer, peerstr, 102 sizeof (peerstr))); 103 data += sizeof (d6r); 104 len -= sizeof (d6r); 105 } else { 106 if (len < sizeof (d6m)) { 107 (void) strlcpy(line, "?", 108 MAXLINE - (line - lstart)); 109 return (olen); 110 } 111 (void) memcpy(&d6m, data, sizeof (d6m)); 112 line += snprintf(line, MAXLINE - (line - lstart), 113 " xid=%x", DHCPV6_GET_TRANSID(&d6m)); 114 data += sizeof (d6m); 115 len -= sizeof (d6m); 116 } 117 ias = 0; 118 d6o = NULL; 119 while ((d6o = dhcpv6_find_option(data, len, d6o, 120 DHCPV6_OPT_IA_NA, NULL)) != NULL) 121 ias++; 122 if (ias > 0) 123 line += snprintf(line, MAXLINE - (line - lstart), 124 " IAs=%u", ias); 125 d6o = dhcpv6_find_option(data, len, NULL, 126 DHCPV6_OPT_STATUS_CODE, &optlen); 127 optlen -= sizeof (*d6o); 128 if (d6o != NULL && optlen >= sizeof (statuscode)) { 129 (void) memcpy(&statuscode, d6o + 1, 130 sizeof (statuscode)); 131 line += snprintf(line, MAXLINE - (line - lstart), 132 " status=%u", ntohs(statuscode)); 133 optlen -= sizeof (statuscode); 134 if (optlen > 0) { 135 line += snprintf(line, 136 MAXLINE - (line - lstart), " \"%.*s\"", 137 optlen, (char *)(d6o + 1) + 2); 138 } 139 } 140 d6o = dhcpv6_find_option(data, len, NULL, 141 DHCPV6_OPT_RELAY_MSG, &optlen); 142 optlen -= sizeof (*d6o); 143 if (d6o != NULL && optlen >= 1) { 144 line += snprintf(line, MAXLINE - (line - lstart), 145 " relay=%s", mtype_to_str(*(uint8_t *)(d6o + 1))); 146 } 147 } else if (flags & F_DTAIL) { 148 show_header("DHCPv6: ", 149 "Dynamic Host Configuration Protocol Version 6", len); 150 show_space(); 151 (void) snprintf(get_line(0, 0), get_line_remain(), 152 "Message type (msg-type) = %u (%s)", data[0], 153 mtype_to_str(data[0])); 154 if (data[0] == DHCPV6_MSG_RELAY_FORW || 155 data[0] == DHCPV6_MSG_RELAY_REPL) { 156 if (len < sizeof (d6r)) { 157 (void) strlcpy(get_line(0, 0), "Truncated", 158 get_line_remain()); 159 return (olen); 160 } 161 (void) memcpy(&d6r, data, sizeof (d6r)); 162 (void) snprintf(get_line(0, 0), get_line_remain(), 163 "Hop count = %u", d6r.d6r_hop_count); 164 show_address("Link address", d6r.d6r_linkaddr); 165 show_address("Peer address", d6r.d6r_peeraddr); 166 data += sizeof (d6r); 167 len -= sizeof (d6r); 168 } else { 169 if (len < sizeof (d6m)) { 170 (void) strlcpy(get_line(0, 0), "Truncated", 171 get_line_remain()); 172 return (olen); 173 } 174 (void) memcpy(&d6m, data, sizeof (d6m)); 175 (void) snprintf(get_line(0, 0), get_line_remain(), 176 "Transaction ID = %x", DHCPV6_GET_TRANSID(&d6m)); 177 data += sizeof (d6m); 178 len -= sizeof (d6m); 179 } 180 show_space(); 181 show_options(data, len); 182 show_space(); 183 } 184 return (olen); 185 } 186 187 static const char * 188 mtype_to_str(uint8_t mtype) 189 { 190 switch (mtype) { 191 case DHCPV6_MSG_SOLICIT: 192 return ("Solicit"); 193 case DHCPV6_MSG_ADVERTISE: 194 return ("Advertise"); 195 case DHCPV6_MSG_REQUEST: 196 return ("Request"); 197 case DHCPV6_MSG_CONFIRM: 198 return ("Confirm"); 199 case DHCPV6_MSG_RENEW: 200 return ("Renew"); 201 case DHCPV6_MSG_REBIND: 202 return ("Rebind"); 203 case DHCPV6_MSG_REPLY: 204 return ("Reply"); 205 case DHCPV6_MSG_RELEASE: 206 return ("Release"); 207 case DHCPV6_MSG_DECLINE: 208 return ("Decline"); 209 case DHCPV6_MSG_RECONFIGURE: 210 return ("Reconfigure"); 211 case DHCPV6_MSG_INFO_REQ: 212 return ("Information-Request"); 213 case DHCPV6_MSG_RELAY_FORW: 214 return ("Relay-Forward"); 215 case DHCPV6_MSG_RELAY_REPL: 216 return ("Relay-Reply"); 217 default: 218 return ("Unknown"); 219 } 220 } 221 222 static const char * 223 option_to_str(uint8_t mtype) 224 { 225 switch (mtype) { 226 case DHCPV6_OPT_CLIENTID: 227 return ("Client Identifier"); 228 case DHCPV6_OPT_SERVERID: 229 return ("Server Identifier"); 230 case DHCPV6_OPT_IA_NA: 231 return ("Identity Association for Non-temporary Addresses"); 232 case DHCPV6_OPT_IA_TA: 233 return ("Identity Association for Temporary Addresses"); 234 case DHCPV6_OPT_IAADDR: 235 return ("IA Address"); 236 case DHCPV6_OPT_ORO: 237 return ("Option Request"); 238 case DHCPV6_OPT_PREFERENCE: 239 return ("Preference"); 240 case DHCPV6_OPT_ELAPSED_TIME: 241 return ("Elapsed Time"); 242 case DHCPV6_OPT_RELAY_MSG: 243 return ("Relay Message"); 244 case DHCPV6_OPT_AUTH: 245 return ("Authentication"); 246 case DHCPV6_OPT_UNICAST: 247 return ("Server Unicast"); 248 case DHCPV6_OPT_STATUS_CODE: 249 return ("Status Code"); 250 case DHCPV6_OPT_RAPID_COMMIT: 251 return ("Rapid Commit"); 252 case DHCPV6_OPT_USER_CLASS: 253 return ("User Class"); 254 case DHCPV6_OPT_VENDOR_CLASS: 255 return ("Vendor Class"); 256 case DHCPV6_OPT_VENDOR_OPT: 257 return ("Vendor-specific Information"); 258 case DHCPV6_OPT_INTERFACE_ID: 259 return ("Interface-Id"); 260 case DHCPV6_OPT_RECONF_MSG: 261 return ("Reconfigure Message"); 262 case DHCPV6_OPT_RECONF_ACC: 263 return ("Reconfigure Accept"); 264 case DHCPV6_OPT_SIP_NAMES: 265 return ("SIP Servers Domain Name List"); 266 case DHCPV6_OPT_SIP_ADDR: 267 return ("SIP Servers IPv6 Address List"); 268 case DHCPV6_OPT_DNS_ADDR: 269 return ("DNS Recursive Name Server"); 270 case DHCPV6_OPT_DNS_SEARCH: 271 return ("Domain Search List"); 272 case DHCPV6_OPT_IA_PD: 273 return ("Identity Association for Prefix Delegation"); 274 case DHCPV6_OPT_IAPREFIX: 275 return ("IA_PD Prefix"); 276 case DHCPV6_OPT_NIS_SERVERS: 277 return ("Network Information Service Servers"); 278 case DHCPV6_OPT_NIS_DOMAIN: 279 return ("Network Information Service Domain Name"); 280 case DHCPV6_OPT_SNTP_SERVERS: 281 return ("Simple Network Time Protocol Servers"); 282 case DHCPV6_OPT_INFO_REFTIME: 283 return ("Information Refresh Time"); 284 case DHCPV6_OPT_BCMCS_SRV_D: 285 return ("BCMCS Controller Domain Name List"); 286 case DHCPV6_OPT_BCMCS_SRV_A: 287 return ("BCMCS Controller IPv6 Address"); 288 case DHCPV6_OPT_GEOCONF_CVC: 289 return ("Civic Location"); 290 case DHCPV6_OPT_REMOTE_ID: 291 return ("Relay Agent Remote-ID"); 292 case DHCPV6_OPT_SUBSCRIBER: 293 return ("Relay Agent Subscriber-ID"); 294 case DHCPV6_OPT_CLIENT_FQDN: 295 return ("Client FQDN"); 296 default: 297 return ("Unknown"); 298 } 299 } 300 301 static const char * 302 duidtype_to_str(uint16_t dtype) 303 { 304 switch (dtype) { 305 case DHCPV6_DUID_LLT: 306 return ("Link-layer Address Plus Time"); 307 case DHCPV6_DUID_EN: 308 return ("Enterprise Number"); 309 case DHCPV6_DUID_LL: 310 return ("Link-layer Address"); 311 default: 312 return ("Unknown"); 313 } 314 } 315 316 static const char * 317 status_to_str(uint16_t status) 318 { 319 switch (status) { 320 case DHCPV6_STAT_SUCCESS: 321 return ("Success"); 322 case DHCPV6_STAT_UNSPECFAIL: 323 return ("Failure, reason unspecified"); 324 case DHCPV6_STAT_NOADDRS: 325 return ("No addresses for IAs"); 326 case DHCPV6_STAT_NOBINDING: 327 return ("Client binding unavailable"); 328 case DHCPV6_STAT_NOTONLINK: 329 return ("Prefix not on link"); 330 case DHCPV6_STAT_USEMCAST: 331 return ("Use multicast"); 332 case DHCPV6_STAT_NOPREFIX: 333 return ("No prefix available"); 334 default: 335 return ("Unknown"); 336 } 337 } 338 339 static const char * 340 entr_to_str(uint32_t entr) 341 { 342 switch (entr) { 343 case DHCPV6_SUN_ENT: 344 return ("Sun Microsystems"); 345 default: 346 return ("Unknown"); 347 } 348 } 349 350 static const char * 351 reconf_to_str(uint8_t msgtype) 352 { 353 switch (msgtype) { 354 case DHCPV6_RECONF_RENEW: 355 return ("Renew"); 356 case DHCPV6_RECONF_INFO: 357 return ("Information-request"); 358 default: 359 return ("Unknown"); 360 } 361 } 362 363 static const char * 364 authproto_to_str(uint8_t aproto) 365 { 366 switch (aproto) { 367 case DHCPV6_PROTO_DELAYED: 368 return ("Delayed"); 369 case DHCPV6_PROTO_RECONFIG: 370 return ("Reconfigure Key"); 371 default: 372 return ("Unknown"); 373 } 374 } 375 376 static const char * 377 authalg_to_str(uint8_t aproto, uint8_t aalg) 378 { 379 switch (aproto) { 380 case DHCPV6_PROTO_DELAYED: 381 case DHCPV6_PROTO_RECONFIG: 382 switch (aalg) { 383 case DHCPV6_ALG_HMAC_MD5: 384 return ("HMAC-MD5 Signature"); 385 default: 386 return ("Unknown"); 387 } 388 break; 389 default: 390 return ("Unknown"); 391 } 392 } 393 394 static const char * 395 authrdm_to_str(uint8_t ardm) 396 { 397 switch (ardm) { 398 case DHCPV6_RDM_MONOCNT: 399 return ("Monotonic Counter"); 400 default: 401 return ("Unknown"); 402 } 403 } 404 405 static const char * 406 cwhat_to_str(uint8_t what) 407 { 408 switch (what) { 409 case DHCPV6_CWHAT_SERVER: 410 return ("Server"); 411 case DHCPV6_CWHAT_NETWORK: 412 return ("Network"); 413 case DHCPV6_CWHAT_CLIENT: 414 return ("Client"); 415 default: 416 return ("Unknown"); 417 } 418 } 419 420 static const char * 421 catype_to_str(uint8_t catype) 422 { 423 switch (catype) { 424 case CIVICADDR_LANG: 425 return ("Language; RFC 2277"); 426 case CIVICADDR_A1: 427 return ("National division (state)"); 428 case CIVICADDR_A2: 429 return ("County"); 430 case CIVICADDR_A3: 431 return ("City"); 432 case CIVICADDR_A4: 433 return ("City division"); 434 case CIVICADDR_A5: 435 return ("Neighborhood"); 436 case CIVICADDR_A6: 437 return ("Street group"); 438 case CIVICADDR_PRD: 439 return ("Leading street direction"); 440 case CIVICADDR_POD: 441 return ("Trailing street suffix"); 442 case CIVICADDR_STS: 443 return ("Street suffix or type"); 444 case CIVICADDR_HNO: 445 return ("House number"); 446 case CIVICADDR_HNS: 447 return ("House number suffix"); 448 case CIVICADDR_LMK: 449 return ("Landmark"); 450 case CIVICADDR_LOC: 451 return ("Additional location information"); 452 case CIVICADDR_NAM: 453 return ("Name/occupant"); 454 case CIVICADDR_PC: 455 return ("Postal Code/ZIP"); 456 case CIVICADDR_BLD: 457 return ("Building"); 458 case CIVICADDR_UNIT: 459 return ("Unit/apt/suite"); 460 case CIVICADDR_FLR: 461 return ("Floor"); 462 case CIVICADDR_ROOM: 463 return ("Room number"); 464 case CIVICADDR_TYPE: 465 return ("Place type"); 466 case CIVICADDR_PCN: 467 return ("Postal community name"); 468 case CIVICADDR_POBOX: 469 return ("Post office box"); 470 case CIVICADDR_ADDL: 471 return ("Additional code"); 472 case CIVICADDR_SEAT: 473 return ("Seat/desk"); 474 case CIVICADDR_ROAD: 475 return ("Primary road or street"); 476 case CIVICADDR_RSEC: 477 return ("Road section"); 478 case CIVICADDR_RBRA: 479 return ("Road branch"); 480 case CIVICADDR_RSBR: 481 return ("Road sub-branch"); 482 case CIVICADDR_SPRE: 483 return ("Street name pre-modifier"); 484 case CIVICADDR_SPOST: 485 return ("Street name post-modifier"); 486 case CIVICADDR_SCRIPT: 487 return ("Script"); 488 default: 489 return ("Unknown"); 490 } 491 } 492 493 static void 494 show_hex(const uint8_t *data, int len, const char *name) 495 { 496 char buffer[16 * 3 + 1]; 497 int nlen; 498 int i; 499 char sep; 500 501 nlen = strlen(name); 502 sep = '='; 503 while (len > 0) { 504 for (i = 0; i < 16 && i < len; i++) 505 (void) snprintf(buffer + 3 * i, 4, " %02x", *data++); 506 (void) snprintf(get_line(0, 0), get_line_remain(), "%*s %c%s", 507 nlen, name, sep, buffer); 508 name = ""; 509 sep = ' '; 510 len -= i; 511 } 512 } 513 514 static void 515 show_ascii(const uint8_t *data, int len, const char *name) 516 { 517 char buffer[64], *bp; 518 int nlen; 519 int i; 520 char sep; 521 522 nlen = strlen(name); 523 sep = '='; 524 while (len > 0) { 525 bp = buffer; 526 for (i = 0; i < sizeof (buffer) - 4 && len > 0; len--) { 527 if (!isascii(*data) || !isprint(*data)) 528 bp += snprintf(bp, 5, "\\%03o", *data++); 529 else 530 *bp++; 531 } 532 *bp = '\0'; 533 (void) snprintf(get_line(0, 0), get_line_remain(), 534 "%*s %c \"%s\"", nlen, name, sep, buffer); 535 sep = ' '; 536 name = ""; 537 } 538 } 539 540 static void 541 show_address(const char *addrname, const void *aptr) 542 { 543 char *hname; 544 char addrstr[INET6_ADDRSTRLEN]; 545 in6_addr_t addr; 546 547 (void) memcpy(&addr, aptr, sizeof (in6_addr_t)); 548 (void) inet_ntop(AF_INET6, &addr, addrstr, sizeof (addrstr)); 549 hname = addrtoname(AF_INET6, &addr); 550 if (strcmp(hname, addrstr) == 0) { 551 (void) snprintf(get_line(0, 0), get_line_remain(), "%s = %s", 552 addrname, addrstr); 553 } else { 554 (void) snprintf(get_line(0, 0), get_line_remain(), 555 "%s = %s (%s)", addrname, addrstr, hname); 556 } 557 } 558 559 static void 560 nest_options(const uint8_t *data, uint_t olen, char *prefix, char *title) 561 { 562 char *str, *oldnest, *oldprefix; 563 564 if (olen <= 0) 565 return; 566 oldprefix = prot_prefix; 567 oldnest = prot_nest_prefix; 568 str = malloc(strlen(prot_nest_prefix) + strlen(prot_prefix) + 1); 569 if (str == NULL) { 570 prot_nest_prefix = prot_prefix; 571 } else { 572 (void) sprintf(str, "%s%s", prot_nest_prefix, prot_prefix); 573 prot_nest_prefix = str; 574 } 575 show_header(prefix, title, 0); 576 show_options(data, olen); 577 free(str); 578 prot_prefix = oldprefix; 579 prot_nest_prefix = oldnest; 580 } 581 582 static void 583 show_options(const uint8_t *data, int len) 584 { 585 dhcpv6_option_t d6o; 586 uint_t olen, retlen; 587 uint16_t val16; 588 uint16_t type; 589 uint32_t val32; 590 const uint8_t *ostart; 591 char *str, *sp; 592 char *oldnest; 593 594 /* 595 * Be very careful with negative numbers; ANSI signed/unsigned 596 * comparison doesn't work as expected. 597 */ 598 while (len >= (signed)sizeof (d6o)) { 599 (void) memcpy(&d6o, data, sizeof (d6o)); 600 d6o.d6o_code = ntohs(d6o.d6o_code); 601 d6o.d6o_len = olen = ntohs(d6o.d6o_len); 602 (void) snprintf(get_line(0, 0), get_line_remain(), 603 "Option Code = %u (%s)", d6o.d6o_code, 604 option_to_str(d6o.d6o_code)); 605 ostart = data += sizeof (d6o); 606 len -= sizeof (d6o); 607 if (olen > len) { 608 (void) strlcpy(get_line(0, 0), "Option truncated", 609 get_line_remain()); 610 olen = len; 611 } 612 switch (d6o.d6o_code) { 613 case DHCPV6_OPT_CLIENTID: 614 case DHCPV6_OPT_SERVERID: 615 if (olen < sizeof (val16)) 616 break; 617 (void) memcpy(&val16, data, sizeof (val16)); 618 data += sizeof (val16); 619 olen -= sizeof (val16); 620 type = ntohs(val16); 621 (void) snprintf(get_line(0, 0), get_line_remain(), 622 " DUID Type = %u (%s)", type, 623 duidtype_to_str(type)); 624 if (type == DHCPV6_DUID_LLT || type == DHCPV6_DUID_LL) { 625 if (olen < sizeof (val16)) 626 break; 627 (void) memcpy(&val16, data, sizeof (val16)); 628 data += sizeof (val16); 629 olen -= sizeof (val16); 630 val16 = ntohs(val16); 631 (void) snprintf(get_line(0, 0), 632 get_line_remain(), 633 " Hardware Type = %u (%s)", val16, 634 arp_htype(type)); 635 } 636 if (type == DHCPV6_DUID_LLT) { 637 time_t timevalue; 638 639 if (olen < sizeof (val32)) 640 break; 641 (void) memcpy(&val32, data, sizeof (val32)); 642 data += sizeof (val32); 643 olen -= sizeof (val32); 644 timevalue = ntohl(val32) + DUID_TIME_BASE; 645 (void) snprintf(get_line(0, 0), 646 get_line_remain(), 647 " Time = %lu (%.24s)", ntohl(val32), 648 ctime(&timevalue)); 649 } 650 if (type == DHCPV6_DUID_EN) { 651 if (olen < sizeof (val32)) 652 break; 653 (void) memcpy(&val32, data, sizeof (val32)); 654 data += sizeof (val32); 655 olen -= sizeof (val32); 656 val32 = ntohl(val32); 657 (void) snprintf(get_line(0, 0), 658 get_line_remain(), 659 " Enterprise Number = %lu (%s)", val32, 660 entr_to_str(val32)); 661 } 662 if (olen == 0) 663 break; 664 if ((str = malloc(olen * 3)) == NULL) 665 pr_err("interpret_dhcpv6: no mem"); 666 sp = str + snprintf(str, 3, "%02x", *data++); 667 while (--olen > 0) { 668 *sp++ = (type == DHCPV6_DUID_LLT || 669 type == DHCPV6_DUID_LL) ? ':' : ' '; 670 sp = sp + snprintf(sp, 3, "%02x", *data++); 671 } 672 (void) snprintf(get_line(0, 0), get_line_remain(), 673 (type == DHCPV6_DUID_LLT || 674 type == DHCPV6_DUID_LL) ? 675 " Link Layer Address = %s" : 676 " Identifier = %s", str); 677 free(str); 678 break; 679 case DHCPV6_OPT_IA_NA: 680 case DHCPV6_OPT_IA_PD: { 681 dhcpv6_ia_na_t d6in; 682 683 if (olen < sizeof (d6in) - sizeof (d6o)) 684 break; 685 (void) memcpy(&d6in, data - sizeof (d6o), 686 sizeof (d6in)); 687 data += sizeof (d6in) - sizeof (d6o); 688 olen -= sizeof (d6in) - sizeof (d6o); 689 (void) snprintf(get_line(0, 0), get_line_remain(), 690 " IAID = %u", ntohl(d6in.d6in_iaid)); 691 (void) snprintf(get_line(0, 0), get_line_remain(), 692 " T1 (renew) = %u seconds", ntohl(d6in.d6in_t1)); 693 (void) snprintf(get_line(0, 0), get_line_remain(), 694 " T2 (rebind) = %u seconds", ntohl(d6in.d6in_t2)); 695 nest_options(data, olen, "IA: ", 696 "Identity Association"); 697 break; 698 } 699 case DHCPV6_OPT_IA_TA: { 700 dhcpv6_ia_ta_t d6it; 701 702 if (olen < sizeof (d6it) - sizeof (d6o)) 703 break; 704 (void) memcpy(&d6it, data - sizeof (d6o), 705 sizeof (d6it)); 706 data += sizeof (d6it) - sizeof (d6o); 707 olen -= sizeof (d6it) - sizeof (d6o); 708 (void) snprintf(get_line(0, 0), get_line_remain(), 709 " IAID = %u", ntohl(d6it.d6it_iaid)); 710 nest_options(data, olen, "IA: ", 711 "Identity Association"); 712 break; 713 } 714 case DHCPV6_OPT_IAADDR: { 715 dhcpv6_iaaddr_t d6ia; 716 717 if (olen < sizeof (d6ia) - sizeof (d6o)) 718 break; 719 (void) memcpy(&d6ia, data - sizeof (d6o), 720 sizeof (d6ia)); 721 data += sizeof (d6ia) - sizeof (d6o); 722 olen -= sizeof (d6ia) - sizeof (d6o); 723 show_address(" Address", &d6ia.d6ia_addr); 724 (void) snprintf(get_line(0, 0), get_line_remain(), 725 " Preferred lifetime = %u seconds", 726 ntohl(d6ia.d6ia_preflife)); 727 (void) snprintf(get_line(0, 0), get_line_remain(), 728 " Valid lifetime = %u seconds", 729 ntohl(d6ia.d6ia_vallife)); 730 nest_options(data, olen, "ADDR: ", "Address"); 731 break; 732 } 733 case DHCPV6_OPT_ORO: 734 while (olen >= sizeof (val16)) { 735 (void) memcpy(&val16, data, sizeof (val16)); 736 val16 = ntohs(val16); 737 (void) snprintf(get_line(0, 0), 738 get_line_remain(), 739 " Requested Option Code = %u (%s)", val16, 740 option_to_str(val16)); 741 data += sizeof (val16); 742 olen -= sizeof (val16); 743 } 744 break; 745 case DHCPV6_OPT_PREFERENCE: 746 if (olen > 0) { 747 (void) snprintf(get_line(0, 0), 748 get_line_remain(), 749 *data == 255 ? 750 " Preference = %u (immediate)" : 751 " Preference = %u", *data); 752 } 753 break; 754 case DHCPV6_OPT_ELAPSED_TIME: 755 if (olen == sizeof (val16)) { 756 (void) memcpy(&val16, data, sizeof (val16)); 757 val16 = ntohs(val16); 758 (void) snprintf(get_line(0, 0), 759 get_line_remain(), 760 " Elapsed Time = %u.%02u seconds", 761 val16 / 100, val16 % 100); 762 } 763 break; 764 case DHCPV6_OPT_RELAY_MSG: 765 if (olen > 0) { 766 oldnest = prot_nest_prefix; 767 prot_nest_prefix = prot_prefix; 768 retlen = interpret_dhcpv6(F_DTAIL, data, olen); 769 prot_prefix = prot_nest_prefix; 770 prot_nest_prefix = oldnest; 771 } 772 break; 773 case DHCPV6_OPT_AUTH: { 774 dhcpv6_auth_t d6a; 775 776 if (olen < DHCPV6_AUTH_SIZE - sizeof (d6o)) 777 break; 778 (void) memcpy(&d6a, data - sizeof (d6o), 779 DHCPV6_AUTH_SIZE); 780 data += DHCPV6_AUTH_SIZE - sizeof (d6o); 781 olen += DHCPV6_AUTH_SIZE - sizeof (d6o); 782 (void) snprintf(get_line(0, 0), get_line_remain(), 783 " Protocol = %u (%s)", d6a.d6a_proto, 784 authproto_to_str(d6a.d6a_proto)); 785 (void) snprintf(get_line(0, 0), get_line_remain(), 786 " Algorithm = %u (%s)", d6a.d6a_alg, 787 authalg_to_str(d6a.d6a_proto, d6a.d6a_alg)); 788 (void) snprintf(get_line(0, 0), get_line_remain(), 789 " Replay Detection Method = %u (%s)", d6a.d6a_rdm, 790 authrdm_to_str(d6a.d6a_rdm)); 791 show_hex(d6a.d6a_replay, sizeof (d6a.d6a_replay), 792 " RDM Data"); 793 if (olen > 0) 794 show_hex(data, olen, " Auth Info"); 795 break; 796 } 797 case DHCPV6_OPT_UNICAST: 798 if (olen >= sizeof (in6_addr_t)) 799 show_address(" Server Address", data); 800 break; 801 case DHCPV6_OPT_STATUS_CODE: 802 if (olen < sizeof (val16)) 803 break; 804 (void) memcpy(&val16, data, sizeof (val16)); 805 val16 = ntohs(val16); 806 (void) snprintf(get_line(0, 0), get_line_remain(), 807 " Status Code = %u (%s)", val16, 808 status_to_str(val16)); 809 data += sizeof (val16); 810 olen -= sizeof (val16); 811 if (olen > 0) 812 (void) snprintf(get_line(0, 0), 813 get_line_remain(), " Text = \"%.*s\"", 814 olen, data); 815 break; 816 case DHCPV6_OPT_VENDOR_CLASS: 817 if (olen < sizeof (val32)) 818 break; 819 (void) memcpy(&val32, data, sizeof (val32)); 820 data += sizeof (val32); 821 olen -= sizeof (val32); 822 val32 = ntohl(val32); 823 (void) snprintf(get_line(0, 0), get_line_remain(), 824 " Enterprise Number = %lu (%s)", val32, 825 entr_to_str(val32)); 826 /* FALLTHROUGH */ 827 case DHCPV6_OPT_USER_CLASS: 828 while (olen >= sizeof (val16)) { 829 (void) memcpy(&val16, data, sizeof (val16)); 830 data += sizeof (val16); 831 olen -= sizeof (val16); 832 val16 = ntohs(val16); 833 if (val16 > olen) { 834 (void) strlcpy(get_line(0, 0), 835 " Truncated class", 836 get_line_remain()); 837 val16 = olen; 838 } 839 show_hex(data, olen, " Class"); 840 data += val16; 841 olen -= val16; 842 } 843 break; 844 case DHCPV6_OPT_VENDOR_OPT: { 845 dhcpv6_option_t sd6o; 846 847 if (olen < sizeof (val32)) 848 break; 849 (void) memcpy(&val32, data, sizeof (val32)); 850 data += sizeof (val32); 851 olen -= sizeof (val32); 852 val32 = ntohl(val32); 853 (void) snprintf(get_line(0, 0), get_line_remain(), 854 " Enterprise Number = %lu (%s)", val32, 855 entr_to_str(val32)); 856 while (olen >= sizeof (sd6o)) { 857 (void) memcpy(&sd6o, data, sizeof (sd6o)); 858 sd6o.d6o_code = ntohs(sd6o.d6o_code); 859 sd6o.d6o_len = ntohs(sd6o.d6o_len); 860 (void) snprintf(get_line(0, 0), 861 get_line_remain(), 862 " Vendor Option Code = %u", d6o.d6o_code); 863 data += sizeof (d6o); 864 olen -= sizeof (d6o); 865 if (sd6o.d6o_len > olen) { 866 (void) strlcpy(get_line(0, 0), 867 " Vendor Option truncated", 868 get_line_remain()); 869 sd6o.d6o_len = olen; 870 } 871 if (sd6o.d6o_len > 0) { 872 show_hex(data, sd6o.d6o_len, 873 " Data"); 874 data += sd6o.d6o_len; 875 olen -= sd6o.d6o_len; 876 } 877 } 878 break; 879 } 880 case DHCPV6_OPT_REMOTE_ID: 881 if (olen < sizeof (val32)) 882 break; 883 (void) memcpy(&val32, data, sizeof (val32)); 884 data += sizeof (val32); 885 olen -= sizeof (val32); 886 val32 = ntohl(val32); 887 (void) snprintf(get_line(0, 0), get_line_remain(), 888 " Enterprise Number = %lu (%s)", val32, 889 entr_to_str(val32)); 890 /* FALLTHROUGH */ 891 case DHCPV6_OPT_INTERFACE_ID: 892 case DHCPV6_OPT_SUBSCRIBER: 893 if (olen > 0) 894 show_hex(data, olen, " ID"); 895 break; 896 case DHCPV6_OPT_RECONF_MSG: 897 if (olen > 0) { 898 (void) snprintf(get_line(0, 0), 899 get_line_remain(), 900 " Message Type = %u (%s)", *data, 901 reconf_to_str(*data)); 902 } 903 break; 904 case DHCPV6_OPT_SIP_NAMES: 905 case DHCPV6_OPT_DNS_SEARCH: 906 case DHCPV6_OPT_NIS_DOMAIN: 907 case DHCPV6_OPT_BCMCS_SRV_D: { 908 dhcp_symbol_t *symp; 909 char *sp2; 910 911 symp = inittab_getbycode( 912 ITAB_CAT_STANDARD | ITAB_CAT_V6, ITAB_CONS_SNOOP, 913 d6o.d6o_code); 914 if (symp != NULL) { 915 str = inittab_decode(symp, data, olen, B_TRUE); 916 if (str != NULL) { 917 sp = str; 918 do { 919 sp2 = strchr(sp, ' '); 920 if (sp2 != NULL) 921 *sp2++ = '\0'; 922 (void) snprintf(get_line(0, 0), 923 get_line_remain(), 924 " Name = %s", sp); 925 } while ((sp = sp2) != NULL); 926 free(str); 927 } 928 free(symp); 929 } 930 break; 931 } 932 case DHCPV6_OPT_SIP_ADDR: 933 case DHCPV6_OPT_DNS_ADDR: 934 case DHCPV6_OPT_NIS_SERVERS: 935 case DHCPV6_OPT_SNTP_SERVERS: 936 case DHCPV6_OPT_BCMCS_SRV_A: 937 while (olen >= sizeof (in6_addr_t)) { 938 show_address(" Address", data); 939 data += sizeof (in6_addr_t); 940 olen -= sizeof (in6_addr_t); 941 } 942 break; 943 case DHCPV6_OPT_IAPREFIX: { 944 dhcpv6_iaprefix_t d6ip; 945 946 if (olen < DHCPV6_IAPREFIX_SIZE - sizeof (d6o)) 947 break; 948 (void) memcpy(&d6ip, data - sizeof (d6o), 949 DHCPV6_IAPREFIX_SIZE); 950 data += DHCPV6_IAPREFIX_SIZE - sizeof (d6o); 951 olen -= DHCPV6_IAPREFIX_SIZE - sizeof (d6o); 952 show_address(" Prefix", d6ip.d6ip_addr); 953 (void) snprintf(get_line(0, 0), get_line_remain(), 954 " Preferred lifetime = %u seconds", 955 ntohl(d6ip.d6ip_preflife)); 956 (void) snprintf(get_line(0, 0), get_line_remain(), 957 " Valid lifetime = %u seconds", 958 ntohl(d6ip.d6ip_vallife)); 959 (void) snprintf(get_line(0, 0), get_line_remain(), 960 " Prefix length = %u", d6ip.d6ip_preflen); 961 nest_options(data, olen, "ADDR: ", "Address"); 962 break; 963 } 964 case DHCPV6_OPT_INFO_REFTIME: 965 if (olen < sizeof (val32)) 966 break; 967 (void) memcpy(&val32, data, sizeof (val32)); 968 (void) snprintf(get_line(0, 0), get_line_remain(), 969 " Refresh Time = %lu seconds", ntohl(val32)); 970 break; 971 case DHCPV6_OPT_GEOCONF_CVC: { 972 dhcpv6_civic_t d6c; 973 int solen; 974 975 if (olen < DHCPV6_CIVIC_SIZE - sizeof (d6o)) 976 break; 977 (void) memcpy(&d6c, data - sizeof (d6o), 978 DHCPV6_CIVIC_SIZE); 979 data += DHCPV6_CIVIC_SIZE - sizeof (d6o); 980 olen -= DHCPV6_CIVIC_SIZE - sizeof (d6o); 981 (void) snprintf(get_line(0, 0), get_line_remain(), 982 " What Location = %u (%s)", d6c.d6c_what, 983 cwhat_to_str(d6c.d6c_what)); 984 (void) snprintf(get_line(0, 0), get_line_remain(), 985 " Country Code = %.*s", sizeof (d6c.d6c_cc), 986 d6c.d6c_cc); 987 while (olen >= 2) { 988 (void) snprintf(get_line(0, 0), 989 get_line_remain(), 990 " CA Element = %u (%s)", *data, 991 catype_to_str(*data)); 992 solen = data[1]; 993 data += 2; 994 olen -= 2; 995 if (solen > olen) { 996 (void) strlcpy(get_line(0, 0), 997 " CA Element truncated", 998 get_line_remain()); 999 solen = olen; 1000 } 1001 if (solen > 0) { 1002 show_ascii(data, solen, " CA Data"); 1003 data += solen; 1004 olen -= solen; 1005 } 1006 } 1007 break; 1008 } 1009 case DHCPV6_OPT_CLIENT_FQDN: { 1010 dhcp_symbol_t *symp; 1011 1012 if (olen == 0) 1013 break; 1014 (void) snprintf(get_line(0, 0), get_line_remain(), 1015 " Flags = %02x", *data); 1016 (void) snprintf(get_line(0, 0), get_line_remain(), 1017 " %s", getflag(*data, DHCPV6_FQDNF_S, 1018 "Perform AAAA RR updates", "No AAAA RR updates")); 1019 (void) snprintf(get_line(0, 0), get_line_remain(), 1020 " %s", getflag(*data, DHCPV6_FQDNF_O, 1021 "Server override updates", 1022 "No server override updates")); 1023 (void) snprintf(get_line(0, 0), get_line_remain(), 1024 " %s", getflag(*data, DHCPV6_FQDNF_N, 1025 "Server performs no updates", 1026 "Server performs updates")); 1027 symp = inittab_getbycode( 1028 ITAB_CAT_STANDARD | ITAB_CAT_V6, ITAB_CONS_SNOOP, 1029 d6o.d6o_code); 1030 if (symp != NULL) { 1031 str = inittab_decode(symp, data, olen, B_TRUE); 1032 if (str != NULL) { 1033 (void) snprintf(get_line(0, 0), 1034 get_line_remain(), 1035 " FQDN = %s", str); 1036 free(str); 1037 } 1038 free(symp); 1039 } 1040 break; 1041 } 1042 } 1043 data = ostart + d6o.d6o_len; 1044 len -= d6o.d6o_len; 1045 } 1046 if (len != 0) { 1047 (void) strlcpy(get_line(0, 0), "Option entry truncated", 1048 get_line_remain()); 1049 } 1050 } 1051