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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <string.h> 27 #include <sys/types.h> 28 #include <stdlib.h> 29 #include <dhcpmsg.h> 30 #include <stddef.h> 31 #include <assert.h> 32 #include <search.h> 33 #include <alloca.h> 34 #include <limits.h> 35 #include <stropts.h> 36 #include <netinet/dhcp6.h> 37 #include <arpa/inet.h> 38 #include <sys/sysmacros.h> 39 #include <sys/sockio.h> 40 #include <inet/ip6_asp.h> 41 42 #include "states.h" 43 #include "interface.h" 44 #include "agent.h" 45 #include "packet.h" 46 #include "util.h" 47 48 int v6_sock_fd = -1; 49 int v4_sock_fd = -1; 50 51 const in6_addr_t ipv6_all_dhcp_relay_and_servers = { 52 0xff, 0x02, 0x00, 0x00, 53 0x00, 0x00, 0x00, 0x00, 54 0x00, 0x00, 0x00, 0x00, 55 0x00, 0x01, 0x00, 0x02 56 }; 57 58 /* 59 * We have our own version of this constant because dhcpagent is compiled with 60 * -lxnet. 61 */ 62 const in6_addr_t my_in6addr_any = IN6ADDR_ANY_INIT; 63 64 static void retransmit(iu_tq_t *, void *); 65 static void next_retransmission(dhcp_smach_t *, boolean_t, boolean_t); 66 static boolean_t send_pkt_internal(dhcp_smach_t *); 67 68 /* 69 * pkt_send_type(): returns an integer representing the packet's type; only 70 * for use with outbound packets. 71 * 72 * input: dhcp_pkt_t *: the packet to examine 73 * output: uchar_t: the packet type (0 if unknown) 74 */ 75 76 static uchar_t 77 pkt_send_type(const dhcp_pkt_t *dpkt) 78 { 79 const uchar_t *option; 80 81 if (dpkt->pkt_isv6) 82 return (((const dhcpv6_message_t *)dpkt->pkt)->d6m_msg_type); 83 84 /* 85 * this is a little dirty but it should get the job done. 86 * assumes that the type is in the statically allocated part 87 * of the options field. 88 */ 89 90 option = dpkt->pkt->options; 91 for (;;) { 92 if (*option == CD_PAD) { 93 option++; 94 continue; 95 } 96 if (*option == CD_END || 97 option + 2 - dpkt->pkt->options >= 98 sizeof (dpkt->pkt->options)) 99 return (0); 100 if (*option == CD_DHCP_TYPE) 101 break; 102 option++; 103 option += *option + 1; 104 } 105 106 return (option[2]); 107 } 108 109 /* 110 * pkt_recv_type(): returns an integer representing the packet's type; only 111 * for use with inbound packets. 112 * 113 * input: dhcp_pkt_t *: the packet to examine 114 * output: uchar_t: the packet type (0 if unknown) 115 */ 116 117 uchar_t 118 pkt_recv_type(const PKT_LIST *plp) 119 { 120 if (plp->isv6) 121 return (((const dhcpv6_message_t *)plp->pkt)->d6m_msg_type); 122 else if (plp->opts[CD_DHCP_TYPE] != NULL) 123 return (plp->opts[CD_DHCP_TYPE]->value[0]); 124 else 125 return (0); 126 } 127 128 /* 129 * pkt_get_xid(): returns transaction ID from a DHCP packet. 130 * 131 * input: const PKT *: the packet to examine 132 * output: uint_t: the transaction ID (0 if unknown) 133 */ 134 135 uint_t 136 pkt_get_xid(const PKT *pkt, boolean_t isv6) 137 { 138 if (pkt == NULL) 139 return (0); 140 if (isv6) 141 return (DHCPV6_GET_TRANSID((const dhcpv6_message_t *)pkt)); 142 else 143 return (pkt->xid); 144 } 145 146 /* 147 * init_pkt(): initializes and returns a packet of a given type 148 * 149 * input: dhcp_smach_t *: the state machine that will send the packet 150 * uchar_t: the packet type (DHCP message type) 151 * output: dhcp_pkt_t *: a pointer to the initialized packet; may be NULL 152 */ 153 154 dhcp_pkt_t * 155 init_pkt(dhcp_smach_t *dsmp, uchar_t type) 156 { 157 dhcp_pkt_t *dpkt = &dsmp->dsm_send_pkt; 158 dhcp_lif_t *lif = dsmp->dsm_lif; 159 dhcp_pif_t *pif = lif->lif_pif; 160 uint_t mtu = lif->lif_max; 161 uint32_t xid; 162 boolean_t isv6; 163 164 dpkt->pkt_isv6 = isv6 = pif->pif_isv6; 165 166 /* 167 * Since multiple dhcp leases may be maintained over the same pif 168 * (e.g. "hme0" and "hme0:1"), make sure the xid is unique. 169 * 170 * Note that transaction ID zero is intentionally never assigned. 171 * That's used to represent "no ID." Also note that transaction IDs 172 * are only 24 bits long in DHCPv6. 173 */ 174 175 do { 176 xid = mrand48(); 177 if (isv6) 178 xid &= 0xFFFFFF; 179 } while (xid == 0 || 180 lookup_smach_by_xid(xid, NULL, dpkt->pkt_isv6) != NULL); 181 182 if (isv6) { 183 dhcpv6_message_t *v6; 184 185 if (mtu != dpkt->pkt_max_len && 186 (v6 = realloc(dpkt->pkt, mtu)) != NULL) { 187 /* LINTED: alignment known to be correct */ 188 dpkt->pkt = (PKT *)v6; 189 dpkt->pkt_max_len = mtu; 190 } 191 192 if (sizeof (*v6) > dpkt->pkt_max_len) { 193 dhcpmsg(MSG_ERR, "init_pkt: cannot allocate v6 pkt: %u", 194 mtu); 195 return (NULL); 196 } 197 198 v6 = (dhcpv6_message_t *)dpkt->pkt; 199 dpkt->pkt_cur_len = sizeof (*v6); 200 201 (void) memset(v6, 0, dpkt->pkt_max_len); 202 203 v6->d6m_msg_type = type; 204 DHCPV6_SET_TRANSID(v6, xid); 205 206 if (dsmp->dsm_cidlen > 0 && 207 add_pkt_opt(dpkt, DHCPV6_OPT_CLIENTID, dsmp->dsm_cid, 208 dsmp->dsm_cidlen) == NULL) { 209 dhcpmsg(MSG_WARNING, 210 "init_pkt: cannot insert client ID"); 211 return (NULL); 212 } 213 214 /* For v6, time starts with the creation of a transaction */ 215 dsmp->dsm_neg_hrtime = gethrtime(); 216 dsmp->dsm_newstart_monosec = monosec(); 217 } else { 218 static uint8_t bootmagic[] = BOOTMAGIC; 219 PKT *v4; 220 221 if (mtu != dpkt->pkt_max_len && 222 (v4 = realloc(dpkt->pkt, mtu)) != NULL) { 223 dpkt->pkt = v4; 224 dpkt->pkt_max_len = mtu; 225 } 226 227 if (offsetof(PKT, options) > dpkt->pkt_max_len) { 228 dhcpmsg(MSG_ERR, "init_pkt: cannot allocate v4 pkt: %u", 229 mtu); 230 return (NULL); 231 } 232 233 v4 = dpkt->pkt; 234 dpkt->pkt_cur_len = offsetof(PKT, options); 235 236 (void) memset(v4, 0, dpkt->pkt_max_len); 237 (void) memcpy(v4->cookie, bootmagic, sizeof (bootmagic)); 238 if (pif->pif_hwlen <= sizeof (v4->chaddr)) { 239 v4->hlen = pif->pif_hwlen; 240 (void) memcpy(v4->chaddr, pif->pif_hwaddr, 241 pif->pif_hwlen); 242 } else { 243 /* 244 * The mac address does not fit in the chaddr 245 * field, thus it can not be sent to the server, 246 * thus server can not unicast the reply. Per 247 * RFC 2131 4.4.1, client can set this bit in 248 * DISCOVER/REQUEST. If the client is already 249 * in a bound state, do not set this bit, as it 250 * can respond to unicast responses from server 251 * using the 'ciaddr' address. 252 */ 253 if (type == DISCOVER || (type == REQUEST && 254 !is_bound_state(dsmp->dsm_state))) 255 v4->flags = htons(BCAST_MASK); 256 } 257 258 v4->xid = xid; 259 v4->op = BOOTREQUEST; 260 v4->htype = pif->pif_hwtype; 261 262 if (add_pkt_opt(dpkt, CD_DHCP_TYPE, &type, 1) == NULL) { 263 dhcpmsg(MSG_WARNING, 264 "init_pkt: cannot set DHCP packet type"); 265 return (NULL); 266 } 267 268 if (dsmp->dsm_cidlen > 0 && 269 add_pkt_opt(dpkt, CD_CLIENT_ID, dsmp->dsm_cid, 270 dsmp->dsm_cidlen) == NULL) { 271 dhcpmsg(MSG_WARNING, 272 "init_pkt: cannot insert client ID"); 273 return (NULL); 274 } 275 } 276 277 return (dpkt); 278 } 279 280 /* 281 * remove_pkt_opt(): removes the first instance of an option from a dhcp_pkt_t 282 * 283 * input: dhcp_pkt_t *: the packet to remove the option from 284 * uint_t: the type of option being added 285 * output: boolean_t: B_TRUE on success, B_FALSE on failure 286 * note: currently does not work with DHCPv6 suboptions, or to remove 287 * arbitrary option instances. 288 */ 289 290 boolean_t 291 remove_pkt_opt(dhcp_pkt_t *dpkt, uint_t opt_type) 292 { 293 uchar_t *raw_pkt, *raw_end, *next; 294 uint_t len; 295 296 raw_pkt = (uchar_t *)dpkt->pkt; 297 raw_end = raw_pkt + dpkt->pkt_cur_len; 298 if (dpkt->pkt_isv6) { 299 dhcpv6_option_t d6o; 300 301 raw_pkt += sizeof (dhcpv6_message_t); 302 303 opt_type = htons(opt_type); 304 while (raw_pkt + sizeof (d6o) <= raw_end) { 305 (void) memcpy(&d6o, raw_pkt, sizeof (d6o)); 306 len = ntohs(d6o.d6o_len) + sizeof (d6o); 307 if (len > raw_end - raw_pkt) 308 break; 309 next = raw_pkt + len; 310 if (d6o.d6o_code == opt_type) { 311 if (next < raw_end) { 312 (void) memmove(raw_pkt, next, 313 raw_end - next); 314 } 315 dpkt->pkt_cur_len -= len; 316 return (B_TRUE); 317 } 318 raw_pkt = next; 319 } 320 } else { 321 uchar_t *pstart, *padrun; 322 323 raw_pkt += offsetof(PKT, options); 324 pstart = raw_pkt; 325 326 if (opt_type == CD_END || opt_type == CD_PAD) 327 return (B_FALSE); 328 329 padrun = NULL; 330 while (raw_pkt + 1 <= raw_end) { 331 if (*raw_pkt == CD_END) 332 break; 333 if (*raw_pkt == CD_PAD) { 334 if (padrun == NULL) 335 padrun = raw_pkt; 336 raw_pkt++; 337 continue; 338 } 339 if (raw_pkt + 2 > raw_end) 340 break; 341 len = raw_pkt[1]; 342 if (len > raw_end - raw_pkt || len < 2) 343 break; 344 next = raw_pkt + len; 345 if (*raw_pkt == opt_type) { 346 if (next < raw_end) { 347 int toadd = (4 + ((next-pstart)&3) - 348 ((raw_pkt-pstart)&3)) & 3; 349 int torem = 4 - toadd; 350 351 if (torem != 4 && padrun != NULL && 352 (raw_pkt - padrun) >= torem) { 353 raw_pkt -= torem; 354 dpkt->pkt_cur_len -= torem; 355 } else if (toadd > 0) { 356 (void) memset(raw_pkt, CD_PAD, 357 toadd); 358 raw_pkt += toadd; 359 /* max is not an issue here */ 360 dpkt->pkt_cur_len += toadd; 361 } 362 if (raw_pkt != next) { 363 (void) memmove(raw_pkt, next, 364 raw_end - next); 365 } 366 } 367 dpkt->pkt_cur_len -= len; 368 return (B_TRUE); 369 } 370 padrun = NULL; 371 raw_pkt = next; 372 } 373 } 374 return (B_FALSE); 375 } 376 377 /* 378 * update_v6opt_len(): updates the length field of a DHCPv6 option. 379 * 380 * input: dhcpv6_option_t *: option to be updated 381 * int: number of octets to add or subtract 382 * output: boolean_t: B_TRUE on success, B_FALSE on failure 383 */ 384 385 boolean_t 386 update_v6opt_len(dhcpv6_option_t *opt, int adjust) 387 { 388 dhcpv6_option_t optval; 389 390 (void) memcpy(&optval, opt, sizeof (optval)); 391 adjust += ntohs(optval.d6o_len); 392 if (adjust < 0 || adjust > UINT16_MAX) { 393 return (B_FALSE); 394 } else { 395 optval.d6o_len = htons(adjust); 396 (void) memcpy(opt, &optval, sizeof (optval)); 397 return (B_TRUE); 398 } 399 } 400 401 /* 402 * add_pkt_opt(): adds an option to a dhcp_pkt_t 403 * 404 * input: dhcp_pkt_t *: the packet to add the option to 405 * uint_t: the type of option being added 406 * const void *: the value of that option 407 * uint_t: the length of the value of the option 408 * output: void *: pointer to the option that was added, or NULL on failure. 409 */ 410 411 void * 412 add_pkt_opt(dhcp_pkt_t *dpkt, uint_t opt_type, const void *opt_val, 413 uint_t opt_len) 414 { 415 uchar_t *raw_pkt; 416 int req_len; 417 void *optr; 418 419 raw_pkt = (uchar_t *)dpkt->pkt; 420 optr = raw_pkt + dpkt->pkt_cur_len; 421 if (dpkt->pkt_isv6) { 422 dhcpv6_option_t d6o; 423 424 req_len = opt_len + sizeof (d6o); 425 426 if (dpkt->pkt_cur_len + req_len > dpkt->pkt_max_len) { 427 dhcpmsg(MSG_WARNING, 428 "add_pkt_opt: not enough room for v6 option %u in " 429 "packet (%u + %u > %u)", opt_type, 430 dpkt->pkt_cur_len, req_len, dpkt->pkt_max_len); 431 return (NULL); 432 } 433 d6o.d6o_code = htons(opt_type); 434 d6o.d6o_len = htons(opt_len); 435 (void) memcpy(&raw_pkt[dpkt->pkt_cur_len], &d6o, sizeof (d6o)); 436 dpkt->pkt_cur_len += sizeof (d6o); 437 if (opt_len > 0) { 438 (void) memcpy(&raw_pkt[dpkt->pkt_cur_len], opt_val, 439 opt_len); 440 dpkt->pkt_cur_len += opt_len; 441 } 442 } else { 443 req_len = opt_len + 2; /* + 2 for code & length bytes */ 444 445 /* CD_END and CD_PAD options don't have a length field */ 446 if (opt_type == CD_END || opt_type == CD_PAD) { 447 req_len = 1; 448 } else if (opt_val == NULL) { 449 dhcpmsg(MSG_ERROR, "add_pkt_opt: option type %d is " 450 "missing required value", opt_type); 451 return (NULL); 452 } 453 454 if ((dpkt->pkt_cur_len + req_len) > dpkt->pkt_max_len) { 455 dhcpmsg(MSG_WARNING, 456 "add_pkt_opt: not enough room for v4 option %u in " 457 "packet", opt_type); 458 return (NULL); 459 } 460 461 raw_pkt[dpkt->pkt_cur_len++] = opt_type; 462 463 if (req_len > 1) { 464 raw_pkt[dpkt->pkt_cur_len++] = opt_len; 465 if (opt_len > 0) { 466 (void) memcpy(&raw_pkt[dpkt->pkt_cur_len], 467 opt_val, opt_len); 468 dpkt->pkt_cur_len += opt_len; 469 } 470 } 471 } 472 return (optr); 473 } 474 475 /* 476 * add_pkt_subopt(): adds an option to a dhcp_pkt_t option. DHCPv6-specific, 477 * but could be extended to IPv4 DHCP if necessary. Assumes 478 * that if the parent isn't a top-level option, the caller 479 * will adjust any upper-level options recursively using 480 * update_v6opt_len. 481 * 482 * input: dhcp_pkt_t *: the packet to add the suboption to 483 * dhcpv6_option_t *: the start of the option to that should contain 484 * it (parent) 485 * uint_t: the type of suboption being added 486 * const void *: the value of that option 487 * uint_t: the length of the value of the option 488 * output: void *: pointer to the suboption that was added, or NULL on 489 * failure. 490 */ 491 492 void * 493 add_pkt_subopt(dhcp_pkt_t *dpkt, dhcpv6_option_t *parentopt, uint_t opt_type, 494 const void *opt_val, uint_t opt_len) 495 { 496 uchar_t *raw_pkt; 497 int req_len; 498 void *optr; 499 dhcpv6_option_t d6o; 500 uchar_t *optend; 501 int olen; 502 503 if (!dpkt->pkt_isv6) 504 return (NULL); 505 506 raw_pkt = (uchar_t *)dpkt->pkt; 507 req_len = opt_len + sizeof (d6o); 508 509 if (dpkt->pkt_cur_len + req_len > dpkt->pkt_max_len) { 510 dhcpmsg(MSG_WARNING, 511 "add_pkt_subopt: not enough room for v6 suboption %u in " 512 "packet (%u + %u > %u)", opt_type, 513 dpkt->pkt_cur_len, req_len, dpkt->pkt_max_len); 514 return (NULL); 515 } 516 517 /* 518 * Update the parent option to include room for this option, 519 * and compute the insertion point. 520 */ 521 (void) memcpy(&d6o, parentopt, sizeof (d6o)); 522 olen = ntohs(d6o.d6o_len); 523 optend = (uchar_t *)(parentopt + 1) + olen; 524 olen += req_len; 525 d6o.d6o_len = htons(olen); 526 (void) memcpy(parentopt, &d6o, sizeof (d6o)); 527 528 /* 529 * If there's anything at the end to move, then move it. Also bump up 530 * the packet size. 531 */ 532 if (optend < raw_pkt + dpkt->pkt_cur_len) { 533 (void) memmove(optend + req_len, optend, 534 (raw_pkt + dpkt->pkt_cur_len) - optend); 535 } 536 dpkt->pkt_cur_len += req_len; 537 538 /* 539 * Now format the suboption and add it in. 540 */ 541 optr = optend; 542 d6o.d6o_code = htons(opt_type); 543 d6o.d6o_len = htons(opt_len); 544 (void) memcpy(optend, &d6o, sizeof (d6o)); 545 if (opt_len > 0) 546 (void) memcpy(optend + sizeof (d6o), opt_val, opt_len); 547 return (optr); 548 } 549 550 /* 551 * add_pkt_opt16(): adds an option with a 16-bit value to a dhcp_pkt_t 552 * 553 * input: dhcp_pkt_t *: the packet to add the option to 554 * uint_t: the type of option being added 555 * uint16_t: the value of that option 556 * output: void *: pointer to the option that was added, or NULL on failure. 557 */ 558 559 void * 560 add_pkt_opt16(dhcp_pkt_t *dpkt, uint_t opt_type, uint16_t opt_value) 561 { 562 return (add_pkt_opt(dpkt, opt_type, &opt_value, 2)); 563 } 564 565 /* 566 * add_pkt_opt32(): adds an option with a 32-bit value to a dhcp_pkt_t 567 * 568 * input: dhcp_pkt_t *: the packet to add the option to 569 * uint_t: the type of option being added 570 * uint32_t: the value of that option 571 * output: void *: pointer to the option that was added, or NULL on failure. 572 */ 573 574 void * 575 add_pkt_opt32(dhcp_pkt_t *dpkt, uint_t opt_type, uint32_t opt_value) 576 { 577 return (add_pkt_opt(dpkt, opt_type, &opt_value, 4)); 578 } 579 580 /* 581 * add_pkt_prl(): adds the parameter request option to the packet 582 * 583 * input: dhcp_pkt_t *: the packet to add the option to 584 * dhcp_smach_t *: state machine with request option 585 * output: void *: pointer to the option that was added, or NULL on failure. 586 */ 587 588 void * 589 add_pkt_prl(dhcp_pkt_t *dpkt, dhcp_smach_t *dsmp) 590 { 591 uint_t len; 592 593 if (dsmp->dsm_prllen == 0) 594 return (0); 595 596 if (dpkt->pkt_isv6) { 597 uint16_t *prl; 598 599 /* 600 * RFC 3315 requires that we include the option, even if we 601 * have nothing to request. 602 */ 603 if (dsmp->dsm_prllen == 0) 604 prl = NULL; 605 else 606 prl = alloca(dsmp->dsm_prllen * sizeof (uint16_t)); 607 608 for (len = 0; len < dsmp->dsm_prllen; len++) 609 prl[len] = htons(dsmp->dsm_prl[len]); 610 return (add_pkt_opt(dpkt, DHCPV6_OPT_ORO, prl, 611 len * sizeof (uint16_t))); 612 } else { 613 uint8_t *prl = alloca(dsmp->dsm_prllen); 614 615 for (len = 0; len < dsmp->dsm_prllen; len++) 616 prl[len] = dsmp->dsm_prl[len]; 617 return (add_pkt_opt(dpkt, CD_REQUEST_LIST, prl, len)); 618 } 619 } 620 621 /* 622 * add_pkt_lif(): Adds CD_REQUESTED_IP_ADDR (IPv4 DHCP) or IA_NA and IAADDR 623 * (DHCPv6) options to the packet to represent the given LIF. 624 * 625 * input: dhcp_pkt_t *: the packet to add the options to 626 * dhcp_lif_t *: the logical interface to represent 627 * int: status code (unused for IPv4 DHCP) 628 * const char *: message to include with status option, or NULL 629 * output: boolean_t: B_TRUE on success, B_FALSE on failure 630 */ 631 632 boolean_t 633 add_pkt_lif(dhcp_pkt_t *dpkt, dhcp_lif_t *lif, int status, const char *msg) 634 { 635 if (lif->lif_pif->pif_isv6) { 636 dhcp_smach_t *dsmp; 637 dhcpv6_message_t *d6m; 638 dhcpv6_ia_na_t d6in; 639 dhcpv6_iaaddr_t d6ia; 640 uint32_t iaid; 641 uint16_t *statusopt; 642 dhcpv6_option_t *d6o, *d6so; 643 uint_t olen; 644 645 /* 646 * Currently, we support just one IAID related to the primary 647 * LIF on the state machine. 648 */ 649 dsmp = lif->lif_lease->dl_smach; 650 iaid = dsmp->dsm_lif->lif_iaid; 651 iaid = htonl(iaid); 652 653 d6m = (dhcpv6_message_t *)dpkt->pkt; 654 655 /* 656 * Find or create the IA_NA needed for this LIF. If we 657 * supported IA_TA, we'd check the IFF_TEMPORARY bit here. 658 */ 659 d6o = NULL; 660 while ((d6o = dhcpv6_find_option(d6m + 1, 661 dpkt->pkt_cur_len - sizeof (*d6m), d6o, DHCPV6_OPT_IA_NA, 662 &olen)) != NULL) { 663 if (olen < sizeof (d6in)) 664 continue; 665 (void) memcpy(&d6in, d6o, sizeof (d6in)); 666 if (d6in.d6in_iaid == iaid) 667 break; 668 } 669 if (d6o == NULL) { 670 d6in.d6in_iaid = iaid; 671 d6in.d6in_t1 = 0; 672 d6in.d6in_t2 = 0; 673 d6o = add_pkt_opt(dpkt, DHCPV6_OPT_IA_NA, 674 (dhcpv6_option_t *)&d6in + 1, 675 sizeof (d6in) - sizeof (*d6o)); 676 if (d6o == NULL) 677 return (B_FALSE); 678 } 679 680 /* 681 * Now add the IAADDR suboption for this LIF. No need to 682 * search here, as we know that this is unique. 683 */ 684 d6ia.d6ia_addr = lif->lif_v6addr; 685 686 /* 687 * For Release and Decline, we zero out the lifetime. For 688 * Renew and Rebind, we report the original time as the 689 * preferred and valid lifetimes. 690 */ 691 if (d6m->d6m_msg_type == DHCPV6_MSG_RELEASE || 692 d6m->d6m_msg_type == DHCPV6_MSG_DECLINE) { 693 d6ia.d6ia_preflife = 0; 694 d6ia.d6ia_vallife = 0; 695 } else { 696 d6ia.d6ia_preflife = htonl(lif->lif_preferred.dt_start); 697 d6ia.d6ia_vallife = htonl(lif->lif_expire.dt_start); 698 } 699 d6so = add_pkt_subopt(dpkt, d6o, DHCPV6_OPT_IAADDR, 700 (dhcpv6_option_t *)&d6ia + 1, 701 sizeof (d6ia) - sizeof (*d6o)); 702 if (d6so == NULL) 703 return (B_FALSE); 704 705 /* 706 * Add a status code suboption to the IAADDR to tell the server 707 * why we're declining the address. Note that we must manually 708 * update the enclosing IA_NA, as add_pkt_subopt doesn't know 709 * how to do that. 710 */ 711 if (status != DHCPV6_STAT_SUCCESS || msg != NULL) { 712 olen = sizeof (*statusopt) + 713 (msg == NULL ? 0 : strlen(msg)); 714 statusopt = alloca(olen); 715 *statusopt = htons(status); 716 if (msg != NULL) { 717 (void) memcpy((char *)(statusopt + 1), msg, 718 olen - sizeof (*statusopt)); 719 } 720 d6so = add_pkt_subopt(dpkt, d6so, 721 DHCPV6_OPT_STATUS_CODE, statusopt, olen); 722 if (d6so != NULL) { 723 /* 724 * Update for length of suboption header and 725 * suboption contents. 726 */ 727 (void) update_v6opt_len(d6o, sizeof (*d6so) + 728 olen); 729 } 730 } 731 } else { 732 /* 733 * For DECLINE, we need to add the CD_REQUESTED_IP_ADDR option. 734 * In all other cases (RELEASE and REQUEST), we need to set 735 * ciadr. 736 */ 737 if (pkt_send_type(dpkt) == DECLINE) { 738 if (!add_pkt_opt32(dpkt, CD_REQUESTED_IP_ADDR, 739 lif->lif_addr)) 740 return (B_FALSE); 741 } else { 742 dpkt->pkt->ciaddr.s_addr = lif->lif_addr; 743 } 744 745 /* 746 * It's not too worrisome if the message fails to fit in the 747 * packet. The result will still be valid. 748 */ 749 if (msg != NULL) 750 (void) add_pkt_opt(dpkt, CD_MESSAGE, msg, 751 strlen(msg) + 1); 752 } 753 return (B_TRUE); 754 } 755 756 /* 757 * free_pkt_entry(): frees a packet list list entry 758 * 759 * input: PKT_LIST *: the packet list entry to free 760 * output: void 761 */ 762 void 763 free_pkt_entry(PKT_LIST *plp) 764 { 765 if (plp != NULL) { 766 free(plp->pkt); 767 free(plp); 768 } 769 } 770 771 /* 772 * free_pkt_list(): frees an entire packet list 773 * 774 * input: PKT_LIST **: the packet list to free 775 * output: void 776 */ 777 778 void 779 free_pkt_list(PKT_LIST **head) 780 { 781 PKT_LIST *plp; 782 783 while ((plp = *head) != NULL) { 784 remque(plp); 785 free_pkt_entry(plp); 786 } 787 } 788 789 /* 790 * send_pkt_internal(): sends a packet out on an interface 791 * 792 * input: dhcp_smach_t *: the state machine with a packet to send 793 * output: boolean_t: B_TRUE if the packet is sent, B_FALSE otherwise 794 */ 795 796 static boolean_t 797 send_pkt_internal(dhcp_smach_t *dsmp) 798 { 799 ssize_t n_bytes; 800 dhcp_lif_t *lif = dsmp->dsm_lif; 801 dhcp_pkt_t *dpkt = &dsmp->dsm_send_pkt; 802 uchar_t ptype = pkt_send_type(dpkt); 803 const char *pkt_name; 804 struct iovec iov; 805 struct msghdr msg; 806 struct cmsghdr *cmsg; 807 struct in6_pktinfo *ipi6; 808 boolean_t ismcast; 809 int msgtype; 810 811 /* 812 * Timer should not be running at the point we go to send a packet. 813 */ 814 if (dsmp->dsm_retrans_timer != -1) { 815 dhcpmsg(MSG_CRIT, "send_pkt_internal: unexpected retransmit " 816 "timer on %s", dsmp->dsm_name); 817 stop_pkt_retransmission(dsmp); 818 } 819 820 pkt_name = pkt_type_to_string(ptype, dpkt->pkt_isv6); 821 822 /* 823 * if needed, schedule a retransmission timer, then attempt to 824 * send the packet. if we fail, then log the error. our 825 * return value should indicate whether or not we were 826 * successful in sending the request, independent of whether 827 * we could schedule a timer. 828 */ 829 830 if (dsmp->dsm_send_timeout != 0) { 831 if ((dsmp->dsm_retrans_timer = iu_schedule_timer_ms(tq, 832 dsmp->dsm_send_timeout, retransmit, dsmp)) == -1) 833 dhcpmsg(MSG_WARNING, "send_pkt_internal: cannot " 834 "schedule retransmit timer for %s packet", 835 pkt_name); 836 else 837 hold_smach(dsmp); 838 } 839 840 if (dpkt->pkt_isv6) { 841 hrtime_t delta; 842 843 /* 844 * Convert current time into centiseconds since transaction 845 * started. This is what DHCPv6 expects to see in the Elapsed 846 * Time option. 847 */ 848 delta = (gethrtime() - dsmp->dsm_neg_hrtime) / 849 (NANOSEC / 100); 850 if (delta > DHCPV6_FOREVER) 851 delta = DHCPV6_FOREVER; 852 (void) remove_pkt_opt(dpkt, DHCPV6_OPT_ELAPSED_TIME); 853 (void) add_pkt_opt16(dpkt, DHCPV6_OPT_ELAPSED_TIME, 854 htons(delta)); 855 } else { 856 /* 857 * set the `pkt->secs' field depending on the type of packet. 858 * it should be zero, except in the following cases: 859 * 860 * DISCOVER: set to the number of seconds since we started 861 * trying to obtain a lease. 862 * 863 * INFORM: set to the number of seconds since we started 864 * trying to get configuration parameters. 865 * 866 * REQUEST: if in the REQUESTING state, then same value as 867 * DISCOVER, otherwise the number of seconds 868 * since we started trying to obtain a lease. 869 * 870 * we also set `dsm_newstart_monosec', to the time we sent a 871 * REQUEST or DISCOVER packet, so we know the lease start 872 * time (the DISCOVER case is for handling BOOTP servers). 873 */ 874 875 switch (ptype) { 876 877 case DISCOVER: 878 dsmp->dsm_newstart_monosec = monosec(); 879 dsmp->dsm_disc_secs = dsmp->dsm_newstart_monosec - 880 hrtime_to_monosec(dsmp->dsm_neg_hrtime); 881 dpkt->pkt->secs = htons(dsmp->dsm_disc_secs); 882 break; 883 884 case INFORM: 885 dpkt->pkt->secs = htons(monosec() - 886 hrtime_to_monosec(dsmp->dsm_neg_hrtime)); 887 break; 888 889 case REQUEST: 890 dsmp->dsm_newstart_monosec = monosec(); 891 892 if (dsmp->dsm_state == REQUESTING) { 893 dpkt->pkt->secs = htons(dsmp->dsm_disc_secs); 894 break; 895 } 896 897 dpkt->pkt->secs = htons(monosec() - 898 hrtime_to_monosec(dsmp->dsm_neg_hrtime)); 899 break; 900 901 default: 902 dpkt->pkt->secs = htons(0); 903 break; 904 } 905 } 906 907 if (dpkt->pkt_isv6) { 908 struct sockaddr_in6 sin6; 909 910 (void) memset(&iov, 0, sizeof (iov)); 911 iov.iov_base = dpkt->pkt; 912 iov.iov_len = dpkt->pkt_cur_len; 913 914 (void) memset(&msg, 0, sizeof (msg)); 915 msg.msg_name = &dsmp->dsm_send_dest.v6; 916 msg.msg_namelen = sizeof (struct sockaddr_in6); 917 msg.msg_iov = &iov; 918 msg.msg_iovlen = 1; 919 920 /* 921 * If the address that's requested cannot be reached, then fall 922 * back to the multcast address. 923 */ 924 if (IN6_IS_ADDR_MULTICAST(&dsmp->dsm_send_dest.v6.sin6_addr)) { 925 ismcast = B_TRUE; 926 } else { 927 struct dstinforeq dinfo; 928 struct strioctl str; 929 930 ismcast = B_FALSE; 931 (void) memset(&dinfo, 0, sizeof (dinfo)); 932 dinfo.dir_daddr = dsmp->dsm_send_dest.v6.sin6_addr; 933 str.ic_cmd = SIOCGDSTINFO; 934 str.ic_timout = 0; 935 str.ic_len = sizeof (dinfo); 936 str.ic_dp = (char *)&dinfo; 937 if (ioctl(v6_sock_fd, I_STR, &str) == -1) { 938 dhcpmsg(MSG_ERR, 939 "send_pkt_internal: ioctl SIOCGDSTINFO"); 940 } else if (!dinfo.dir_dreachable) { 941 char abuf[INET6_ADDRSTRLEN]; 942 943 dhcpmsg(MSG_DEBUG, "send_pkt_internal: %s is " 944 "not reachable; using multicast instead", 945 inet_ntop(AF_INET6, &dinfo.dir_daddr, abuf, 946 sizeof (abuf))); 947 sin6 = dsmp->dsm_send_dest.v6; 948 sin6.sin6_addr = 949 ipv6_all_dhcp_relay_and_servers; 950 msg.msg_name = &sin6; 951 ismcast = B_TRUE; 952 } 953 } 954 955 /* 956 * Make room for our ancillary data option as well as a dummy 957 * option used by CMSG_NXTHDR. 958 */ 959 msg.msg_controllen = sizeof (*cmsg) + _MAX_ALIGNMENT + 960 sizeof (*ipi6) + _MAX_ALIGNMENT + sizeof (*cmsg); 961 msg.msg_control = alloca(msg.msg_controllen); 962 cmsg = CMSG_FIRSTHDR(&msg); 963 cmsg->cmsg_level = IPPROTO_IPV6; 964 cmsg->cmsg_type = IPV6_PKTINFO; 965 /* LINTED: alignment */ 966 ipi6 = (struct in6_pktinfo *)CMSG_DATA(cmsg); 967 if (ismcast) 968 ipi6->ipi6_addr = lif->lif_v6addr; 969 else 970 ipi6->ipi6_addr = my_in6addr_any; 971 if (lif->lif_pif->pif_under_ipmp) 972 ipi6->ipi6_ifindex = lif->lif_pif->pif_grindex; 973 else 974 ipi6->ipi6_ifindex = lif->lif_pif->pif_index; 975 cmsg->cmsg_len = (char *)(ipi6 + 1) - (char *)cmsg; 976 977 /* 978 * Now correct the control message length. 979 */ 980 cmsg = CMSG_NXTHDR(&msg, cmsg); 981 msg.msg_controllen = (char *)cmsg - (char *)msg.msg_control; 982 983 n_bytes = sendmsg(v6_sock_fd, &msg, 0); 984 } else { 985 n_bytes = sendto(lif->lif_sock_ip_fd, dpkt->pkt, 986 dpkt->pkt_cur_len, 0, 987 (struct sockaddr *)&dsmp->dsm_send_dest.v4, 988 sizeof (struct sockaddr_in)); 989 } 990 991 if (n_bytes != dpkt->pkt_cur_len) { 992 msgtype = (n_bytes == -1) ? MSG_ERR : MSG_WARNING; 993 if (dsmp->dsm_retrans_timer == -1) 994 dhcpmsg(msgtype, "send_pkt_internal: cannot send " 995 "%s packet to server", pkt_name); 996 else 997 dhcpmsg(msgtype, "send_pkt_internal: cannot send " 998 "%s packet to server (will retry in %u seconds)", 999 pkt_name, dsmp->dsm_send_timeout / MILLISEC); 1000 return (B_FALSE); 1001 } 1002 1003 dhcpmsg(MSG_VERBOSE, "sent %s xid %x packet out %s", pkt_name, 1004 pkt_get_xid(dpkt->pkt, dpkt->pkt_isv6), dsmp->dsm_name); 1005 1006 dsmp->dsm_packet_sent++; 1007 dsmp->dsm_sent++; 1008 return (B_TRUE); 1009 } 1010 1011 /* 1012 * send_pkt(): sends a packet out 1013 * 1014 * input: dhcp_smach_t *: the state machine sending the packet 1015 * dhcp_pkt_t *: the packet to send out 1016 * in_addr_t: the destination IP address for the packet 1017 * stop_func_t *: a pointer to function to indicate when to stop 1018 * retransmitting the packet (if NULL, packet is 1019 * not retransmitted) 1020 * output: boolean_t: B_TRUE if the packet was sent, B_FALSE otherwise 1021 */ 1022 1023 boolean_t 1024 send_pkt(dhcp_smach_t *dsmp, dhcp_pkt_t *dpkt, in_addr_t dest, 1025 stop_func_t *stop) 1026 { 1027 /* 1028 * packets must be at least sizeof (PKT) or they may be dropped 1029 * by routers. pad out the packet in this case. 1030 */ 1031 1032 dpkt->pkt_cur_len = MAX(dpkt->pkt_cur_len, sizeof (PKT)); 1033 1034 dsmp->dsm_packet_sent = 0; 1035 1036 (void) memset(&dsmp->dsm_send_dest.v4, 0, 1037 sizeof (dsmp->dsm_send_dest.v4)); 1038 dsmp->dsm_send_dest.v4.sin_addr.s_addr = dest; 1039 dsmp->dsm_send_dest.v4.sin_family = AF_INET; 1040 dsmp->dsm_send_dest.v4.sin_port = htons(IPPORT_BOOTPS); 1041 dsmp->dsm_send_stop_func = stop; 1042 1043 /* 1044 * TODO: dispose of this gruesome assumption (there's no real 1045 * technical gain from doing so, but it would be cleaner) 1046 */ 1047 1048 assert(dpkt == &dsmp->dsm_send_pkt); 1049 1050 /* 1051 * clear out any packets which had been previously received 1052 * but not pulled off of the recv_packet queue. 1053 */ 1054 1055 free_pkt_list(&dsmp->dsm_recv_pkt_list); 1056 1057 if (stop == NULL) 1058 dsmp->dsm_send_timeout = 0; /* prevents retransmissions */ 1059 else 1060 next_retransmission(dsmp, B_TRUE, B_FALSE); 1061 1062 return (send_pkt_internal(dsmp)); 1063 } 1064 1065 /* 1066 * send_pkt_v6(): sends a DHCPv6 packet out 1067 * 1068 * input: dhcp_smach_t *: the state machine sending the packet 1069 * dhcp_pkt_t *: the packet to send out 1070 * in6_addr_t: the destination IPv6 address for the packet 1071 * stop_func_t *: a pointer to function to indicate when to stop 1072 * retransmitting the packet (if NULL, packet is 1073 * not retransmitted) 1074 * uint_t: Initial Retransmit Timer value 1075 * uint_t: Maximum Retransmit Timer value, zero if none 1076 * output: boolean_t: B_TRUE if the packet was sent, B_FALSE otherwise 1077 */ 1078 1079 boolean_t 1080 send_pkt_v6(dhcp_smach_t *dsmp, dhcp_pkt_t *dpkt, in6_addr_t dest, 1081 stop_func_t *stop, uint_t irt, uint_t mrt) 1082 { 1083 dsmp->dsm_packet_sent = 0; 1084 1085 (void) memset(&dsmp->dsm_send_dest.v6, 0, 1086 sizeof (dsmp->dsm_send_dest.v6)); 1087 dsmp->dsm_send_dest.v6.sin6_addr = dest; 1088 dsmp->dsm_send_dest.v6.sin6_family = AF_INET6; 1089 dsmp->dsm_send_dest.v6.sin6_port = htons(IPPORT_DHCPV6S); 1090 dsmp->dsm_send_stop_func = stop; 1091 1092 /* 1093 * TODO: dispose of this gruesome assumption (there's no real 1094 * technical gain from doing so, but it would be cleaner) 1095 */ 1096 1097 assert(dpkt == &dsmp->dsm_send_pkt); 1098 1099 /* 1100 * clear out any packets which had been previously received 1101 * but not pulled off of the recv_packet queue. 1102 */ 1103 1104 free_pkt_list(&dsmp->dsm_recv_pkt_list); 1105 1106 if (stop == NULL) { 1107 dsmp->dsm_send_timeout = 0; /* prevents retransmissions */ 1108 } else { 1109 dsmp->dsm_send_timeout = irt; 1110 dsmp->dsm_send_tcenter = mrt; 1111 /* 1112 * This is quite ugly, but RFC 3315 section 17.1.2 requires 1113 * that the RAND value for the very first retransmission of a 1114 * Solicit message is strictly greater than zero. 1115 */ 1116 next_retransmission(dsmp, B_TRUE, 1117 pkt_send_type(dpkt) == DHCPV6_MSG_SOLICIT); 1118 } 1119 1120 return (send_pkt_internal(dsmp)); 1121 } 1122 1123 /* 1124 * retransmit(): retransmits the current packet on an interface 1125 * 1126 * input: iu_tq_t *: unused 1127 * void *: the dhcp_smach_t * (state machine) sending a packet 1128 * output: void 1129 */ 1130 1131 /* ARGSUSED */ 1132 static void 1133 retransmit(iu_tq_t *tqp, void *arg) 1134 { 1135 dhcp_smach_t *dsmp = arg; 1136 1137 dsmp->dsm_retrans_timer = -1; 1138 1139 if (!verify_smach(dsmp)) 1140 return; 1141 1142 /* 1143 * Check the callback to see if we should keep sending retransmissions. 1144 * Compute the next retransmission time first, so that the callback can 1145 * cap the value if need be. (Required for DHCPv6 Confirm messages.) 1146 * 1147 * Hold the state machine across the callback so that the called 1148 * function can remove the state machine from the system without 1149 * disturbing the string used subsequently for verbose logging. The 1150 * Release function destroys the state machine when the retry count 1151 * expires. 1152 */ 1153 1154 next_retransmission(dsmp, B_FALSE, B_FALSE); 1155 hold_smach(dsmp); 1156 if (dsmp->dsm_send_stop_func(dsmp, dsmp->dsm_packet_sent)) { 1157 dhcpmsg(MSG_VERBOSE, "retransmit: time to stop on %s", 1158 dsmp->dsm_name); 1159 } else { 1160 dhcpmsg(MSG_VERBOSE, "retransmit: sending another on %s", 1161 dsmp->dsm_name); 1162 (void) send_pkt_internal(dsmp); 1163 } 1164 release_smach(dsmp); 1165 } 1166 1167 /* 1168 * stop_pkt_retransmission(): stops retransmission of last sent packet 1169 * 1170 * input: dhcp_smach_t *: the state machine to stop retransmission on 1171 * output: void 1172 */ 1173 1174 void 1175 stop_pkt_retransmission(dhcp_smach_t *dsmp) 1176 { 1177 if (dsmp->dsm_retrans_timer != -1 && 1178 iu_cancel_timer(tq, dsmp->dsm_retrans_timer, NULL) == 1) { 1179 dhcpmsg(MSG_VERBOSE, "stop_pkt_retransmission: stopped on %s", 1180 dsmp->dsm_name); 1181 dsmp->dsm_retrans_timer = -1; 1182 release_smach(dsmp); 1183 } 1184 } 1185 1186 /* 1187 * retransmit_now(): force a packet retransmission right now. Used only with 1188 * the DHCPv6 UseMulticast status code. Use with caution; 1189 * triggered retransmissions can cause packet storms. 1190 * 1191 * input: dhcp_smach_t *: the state machine to force retransmission on 1192 * output: void 1193 */ 1194 1195 void 1196 retransmit_now(dhcp_smach_t *dsmp) 1197 { 1198 stop_pkt_retransmission(dsmp); 1199 (void) send_pkt_internal(dsmp); 1200 } 1201 1202 /* 1203 * alloc_pkt_entry(): Allocates a packet list entry with a given data area 1204 * size. 1205 * 1206 * input: size_t: size of data area for packet 1207 * boolean_t: B_TRUE for IPv6 1208 * output: PKT_LIST *: allocated packet list entry 1209 */ 1210 1211 PKT_LIST * 1212 alloc_pkt_entry(size_t psize, boolean_t isv6) 1213 { 1214 PKT_LIST *plp; 1215 1216 if ((plp = calloc(1, sizeof (*plp))) == NULL || 1217 (plp->pkt = malloc(psize)) == NULL) { 1218 free(plp); 1219 plp = NULL; 1220 } else { 1221 plp->len = psize; 1222 plp->isv6 = isv6; 1223 } 1224 1225 return (plp); 1226 } 1227 1228 /* 1229 * sock_recvpkt(): read from the given socket into an allocated buffer and 1230 * handles any ancillary data options. 1231 * 1232 * input: int: file descriptor to read 1233 * PKT_LIST *: allocated buffer 1234 * output: ssize_t: number of bytes read, or -1 on error 1235 */ 1236 1237 static ssize_t 1238 sock_recvpkt(int fd, PKT_LIST *plp) 1239 { 1240 struct iovec iov; 1241 struct msghdr msg; 1242 int64_t ctrl[8192 / sizeof (int64_t)]; 1243 ssize_t msglen; 1244 1245 (void) memset(&iov, 0, sizeof (iov)); 1246 iov.iov_base = (caddr_t)plp->pkt; 1247 iov.iov_len = plp->len; 1248 1249 (void) memset(&msg, 0, sizeof (msg)); 1250 msg.msg_name = &plp->pktfrom; 1251 msg.msg_namelen = sizeof (plp->pktfrom); 1252 msg.msg_iov = &iov; 1253 msg.msg_iovlen = 1; 1254 msg.msg_control = ctrl; 1255 msg.msg_controllen = sizeof (ctrl); 1256 1257 if ((msglen = recvmsg(fd, &msg, 0)) != -1) { 1258 struct cmsghdr *cmsg; 1259 1260 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; 1261 cmsg = CMSG_NXTHDR(&msg, cmsg)) { 1262 struct sockaddr_in *sinp; 1263 struct sockaddr_in6 *sin6; 1264 struct in6_pktinfo *ipi6; 1265 1266 switch (cmsg->cmsg_level) { 1267 case IPPROTO_IP: 1268 switch (cmsg->cmsg_type) { 1269 case IP_RECVDSTADDR: 1270 sinp = (struct sockaddr_in *) 1271 &plp->pktto; 1272 sinp->sin_family = AF_INET; 1273 (void) memcpy(&sinp->sin_addr.s_addr, 1274 CMSG_DATA(cmsg), 1275 sizeof (ipaddr_t)); 1276 break; 1277 1278 case IP_RECVIF: 1279 (void) memcpy(&plp->ifindex, 1280 CMSG_DATA(cmsg), sizeof (uint_t)); 1281 break; 1282 } 1283 break; 1284 1285 case IPPROTO_IPV6: 1286 switch (cmsg->cmsg_type) { 1287 case IPV6_PKTINFO: 1288 /* LINTED: alignment */ 1289 ipi6 = (struct in6_pktinfo *) 1290 CMSG_DATA(cmsg); 1291 sin6 = (struct sockaddr_in6 *) 1292 &plp->pktto; 1293 sin6->sin6_family = AF_INET6; 1294 (void) memcpy(&sin6->sin6_addr, 1295 &ipi6->ipi6_addr, 1296 sizeof (ipi6->ipi6_addr)); 1297 (void) memcpy(&plp->ifindex, 1298 &ipi6->ipi6_ifindex, 1299 sizeof (uint_t)); 1300 break; 1301 } 1302 } 1303 } 1304 } 1305 return (msglen); 1306 } 1307 1308 /* 1309 * recv_pkt(): receives a single DHCP packet on a given file descriptor. 1310 * 1311 * input: int: the file descriptor to receive the packet from 1312 * int: the maximum packet size to allow 1313 * boolean_t: B_TRUE for IPv6 1314 * output: PKT_LIST *: the received packet 1315 */ 1316 1317 PKT_LIST * 1318 recv_pkt(int fd, int mtu, boolean_t isv6) 1319 { 1320 PKT_LIST *plp; 1321 ssize_t retval; 1322 1323 if ((plp = alloc_pkt_entry(mtu, isv6)) == NULL) { 1324 dhcpmsg(MSG_ERROR, 1325 "recv_pkt: allocation failure; dropped packet"); 1326 return (NULL); 1327 } 1328 1329 retval = sock_recvpkt(fd, plp); 1330 if (retval == -1) { 1331 dhcpmsg(MSG_ERR, "recv_pkt: recvfrom v%d failed, dropped", 1332 isv6 ? 6 : 4); 1333 goto failure; 1334 } 1335 1336 plp->len = retval; 1337 1338 if (isv6) { 1339 if (retval < sizeof (dhcpv6_message_t)) { 1340 dhcpmsg(MSG_WARNING, "recv_pkt: runt message"); 1341 goto failure; 1342 } 1343 } else { 1344 switch (dhcp_options_scan(plp, B_TRUE)) { 1345 1346 case DHCP_WRONG_MSG_TYPE: 1347 dhcpmsg(MSG_WARNING, 1348 "recv_pkt: unexpected DHCP message"); 1349 goto failure; 1350 1351 case DHCP_GARBLED_MSG_TYPE: 1352 dhcpmsg(MSG_WARNING, 1353 "recv_pkt: garbled DHCP message type"); 1354 goto failure; 1355 1356 case DHCP_BAD_OPT_OVLD: 1357 dhcpmsg(MSG_WARNING, "recv_pkt: bad option overload"); 1358 goto failure; 1359 1360 case 0: 1361 break; 1362 1363 default: 1364 dhcpmsg(MSG_WARNING, 1365 "recv_pkt: packet corrupted, dropped"); 1366 goto failure; 1367 } 1368 } 1369 return (plp); 1370 1371 failure: 1372 free_pkt_entry(plp); 1373 return (NULL); 1374 } 1375 1376 /* 1377 * pkt_v4_match(): check if a given DHCPv4 message type is in a given set 1378 * 1379 * input: uchar_t: packet type 1380 * dhcp_message_type_t: bit-wise OR of DHCP_P* values. 1381 * output: boolean_t: B_TRUE if packet type is in the set 1382 */ 1383 1384 boolean_t 1385 pkt_v4_match(uchar_t type, dhcp_message_type_t match_type) 1386 { 1387 /* 1388 * note: the ordering here allows direct indexing of the table 1389 * based on the RFC2131 packet type value passed in. 1390 */ 1391 1392 static dhcp_message_type_t type_map[] = { 1393 DHCP_PUNTYPED, DHCP_PDISCOVER, DHCP_POFFER, DHCP_PREQUEST, 1394 DHCP_PDECLINE, DHCP_PACK, DHCP_PNAK, DHCP_PRELEASE, 1395 DHCP_PINFORM 1396 }; 1397 1398 if (type < (sizeof (type_map) / sizeof (*type_map))) 1399 return ((type_map[type] & match_type) ? B_TRUE : B_FALSE); 1400 else 1401 return (B_FALSE); 1402 } 1403 1404 /* 1405 * pkt_smach_enqueue(): enqueue a packet on a given state machine 1406 * 1407 * input: dhcp_smach_t: state machine 1408 * PKT_LIST *: packet to enqueue 1409 * output: none 1410 */ 1411 1412 void 1413 pkt_smach_enqueue(dhcp_smach_t *dsmp, PKT_LIST *plp) 1414 { 1415 dhcpmsg(MSG_VERBOSE, "pkt_smach_enqueue: received %s %s packet on %s", 1416 pkt_type_to_string(pkt_recv_type(plp), dsmp->dsm_isv6), 1417 dsmp->dsm_isv6 ? "v6" : "v4", dsmp->dsm_name); 1418 1419 /* add to front of list */ 1420 insque(plp, &dsmp->dsm_recv_pkt_list); 1421 } 1422 1423 /* 1424 * next_retransmission(): computes the number of seconds until the next 1425 * retransmission, based on the algorithms in RFCs 2131 1426 * 3315. 1427 * 1428 * input: dhcp_smach_t *: state machine that needs a new timer 1429 * boolean_t: B_TRUE if this is the first time sending the message 1430 * boolean_t: B_TRUE for positive RAND values only (RFC 3315 17.1.2) 1431 * output: none 1432 */ 1433 1434 static void 1435 next_retransmission(dhcp_smach_t *dsmp, boolean_t first_send, 1436 boolean_t positive_only) 1437 { 1438 uint32_t timeout_ms; 1439 1440 if (dsmp->dsm_isv6) { 1441 double randval; 1442 1443 /* 1444 * The RFC specifies 0 to 10% jitter for the initial 1445 * solicitation, and plus or minus 10% jitter for all others. 1446 * This works out to 100 milliseconds on the shortest timer we 1447 * use. 1448 */ 1449 if (positive_only) 1450 randval = drand48() / 10.0; 1451 else 1452 randval = (drand48() - 0.5) / 5.0; 1453 1454 /* The RFC specifies doubling *after* the first transmission */ 1455 timeout_ms = dsmp->dsm_send_timeout; 1456 if (!first_send) 1457 timeout_ms *= 2; 1458 timeout_ms += (int)(randval * dsmp->dsm_send_timeout); 1459 1460 /* This checks the MRT (maximum retransmission time) */ 1461 if (dsmp->dsm_send_tcenter != 0 && 1462 timeout_ms > dsmp->dsm_send_tcenter) { 1463 timeout_ms = dsmp->dsm_send_tcenter + 1464 (uint_t)(randval * dsmp->dsm_send_tcenter); 1465 } 1466 1467 dsmp->dsm_send_timeout = timeout_ms; 1468 } else { 1469 if (dsmp->dsm_state == RENEWING || 1470 dsmp->dsm_state == REBINDING) { 1471 monosec_t mono; 1472 1473 timeout_ms = dsmp->dsm_state == RENEWING ? 1474 dsmp->dsm_leases->dl_t2.dt_start : 1475 dsmp->dsm_leases->dl_lifs->lif_expire.dt_start; 1476 timeout_ms += dsmp->dsm_curstart_monosec; 1477 mono = monosec(); 1478 if (mono > timeout_ms) 1479 timeout_ms = 0; 1480 else 1481 timeout_ms -= mono; 1482 timeout_ms *= MILLISEC / 2; 1483 } else { 1484 /* 1485 * Start at 4, and increase by a factor of 2 up to 64. 1486 */ 1487 if (first_send) { 1488 timeout_ms = 4 * MILLISEC; 1489 } else { 1490 timeout_ms = MIN(dsmp->dsm_send_tcenter << 1, 1491 64 * MILLISEC); 1492 } 1493 } 1494 1495 dsmp->dsm_send_tcenter = timeout_ms; 1496 1497 /* 1498 * At each iteration, jitter the timeout by some fraction of a 1499 * second. 1500 */ 1501 dsmp->dsm_send_timeout = timeout_ms + 1502 ((lrand48() % (2 * MILLISEC)) - MILLISEC); 1503 } 1504 } 1505 1506 /* 1507 * dhcp_ip_default(): open and bind the default IP sockets used for I/O and 1508 * interface control. 1509 * 1510 * input: none 1511 * output: B_TRUE on success 1512 */ 1513 1514 boolean_t 1515 dhcp_ip_default(void) 1516 { 1517 int on = 1; 1518 1519 if ((v4_sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { 1520 dhcpmsg(MSG_ERR, 1521 "dhcp_ip_default: unable to create IPv4 socket"); 1522 return (B_FALSE); 1523 } 1524 1525 if (setsockopt(v4_sock_fd, IPPROTO_IP, IP_RECVDSTADDR, &on, 1526 sizeof (on)) == -1) { 1527 dhcpmsg(MSG_ERR, 1528 "dhcp_ip_default: unable to enable IP_RECVDSTADDR"); 1529 return (B_FALSE); 1530 } 1531 1532 if (setsockopt(v4_sock_fd, IPPROTO_IP, IP_RECVIF, &on, sizeof (on)) == 1533 -1) { 1534 dhcpmsg(MSG_ERR, 1535 "dhcp_ip_default: unable to enable IP_RECVIF"); 1536 return (B_FALSE); 1537 } 1538 1539 if (!bind_sock(v4_sock_fd, IPPORT_BOOTPC, INADDR_ANY)) { 1540 dhcpmsg(MSG_ERROR, 1541 "dhcp_ip_default: unable to bind IPv4 socket to port %d", 1542 IPPORT_BOOTPC); 1543 return (B_FALSE); 1544 } 1545 1546 if (iu_register_event(eh, v4_sock_fd, POLLIN, dhcp_acknak_global, 1547 NULL) == -1) { 1548 dhcpmsg(MSG_WARNING, "dhcp_ip_default: cannot register to " 1549 "receive IPv4 broadcasts"); 1550 return (B_FALSE); 1551 } 1552 1553 if ((v6_sock_fd = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) { 1554 dhcpmsg(MSG_ERR, 1555 "dhcp_ip_default: unable to create IPv6 socket"); 1556 return (B_FALSE); 1557 } 1558 1559 if (setsockopt(v6_sock_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, 1560 sizeof (on)) == -1) { 1561 dhcpmsg(MSG_ERR, 1562 "dhcp_ip_default: unable to enable IPV6_RECVPKTINFO"); 1563 return (B_FALSE); 1564 } 1565 1566 if (!bind_sock_v6(v6_sock_fd, IPPORT_DHCPV6C, NULL)) { 1567 dhcpmsg(MSG_ERROR, 1568 "dhcp_ip_default: unable to bind IPv6 socket to port %d", 1569 IPPORT_DHCPV6C); 1570 return (B_FALSE); 1571 } 1572 1573 if (iu_register_event(eh, v6_sock_fd, POLLIN, dhcp_acknak_global, 1574 NULL) == -1) { 1575 dhcpmsg(MSG_WARNING, "dhcp_ip_default: cannot register to " 1576 "receive IPv6 packets"); 1577 return (B_FALSE); 1578 } 1579 1580 return (B_TRUE); 1581 } 1582
Indexes created Thu Nov 26 17:27:16 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.