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 * Copyright (c) 2016-2017, Chris Fraire <cfraire@me.com>.
25 *
26 * REQUESTING state of the client state machine.
27 */
28
29 #include <stdlib.h>
30 #include <string.h>
31 #include <search.h>
32 #include <sys/types.h>
33 #include <netinet/in.h>
34 #include <netinet/dhcp.h>
35 #include <netinet/udp.h>
36 #include <netinet/ip_var.h>
37 #include <netinet/udp_var.h>
38 #include <arpa/inet.h>
39 #include <dhcp_hostconf.h>
40 #include <dhcpagent_util.h>
41 #include <dhcpmsg.h>
42
43 #include "states.h"
44 #include "util.h"
45 #include "packet.h"
46 #include "interface.h"
47 #include "agent.h"
48
49 static PKT_LIST *select_best(dhcp_smach_t *);
50 static void request_failed(dhcp_smach_t *);
51 static stop_func_t stop_requesting;
52
53 /*
54 * send_v6_request(): sends a DHCPv6 Request message and switches to REQUESTING
55 * state. This is a separate function because a NoBinding
56 * response can also cause us to do this.
57 *
58 * input: dhcp_smach_t *: the state machine
59 * output: none
60 */
61
62 void
send_v6_request(dhcp_smach_t * dsmp)63 send_v6_request(dhcp_smach_t *dsmp)
64 {
65 dhcp_pkt_t *dpkt;
66 dhcpv6_ia_na_t d6in;
67
68 dpkt = init_pkt(dsmp, DHCPV6_MSG_REQUEST);
69 (void) add_pkt_opt(dpkt, DHCPV6_OPT_SERVERID, dsmp->dsm_serverid,
70 dsmp->dsm_serveridlen);
71
72 /* Add an IA_NA option for our controlling LIF */
73 d6in.d6in_iaid = htonl(dsmp->dsm_lif->lif_iaid);
74 d6in.d6in_t1 = htonl(0);
75 d6in.d6in_t2 = htonl(0);
76 (void) add_pkt_opt(dpkt, DHCPV6_OPT_IA_NA,
77 (dhcpv6_option_t *)&d6in + 1,
78 sizeof (d6in) - sizeof (dhcpv6_option_t));
79
80 /* Add required Option Request option */
81 (void) add_pkt_prl(dpkt, dsmp);
82
83 (void) send_pkt_v6(dsmp, dpkt, dsmp->dsm_server, stop_requesting,
84 DHCPV6_REQ_TIMEOUT, DHCPV6_REQ_MAX_RT);
85
86 /* For DHCPv6, state switch cannot fail */
87 (void) set_smach_state(dsmp, REQUESTING);
88 }
89
90 /*
91 * server_unicast_option(): determines the server address to use based on the
92 * DHCPv6 Server Unicast option present in the given
93 * packet.
94 *
95 * input: dhcp_smach_t *: the state machine
96 * PKT_LIST *: received packet (Advertisement or Reply)
97 * output: none
98 */
99
100 void
server_unicast_option(dhcp_smach_t * dsmp,PKT_LIST * plp)101 server_unicast_option(dhcp_smach_t *dsmp, PKT_LIST *plp)
102 {
103 const dhcpv6_option_t *d6o;
104 uint_t olen;
105
106 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_UNICAST, &olen);
107 olen -= sizeof (*d6o);
108 /* LINTED: no consequent */
109 if (d6o == NULL) {
110 /* No Server Unicast option specified */
111 } else if (olen != sizeof (dsmp->dsm_server)) {
112 dhcpmsg(MSG_WARNING, "server_unicast_option: %s has Server "
113 "Unicast option with bad length",
114 pkt_type_to_string(pkt_recv_type(plp), B_TRUE));
115 } else {
116 in6_addr_t addr;
117
118 (void) memcpy(&addr, d6o + 1, olen);
119 if (IN6_IS_ADDR_UNSPECIFIED(&addr)) {
120 dhcpmsg(MSG_WARNING, "server_unicast_option: unicast "
121 "to unspecified address ignored");
122 } else if (IN6_IS_ADDR_MULTICAST(&addr)) {
123 dhcpmsg(MSG_WARNING, "server_unicast_option: unicast "
124 "to multicast address ignored");
125 } else if (IN6_IS_ADDR_V4COMPAT(&addr) ||
126 IN6_IS_ADDR_V4MAPPED(&addr)) {
127 dhcpmsg(MSG_WARNING, "server_unicast_option: unicast "
128 "to invalid address ignored");
129 } else {
130 dsmp->dsm_server = addr;
131 }
132 }
133 }
134
135 /*
136 * dhcp_requesting(): checks if OFFER packets to come in from DHCP servers.
137 * if so, chooses the best one, sends a REQUEST to the
138 * server and registers an event handler to receive
139 * the ACK/NAK. This may be called by the offer timer or
140 * by any function that wants to check for offers after
141 * canceling that timer.
142 *
143 * input: iu_tq_t *: timer queue; non-NULL if this is a timer callback
144 * void *: the state machine receiving OFFER packets
145 * output: void
146 */
147
148 void
dhcp_requesting(iu_tq_t * tqp,void * arg)149 dhcp_requesting(iu_tq_t *tqp, void *arg)
150 {
151 dhcp_smach_t *dsmp = arg;
152 dhcp_pkt_t *dpkt;
153 PKT_LIST *offer;
154 lease_t lease;
155 boolean_t isv6 = dsmp->dsm_isv6;
156
157 /*
158 * We assume here that if tqp is set, then this means we're being
159 * called back by the offer wait timer. If so, then drop our hold
160 * on the state machine. Otherwise, cancel the timer if it's running.
161 */
162 if (tqp != NULL) {
163 dhcpmsg(MSG_VERBOSE,
164 "dhcp_requesting: offer wait timer on v%d %s",
165 isv6 ? 6 : 4, dsmp->dsm_name);
166 dsmp->dsm_offer_timer = -1;
167 if (!verify_smach(dsmp))
168 return;
169 } else {
170 cancel_offer_timer(dsmp);
171 }
172
173 /*
174 * select the best OFFER; all others pitched.
175 */
176
177 offer = select_best(dsmp);
178 if (offer == NULL) {
179
180 dhcpmsg(MSG_VERBOSE,
181 "no OFFERs/Advertisements on %s, waiting...",
182 dsmp->dsm_name);
183
184 /*
185 * no acceptable OFFERs have come in. reschedule
186 * ourself for callback.
187 */
188
189 if ((dsmp->dsm_offer_timer = iu_schedule_timer(tq,
190 dsmp->dsm_offer_wait, dhcp_requesting, dsmp)) == -1) {
191
192 /*
193 * ugh. the best we can do at this point is
194 * revert back to INIT and wait for a user to
195 * restart us.
196 */
197
198 dhcpmsg(MSG_WARNING, "dhcp_requesting: cannot "
199 "reschedule callback, reverting to INIT state on "
200 "%s", dsmp->dsm_name);
201
202 stop_pkt_retransmission(dsmp);
203 (void) set_smach_state(dsmp, INIT);
204 dsmp->dsm_dflags |= DHCP_IF_FAILED;
205 ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
206 } else {
207 hold_smach(dsmp);
208 }
209
210 return;
211 }
212
213 /*
214 * With IPv4, the DHCPREQUEST packet we're about to transmit implicitly
215 * declines all other offers we've received. We can no longer use any
216 * cached offers, so we must discard them now. With DHCPv6, though,
217 * we're permitted to hang onto the advertisements (offers) and try
218 * them if the preferred one doesn't pan out.
219 */
220 if (!isv6)
221 free_pkt_list(&dsmp->dsm_recv_pkt_list);
222
223 /* stop collecting packets. */
224
225 stop_pkt_retransmission(dsmp);
226
227 /*
228 * For IPv4, check to see whether we got an OFFER or a BOOTP packet.
229 * If we got a BOOTP packet, go to the BOUND state now.
230 */
231 if (!isv6 && offer->opts[CD_DHCP_TYPE] == NULL) {
232 free_pkt_list(&dsmp->dsm_recv_pkt_list);
233
234 if (!set_smach_state(dsmp, REQUESTING)) {
235 dhcp_restart(dsmp);
236 return;
237 }
238
239 if (!dhcp_bound(dsmp, offer)) {
240 dhcpmsg(MSG_WARNING, "dhcp_requesting: dhcp_bound "
241 "failed for %s", dsmp->dsm_name);
242 dhcp_restart(dsmp);
243 return;
244 }
245
246 return;
247 }
248
249 save_domainname(dsmp, offer);
250
251 if (isv6) {
252 const char *estr, *msg;
253 const dhcpv6_option_t *d6o;
254 uint_t olen, msglen;
255
256 /* If there's a Status Code option, print the message */
257 d6o = dhcpv6_pkt_option(offer, NULL, DHCPV6_OPT_STATUS_CODE,
258 &olen);
259 (void) dhcpv6_status_code(d6o, olen, &estr, &msg, &msglen);
260 print_server_msg(dsmp, msg, msglen);
261
262 /* Copy in the Server ID (guaranteed to be present now) */
263 if (!save_server_id(dsmp, offer))
264 goto failure;
265
266 /*
267 * Determine how to send this message. If the Advertisement
268 * (offer) has the unicast option, then use the address
269 * specified in the option. Otherwise, send via multicast.
270 */
271 server_unicast_option(dsmp, offer);
272
273 send_v6_request(dsmp);
274 } else {
275 /* if we got a message from the server, display it. */
276 if (offer->opts[CD_MESSAGE] != NULL) {
277 print_server_msg(dsmp,
278 (char *)offer->opts[CD_MESSAGE]->value,
279 offer->opts[CD_MESSAGE]->len);
280 }
281
282 /*
283 * assemble a DHCPREQUEST, with the ciaddr field set to 0,
284 * since we got here from the INIT state.
285 */
286
287 dpkt = init_pkt(dsmp, REQUEST);
288
289 /*
290 * Grab the lease out of the OFFER; we know it's valid because
291 * select_best() already checked. The max dhcp message size
292 * option is set to the interface max, minus the size of the
293 * udp and ip headers.
294 */
295
296 (void) memcpy(&lease, offer->opts[CD_LEASE_TIME]->value,
297 sizeof (lease_t));
298
299 (void) add_pkt_opt32(dpkt, CD_LEASE_TIME, lease);
300 (void) add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE,
301 htons(dsmp->dsm_lif->lif_max - sizeof (struct udpiphdr)));
302 (void) add_pkt_opt32(dpkt, CD_REQUESTED_IP_ADDR,
303 offer->pkt->yiaddr.s_addr);
304 (void) add_pkt_opt(dpkt, CD_SERVER_ID,
305 offer->opts[CD_SERVER_ID]->value,
306 offer->opts[CD_SERVER_ID]->len);
307
308 if (class_id_len != 0) {
309 (void) add_pkt_opt(dpkt, CD_CLASS_ID, class_id,
310 class_id_len);
311 }
312 (void) add_pkt_prl(dpkt, dsmp);
313
314 /*
315 * dsm_reqhost was set for this state machine in
316 * dhcp_selecting() if the DF_REQUEST_HOSTNAME option set and a
317 * host name was found
318 */
319 if (!dhcp_add_fqdn_opt(dpkt, dsmp) &&
320 dsmp->dsm_reqhost != NULL) {
321 (void) add_pkt_opt(dpkt, CD_HOSTNAME, dsmp->dsm_reqhost,
322 strlen(dsmp->dsm_reqhost));
323 }
324 (void) add_pkt_opt(dpkt, CD_END, NULL, 0);
325
326 /*
327 * send out the REQUEST, trying retransmissions. either a NAK
328 * or too many REQUEST attempts will revert us to SELECTING.
329 */
330
331 if (!set_smach_state(dsmp, REQUESTING)) {
332 dhcpmsg(MSG_ERROR, "dhcp_requesting: cannot switch to "
333 "REQUESTING state; reverting to INIT on %s",
334 dsmp->dsm_name);
335 goto failure;
336 }
337
338 (void) send_pkt(dsmp, dpkt, htonl(INADDR_BROADCAST),
339 stop_requesting);
340 }
341
342 /* all done with the offer */
343 free_pkt_entry(offer);
344
345 return;
346
347 failure:
348 dsmp->dsm_dflags |= DHCP_IF_FAILED;
349 (void) set_smach_state(dsmp, INIT);
350 ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
351 free_pkt_list(&dsmp->dsm_recv_pkt_list);
352 }
353
354 /*
355 * compute_points_v6(): compute the number of "points" for a given v6
356 * advertisement.
357 *
358 * input: const PKT_LIST *: packet to inspect
359 * const dhcp_smach_t *: state machine that received the packet
360 * output: int: -1 to discard, -2 to accept immediately, >=0 for preference.
361 */
362
363 static int
compute_points_v6(const PKT_LIST * pkt,const dhcp_smach_t * dsmp)364 compute_points_v6(const PKT_LIST *pkt, const dhcp_smach_t *dsmp)
365 {
366 char abuf[INET6_ADDRSTRLEN];
367 int points = 0;
368 const dhcpv6_option_t *d6o, *d6so;
369 uint_t olen, solen;
370 int i;
371 const char *estr, *msg;
372 uint_t msglen;
373
374 /*
375 * Look through the packet contents. Valid packets must have our
376 * client ID and a server ID, which has already been checked by
377 * dhcp_packet_lif. Bonus points for each option.
378 */
379
380 /* One point for having a valid message. */
381 points++;
382
383 /*
384 * Per RFC 3315, if the Advertise message says, "yes, we have no
385 * bananas today," then ignore the entire message. (Why it's just
386 * _this_ error and no other is a bit of a mystery, but a standard is a
387 * standard.)
388 */
389 d6o = dhcpv6_pkt_option(pkt, NULL, DHCPV6_OPT_STATUS_CODE, &olen);
390 if (dhcpv6_status_code(d6o, olen, &estr, &msg, &msglen) ==
391 DHCPV6_STAT_NOADDRS) {
392 dhcpmsg(MSG_INFO,
393 "discard advertisement from %s on %s: no address status",
394 inet_ntop(AF_INET6,
395 &((struct sockaddr_in6 *)&pkt->pktfrom)->sin6_addr,
396 abuf, sizeof (abuf)), dsmp->dsm_name);
397 return (-1);
398 }
399
400 /* Two points for each batch of offered IP addresses */
401 d6o = NULL;
402 while ((d6o = dhcpv6_pkt_option(pkt, d6o, DHCPV6_OPT_IA_NA,
403 &olen)) != NULL) {
404
405 /*
406 * Note that it's possible to have "no bananas" on an
407 * individual IA. We must look for that here.
408 *
409 * RFC 3315 section 17.1.3 does not refer to the status code
410 * embedded in the IA itself. However, the TAHI test suite
411 * checks for this specific case. Because it's extremely
412 * unlikely that any usable server is going to report that it
413 * has no addresses on a network using DHCP for address
414 * assignment, we allow such messages to be dropped.
415 */
416 d6so = dhcpv6_find_option(
417 (const char *)d6o + sizeof (dhcpv6_ia_na_t),
418 olen - sizeof (dhcpv6_ia_na_t), NULL,
419 DHCPV6_OPT_STATUS_CODE, &solen);
420 if (dhcpv6_status_code(d6so, solen, &estr, &msg, &msglen) ==
421 DHCPV6_STAT_NOADDRS)
422 return (-1);
423 points += 2;
424 }
425
426 /*
427 * Note that we drive on in the case where there are no addresses. The
428 * hope here is that we'll at least get some useful configuration
429 * information.
430 */
431
432 /* One point for each requested option */
433 for (i = 0; i < dsmp->dsm_prllen; i++) {
434 if (dhcpv6_pkt_option(pkt, NULL, dsmp->dsm_prl[i], NULL) !=
435 NULL)
436 points++;
437 }
438
439 /*
440 * Ten points for each point of "preference." Note: the value 255 is
441 * special. It means "stop right now and select this server."
442 */
443 d6o = dhcpv6_pkt_option(pkt, NULL, DHCPV6_OPT_PREFERENCE, &olen);
444 if (d6o != NULL && olen == sizeof (*d6o) + 1) {
445 int pref = *(const uchar_t *)(d6o + 1);
446
447 if (pref == 255)
448 return (-2);
449 points += 10 * pref;
450 }
451
452 return (points);
453 }
454
455 /*
456 * compute_points_v4(): compute the number of "points" for a given v4 offer.
457 *
458 * input: const PKT_LIST *: packet to inspect
459 * const dhcp_smach_t *: state machine that received the packet
460 * output: int: -1 to discard, >=0 for preference.
461 */
462
463 static int
compute_points_v4(const PKT_LIST * pkt)464 compute_points_v4(const PKT_LIST *pkt)
465 {
466 int points = 0;
467
468 if (pkt->opts[CD_DHCP_TYPE] == NULL) {
469 dhcpmsg(MSG_VERBOSE, "compute_points_v4: valid BOOTP reply");
470 goto valid_offer;
471 }
472
473 if (pkt->opts[CD_LEASE_TIME] == NULL) {
474 dhcpmsg(MSG_WARNING, "compute_points_v4: OFFER without lease "
475 "time");
476 return (-1);
477 }
478
479 if (pkt->opts[CD_LEASE_TIME]->len != sizeof (lease_t)) {
480 dhcpmsg(MSG_WARNING, "compute_points_v4: OFFER with garbled "
481 "lease time");
482 return (-1);
483 }
484
485 if (pkt->opts[CD_SERVER_ID] == NULL) {
486 dhcpmsg(MSG_WARNING, "compute_points_v4: OFFER without server "
487 "id");
488 return (-1);
489 }
490
491 if (pkt->opts[CD_SERVER_ID]->len != sizeof (ipaddr_t)) {
492 dhcpmsg(MSG_WARNING, "compute_points_v4: OFFER with garbled "
493 "server id");
494 return (-1);
495 }
496
497 /* valid DHCP OFFER. see if we got our parameters. */
498 dhcpmsg(MSG_VERBOSE, "compute_points_v4: valid OFFER packet");
499 points += 30;
500
501 valid_offer:
502 if (pkt->rfc1048)
503 points += 5;
504
505 /*
506 * also could be faked, though more difficult because the encapsulation
507 * is hard to encode on a BOOTP server; plus there's not as much real
508 * estate in the packet for options, so it's likely this option would
509 * get dropped.
510 */
511
512 if (pkt->opts[CD_VENDOR_SPEC] != NULL)
513 points += 80;
514
515 if (pkt->opts[CD_SUBNETMASK] != NULL)
516 points++;
517
518 if (pkt->opts[CD_ROUTER] != NULL)
519 points++;
520
521 if (pkt->opts[CD_HOSTNAME] != NULL)
522 points += 5;
523
524 return (points);
525 }
526
527 /*
528 * select_best(): selects the best offer from a list of IPv4 OFFER packets or
529 * DHCPv6 Advertise packets.
530 *
531 * input: dhcp_smach_t *: state machine with enqueued offers
532 * output: PKT_LIST *: the best packet, or NULL if none are acceptable
533 */
534
535 static PKT_LIST *
select_best(dhcp_smach_t * dsmp)536 select_best(dhcp_smach_t *dsmp)
537 {
538 PKT_LIST *current = dsmp->dsm_recv_pkt_list;
539 PKT_LIST *next, *best = NULL;
540 int points, best_points = -1;
541
542 /*
543 * pick out the best offer. point system.
544 * what's important for IPv4?
545 *
546 * 0) DHCP (30 points)
547 * 1) no option overload
548 * 2) encapsulated vendor option (80 points)
549 * 3) non-null sname and siaddr fields
550 * 4) non-null file field
551 * 5) hostname (5 points)
552 * 6) subnetmask (1 point)
553 * 7) router (1 point)
554 */
555
556 for (; current != NULL; current = next) {
557 next = current->next;
558
559 points = current->isv6 ?
560 compute_points_v6(current, dsmp) :
561 compute_points_v4(current);
562
563 /*
564 * Just discard any unacceptable entries we encounter.
565 */
566 if (points == -1) {
567 remque(current);
568 free_pkt_entry(current);
569 continue;
570 }
571
572 dhcpmsg(MSG_DEBUG, "select_best: OFFER had %d points", points);
573
574 /* Special case: stop now and select */
575 if (points == -2) {
576 best = current;
577 break;
578 }
579
580 if (points >= best_points) {
581 best_points = points;
582 best = current;
583 }
584 }
585
586 if (best != NULL) {
587 dhcpmsg(MSG_DEBUG, "select_best: most points: %d", best_points);
588 remque(best);
589 } else {
590 dhcpmsg(MSG_DEBUG, "select_best: no valid OFFER/BOOTP reply");
591 }
592
593 return (best);
594 }
595
596 /*
597 * accept_v4_acknak(): determine what to do with a DHCPv4 ACK/NAK based on the
598 * current state. If we're renewing or rebinding, the ACK
599 * must be for the same address and must have a new lease
600 * time. If it's a NAK, then our cache is garbage, and we
601 * must restart. Finally, call dhcp_bound on accepted
602 * ACKs.
603 *
604 * input: dhcp_smach_t *: the state machine to handle the ACK/NAK
605 * PKT_LIST *: the ACK/NAK message
606 * output: void
607 */
608
609 static void
accept_v4_acknak(dhcp_smach_t * dsmp,PKT_LIST * plp)610 accept_v4_acknak(dhcp_smach_t *dsmp, PKT_LIST *plp)
611 {
612 /* Account for received and processed messages */
613 dsmp->dsm_received++;
614
615 if (*plp->opts[CD_DHCP_TYPE]->value == ACK) {
616 if (dsmp->dsm_state != INFORM_SENT &&
617 dsmp->dsm_state != INFORMATION &&
618 (plp->opts[CD_LEASE_TIME] == NULL ||
619 plp->opts[CD_LEASE_TIME]->len != sizeof (lease_t))) {
620 dhcpmsg(MSG_WARNING, "accept_v4_acknak: ACK packet on "
621 "%s missing mandatory lease option, ignored",
622 dsmp->dsm_name);
623 dsmp->dsm_bad_offers++;
624 free_pkt_entry(plp);
625 return;
626 }
627 if ((dsmp->dsm_state == RENEWING ||
628 dsmp->dsm_state == REBINDING) &&
629 dsmp->dsm_leases->dl_lifs->lif_addr !=
630 plp->pkt->yiaddr.s_addr) {
631 dhcpmsg(MSG_WARNING, "accept_v4_acknak: renewal ACK "
632 "packet has a different IP address (%s), ignored",
633 inet_ntoa(plp->pkt->yiaddr));
634 dsmp->dsm_bad_offers++;
635 free_pkt_entry(plp);
636 return;
637 }
638 }
639
640 /*
641 * looks good; cancel the retransmission timer and unregister
642 * the acknak handler. ACK to BOUND, NAK back to SELECTING.
643 */
644
645 stop_pkt_retransmission(dsmp);
646
647 if (*plp->opts[CD_DHCP_TYPE]->value == NAK) {
648 dhcpmsg(MSG_WARNING, "accept_v4_acknak: NAK on interface %s",
649 dsmp->dsm_name);
650 dsmp->dsm_bad_offers++;
651 free_pkt_entry(plp);
652 dhcp_restart(dsmp);
653
654 /*
655 * remove any bogus cached configuration we might have
656 * around (right now would only happen if we got here
657 * from INIT_REBOOT).
658 */
659
660 (void) remove_hostconf(dsmp->dsm_name, dsmp->dsm_isv6);
661 return;
662 }
663
664 if (plp->opts[CD_SERVER_ID] == NULL ||
665 plp->opts[CD_SERVER_ID]->len != sizeof (ipaddr_t)) {
666 dhcpmsg(MSG_ERROR, "accept_v4_acknak: ACK with no valid "
667 "server id on %s", dsmp->dsm_name);
668 dsmp->dsm_bad_offers++;
669 free_pkt_entry(plp);
670 dhcp_restart(dsmp);
671 return;
672 }
673
674 if (plp->opts[CD_MESSAGE] != NULL) {
675 print_server_msg(dsmp, (char *)plp->opts[CD_MESSAGE]->value,
676 plp->opts[CD_MESSAGE]->len);
677 }
678
679 dhcpmsg(MSG_VERBOSE, "accept_v4_acknak: ACK on %s", dsmp->dsm_name);
680 if (!dhcp_bound(dsmp, plp)) {
681 dhcpmsg(MSG_WARNING, "accept_v4_acknak: dhcp_bound failed "
682 "for %s", dsmp->dsm_name);
683 dhcp_restart(dsmp);
684 }
685 }
686
687 /*
688 * accept_v6_message(): determine what to do with a DHCPv6 message based on the
689 * current state.
690 *
691 * input: dhcp_smach_t *: the state machine to handle the message
692 * PKT_LIST *: the DHCPv6 message
693 * const char *: type of message (for logging)
694 * uchar_t: type of message (extracted from packet)
695 * output: void
696 */
697
698 static void
accept_v6_message(dhcp_smach_t * dsmp,PKT_LIST * plp,const char * pname,uchar_t recv_type)699 accept_v6_message(dhcp_smach_t *dsmp, PKT_LIST *plp, const char *pname,
700 uchar_t recv_type)
701 {
702 const dhcpv6_option_t *d6o;
703 uint_t olen;
704 const char *estr, *msg;
705 uint_t msglen;
706 int status;
707
708 /* Account for received and processed messages */
709 dsmp->dsm_received++;
710
711 /* We don't yet support Reconfigure at all. */
712 if (recv_type == DHCPV6_MSG_RECONFIGURE) {
713 dhcpmsg(MSG_VERBOSE, "accept_v6_message: ignored Reconfigure "
714 "on %s", dsmp->dsm_name);
715 free_pkt_entry(plp);
716 return;
717 }
718
719 /*
720 * All valid DHCPv6 messages must have our Client ID specified.
721 */
722 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_CLIENTID, &olen);
723 olen -= sizeof (*d6o);
724 if (d6o == NULL || olen != dsmp->dsm_cidlen ||
725 memcmp(d6o + 1, dsmp->dsm_cid, olen) != 0) {
726 dhcpmsg(MSG_VERBOSE,
727 "accept_v6_message: discarded %s on %s: %s Client ID",
728 pname, dsmp->dsm_name, d6o == NULL ? "no" : "wrong");
729 free_pkt_entry(plp);
730 return;
731 }
732
733 /*
734 * All valid DHCPv6 messages must have a Server ID specified.
735 *
736 * If this is a Reply and it's not in response to Solicit, Confirm,
737 * Rebind, or Information-Request, then it must also match the Server
738 * ID we're expecting.
739 *
740 * For Reply in the Solicit, Confirm, Rebind, and Information-Request
741 * cases, the Server ID needs to be saved. This is done inside of
742 * dhcp_bound().
743 */
744 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_SERVERID, &olen);
745 if (d6o == NULL) {
746 dhcpmsg(MSG_DEBUG,
747 "accept_v6_message: discarded %s on %s: no Server ID",
748 pname, dsmp->dsm_name);
749 free_pkt_entry(plp);
750 return;
751 }
752 if (recv_type == DHCPV6_MSG_REPLY && dsmp->dsm_state != SELECTING &&
753 dsmp->dsm_state != INIT_REBOOT && dsmp->dsm_state != REBINDING &&
754 dsmp->dsm_state != INFORM_SENT) {
755 olen -= sizeof (*d6o);
756 if (olen != dsmp->dsm_serveridlen ||
757 memcmp(d6o + 1, dsmp->dsm_serverid, olen) != 0) {
758 dhcpmsg(MSG_DEBUG, "accept_v6_message: discarded %s on "
759 "%s: wrong Server ID", pname, dsmp->dsm_name);
760 free_pkt_entry(plp);
761 return;
762 }
763 }
764
765 /*
766 * Break out of the switch if the input message needs to be discarded.
767 * Return from the function if the message has been enqueued or
768 * consumed.
769 */
770 switch (dsmp->dsm_state) {
771 case SELECTING:
772 /* A Reply message signifies a Rapid-Commit. */
773 if (recv_type == DHCPV6_MSG_REPLY) {
774 if (dhcpv6_pkt_option(plp, NULL,
775 DHCPV6_OPT_RAPID_COMMIT, &olen) == NULL) {
776 dhcpmsg(MSG_DEBUG, "accept_v6_message: Reply "
777 "on %s lacks Rapid-Commit; ignoring",
778 dsmp->dsm_name);
779 break;
780 }
781 dhcpmsg(MSG_VERBOSE,
782 "accept_v6_message: rapid-commit Reply on %s",
783 dsmp->dsm_name);
784 cancel_offer_timer(dsmp);
785 goto rapid_commit;
786 }
787
788 /* Otherwise, we're looking for Advertisements. */
789 if (recv_type != DHCPV6_MSG_ADVERTISE)
790 break;
791
792 /*
793 * Special case: if this advertisement has preference 255, then
794 * we must stop right now and select this server.
795 */
796 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_PREFERENCE,
797 &olen);
798 if (d6o != NULL && olen == sizeof (*d6o) + 1 &&
799 *(const uchar_t *)(d6o + 1) == 255) {
800 pkt_smach_enqueue(dsmp, plp);
801 dhcpmsg(MSG_DEBUG, "accept_v6_message: preference 255;"
802 " immediate Request on %s", dsmp->dsm_name);
803 dhcp_requesting(NULL, dsmp);
804 } else {
805 pkt_smach_enqueue(dsmp, plp);
806 }
807 return;
808
809 case PRE_BOUND:
810 case BOUND:
811 /*
812 * Not looking for anything in these states. (If we
813 * implemented reconfigure, that might go here.)
814 */
815 break;
816
817 case REQUESTING:
818 case INIT_REBOOT:
819 case RENEWING:
820 case REBINDING:
821 case INFORM_SENT:
822 /*
823 * We're looking for Reply messages.
824 */
825 if (recv_type != DHCPV6_MSG_REPLY)
826 break;
827 dhcpmsg(MSG_VERBOSE,
828 "accept_v6_message: received Reply message on %s",
829 dsmp->dsm_name);
830 rapid_commit:
831 /*
832 * Extract the status code option. If one is present and the
833 * request failed, then try to go to another advertisement in
834 * the list or restart the selection machinery.
835 */
836 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_STATUS_CODE,
837 &olen);
838 status = dhcpv6_status_code(d6o, olen, &estr, &msg, &msglen);
839 /*
840 * Check for the UseMulticast status code. If this is present,
841 * and if we were actually using unicast, then drop back and
842 * try again. If we weren't using unicast, then just pretend
843 * we never saw this message -- the peer is confused. (TAHI
844 * does this.)
845 */
846 if (status == DHCPV6_STAT_USEMCAST) {
847 if (IN6_IS_ADDR_MULTICAST(
848 &dsmp->dsm_send_dest.v6.sin6_addr)) {
849 break;
850 } else {
851 free_pkt_entry(plp);
852 dsmp->dsm_send_dest.v6.sin6_addr =
853 ipv6_all_dhcp_relay_and_servers;
854 retransmit_now(dsmp);
855 return;
856 }
857 }
858 print_server_msg(dsmp, msg, msglen);
859 /*
860 * We treat NoBinding at the top level as "success." Granted,
861 * this doesn't make much sense, but the TAHI test suite does
862 * this. NoBinding really only makes sense in the context of a
863 * specific IA, as it refers to the GUID:IAID binding, so
864 * ignoring it at the top level is safe.
865 */
866 if (status == DHCPV6_STAT_SUCCESS ||
867 status == DHCPV6_STAT_NOBINDING) {
868 if (dhcp_bound(dsmp, plp)) {
869 /*
870 * dhcp_bound will stop retransmission on
871 * success, if that's called for.
872 */
873 server_unicast_option(dsmp, plp);
874 } else {
875 stop_pkt_retransmission(dsmp);
876 dhcpmsg(MSG_WARNING, "accept_v6_message: "
877 "dhcp_bound failed for %s", dsmp->dsm_name);
878 (void) remove_hostconf(dsmp->dsm_name,
879 dsmp->dsm_isv6);
880 dhcp_restart(dsmp);
881 }
882 } else {
883 dhcpmsg(MSG_WARNING, "accept_v6_message: Reply: %s",
884 estr);
885 stop_pkt_retransmission(dsmp);
886 free_pkt_entry(plp);
887 if (dsmp->dsm_state == INFORM_SENT) {
888 (void) set_smach_state(dsmp, INIT);
889 ipc_action_finish(dsmp, DHCP_IPC_E_SRVFAILED);
890 } else {
891 (void) remove_hostconf(dsmp->dsm_name,
892 dsmp->dsm_isv6);
893 request_failed(dsmp);
894 }
895 }
896 return;
897
898 case DECLINING:
899 /*
900 * We're looking for Reply messages.
901 */
902 if (recv_type != DHCPV6_MSG_REPLY)
903 break;
904 stop_pkt_retransmission(dsmp);
905 /*
906 * Extract the status code option. Note that it's not a
907 * failure if the server reports an error.
908 */
909 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_STATUS_CODE,
910 &olen);
911 if (dhcpv6_status_code(d6o, olen, &estr, &msg,
912 &msglen) == DHCPV6_STAT_SUCCESS) {
913 print_server_msg(dsmp, msg, msglen);
914 } else {
915 dhcpmsg(MSG_WARNING, "accept_v6_message: Reply: %s",
916 estr);
917 }
918 free_pkt_entry(plp);
919 if (dsmp->dsm_leases == NULL) {
920 dhcpmsg(MSG_VERBOSE, "accept_v6_message: %s has no "
921 "leases left", dsmp->dsm_name);
922 dhcp_restart(dsmp);
923 } else if (dsmp->dsm_lif_wait == 0) {
924 (void) set_smach_state(dsmp, BOUND);
925 } else {
926 (void) set_smach_state(dsmp, PRE_BOUND);
927 }
928 return;
929
930 case RELEASING:
931 /*
932 * We're looking for Reply messages.
933 */
934 if (recv_type != DHCPV6_MSG_REPLY)
935 break;
936 stop_pkt_retransmission(dsmp);
937 /*
938 * Extract the status code option.
939 */
940 d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_STATUS_CODE,
941 &olen);
942 if (dhcpv6_status_code(d6o, olen, &estr, &msg,
943 &msglen) == DHCPV6_STAT_SUCCESS) {
944 print_server_msg(dsmp, msg, msglen);
945 } else {
946 dhcpmsg(MSG_WARNING, "accept_v6_message: Reply: %s",
947 estr);
948 }
949 free_pkt_entry(plp);
950 finished_smach(dsmp, DHCP_IPC_SUCCESS);
951 return;
952 }
953
954 /*
955 * Break from above switch means that the message must be discarded.
956 */
957 dhcpmsg(MSG_VERBOSE,
958 "accept_v6_message: discarded v6 %s on %s; state %s",
959 pname, dsmp->dsm_name, dhcp_state_to_string(dsmp->dsm_state));
960 free_pkt_entry(plp);
961 }
962
963 /*
964 * dhcp_acknak_global(): Processes reception of an ACK or NAK packet on the
965 * global socket -- broadcast packets for IPv4, all
966 * packets for DHCPv6.
967 *
968 * input: iu_eh_t *: unused
969 * int: the global file descriptor the ACK/NAK arrived on
970 * short: unused
971 * iu_event_id_t: unused
972 * void *: unused
973 * output: void
974 */
975
976 /* ARGSUSED */
977 void
dhcp_acknak_global(iu_eh_t * ehp,int fd,short events,iu_event_id_t id,void * arg)978 dhcp_acknak_global(iu_eh_t *ehp, int fd, short events, iu_event_id_t id,
979 void *arg)
980 {
981 PKT_LIST *plp;
982 dhcp_pif_t *pif;
983 uchar_t recv_type;
984 const char *pname;
985 uint_t xid;
986 dhcp_smach_t *dsmp;
987 boolean_t isv6 = (fd == v6_sock_fd);
988 struct sockaddr_in sin;
989 const char *reason;
990 size_t sinlen = sizeof (sin);
991 int sock;
992
993 plp = recv_pkt(fd, get_max_mtu(isv6), isv6);
994 if (plp == NULL)
995 return;
996
997 recv_type = pkt_recv_type(plp);
998 pname = pkt_type_to_string(recv_type, isv6);
999
1000 /*
1001 * Find the corresponding state machine and pif.
1002 *
1003 * Note that DHCPv6 Reconfigure would be special: it's not the reply to
1004 * any transaction, and thus we would need to search on transaction ID
1005 * zero (all state machines) to find the match. However, Reconfigure
1006 * is not yet supported.
1007 */
1008 xid = pkt_get_xid(plp->pkt, isv6);
1009
1010 for (dsmp = lookup_smach_by_xid(xid, NULL, isv6); dsmp != NULL;
1011 dsmp = lookup_smach_by_xid(xid, dsmp, isv6)) {
1012 pif = dsmp->dsm_lif->lif_pif;
1013 if (pif->pif_index == plp->ifindex ||
1014 pif->pif_under_ipmp && pif->pif_grindex == plp->ifindex)
1015 break;
1016 }
1017
1018 if (dsmp == NULL) {
1019 dhcpmsg(MSG_VERBOSE, "dhcp_acknak_global: ignored v%d %s packet"
1020 " on ifindex %d: unknown state machine", isv6 ? 6 : 4,
1021 pname, plp->ifindex);
1022 free_pkt_entry(plp);
1023 return;
1024 }
1025
1026 if (!isv6 && !pkt_v4_match(recv_type, DHCP_PACK|DHCP_PNAK)) {
1027 reason = "not ACK or NAK";
1028 goto drop;
1029 }
1030
1031 /*
1032 * For IPv4, most packets will be handled by dhcp_packet_lif(). The
1033 * only exceptions are broadcast packets sent when lif_sock_ip_fd has
1034 * bound to something other than INADDR_ANY.
1035 */
1036 if (!isv6) {
1037 sock = dsmp->dsm_lif->lif_sock_ip_fd;
1038
1039 if (getsockname(sock, (struct sockaddr *)&sin, &sinlen) != -1 &&
1040 sin.sin_addr.s_addr == INADDR_ANY) {
1041 reason = "handled by lif_sock_ip_fd";
1042 goto drop;
1043 }
1044 }
1045
1046 /*
1047 * We've got a packet; make sure it's acceptable and cancel the REQUEST
1048 * retransmissions.
1049 */
1050 if (isv6)
1051 accept_v6_message(dsmp, plp, pname, recv_type);
1052 else
1053 accept_v4_acknak(dsmp, plp);
1054 return;
1055 drop:
1056 dhcpmsg(MSG_VERBOSE, "dhcp_acknak_global: ignored v%d %s packet for %s "
1057 "received on global socket: %s", isv6 ? 6 : 4, pname, pif->pif_name,
1058 reason);
1059 free_pkt_entry(plp);
1060 }
1061
1062 /*
1063 * request_failed(): Attempt to request an address has failed. Take an
1064 * appropriate action.
1065 *
1066 * input: dhcp_smach_t *: state machine that has failed
1067 * output: void
1068 */
1069
1070 static void
request_failed(dhcp_smach_t * dsmp)1071 request_failed(dhcp_smach_t *dsmp)
1072 {
1073 PKT_LIST *offer;
1074
1075 dsmp->dsm_server = ipv6_all_dhcp_relay_and_servers;
1076 if ((offer = select_best(dsmp)) != NULL) {
1077 insque(offer, &dsmp->dsm_recv_pkt_list);
1078 dhcp_requesting(NULL, dsmp);
1079 } else {
1080 dhcpmsg(MSG_INFO, "no offers left on %s; restarting",
1081 dsmp->dsm_name);
1082 dhcp_selecting(dsmp);
1083 }
1084 }
1085
1086 /*
1087 * dhcp_packet_lif(): Processes reception of an ACK, NAK, or OFFER packet on
1088 * a given logical interface for IPv4 (only).
1089 *
1090 * input: iu_eh_t *: unused
1091 * int: the file descriptor the packet arrived on
1092 * short: unused
1093 * iu_event_id_t: the id of this event callback with the handler
1094 * void *: pointer to logical interface receiving message
1095 * output: void
1096 */
1097
1098 /* ARGSUSED */
1099 void
dhcp_packet_lif(iu_eh_t * ehp,int fd,short events,iu_event_id_t id,void * arg)1100 dhcp_packet_lif(iu_eh_t *ehp, int fd, short events, iu_event_id_t id,
1101 void *arg)
1102 {
1103 dhcp_lif_t *lif = arg;
1104 PKT_LIST *plp;
1105 uchar_t recv_type;
1106 const char *pname;
1107 uint_t xid;
1108 dhcp_smach_t *dsmp;
1109
1110 if ((plp = recv_pkt(fd, lif->lif_max, B_FALSE)) == NULL)
1111 return;
1112
1113 recv_type = pkt_recv_type(plp);
1114 pname = pkt_type_to_string(recv_type, B_FALSE);
1115
1116 if (!pkt_v4_match(recv_type,
1117 DHCP_PACK | DHCP_PNAK | DHCP_PUNTYPED | DHCP_POFFER)) {
1118 dhcpmsg(MSG_VERBOSE, "dhcp_packet_lif: ignored v4 %s packet "
1119 "received via LIF %s", pname, lif->lif_name);
1120 free_pkt_entry(plp);
1121 return;
1122 }
1123
1124 /*
1125 * Find the corresponding state machine.
1126 */
1127 xid = pkt_get_xid(plp->pkt, B_FALSE);
1128 for (dsmp = lookup_smach_by_xid(xid, NULL, B_FALSE); dsmp != NULL;
1129 dsmp = lookup_smach_by_xid(xid, dsmp, B_FALSE)) {
1130 if (dsmp->dsm_lif == lif)
1131 break;
1132 }
1133
1134 if (dsmp == NULL)
1135 goto drop;
1136
1137 if (pkt_v4_match(recv_type, DHCP_PACK|DHCP_PNAK)) {
1138 /*
1139 * We've got an ACK/NAK; make sure it's acceptable and cancel
1140 * the REQUEST retransmissions.
1141 */
1142 accept_v4_acknak(dsmp, plp);
1143 } else {
1144 if (is_bound_state(dsmp->dsm_state))
1145 goto drop;
1146 /*
1147 * Must be an OFFER or a BOOTP message: enqueue it for later
1148 * processing by select_best().
1149 */
1150 pkt_smach_enqueue(dsmp, plp);
1151 }
1152 return;
1153 drop:
1154 dhcpmsg(MSG_VERBOSE, "dhcp_packet_lif: ignored %s packet xid "
1155 "%x received via LIF %s; %s", pname, xid, lif->lif_name,
1156 dsmp == NULL ? "unknown state machine" : "bound");
1157 free_pkt_entry(plp);
1158 }
1159
1160 /*
1161 * dhcp_restart(): restarts DHCP (from INIT) on a given state machine, but only
1162 * if we're leasing addresses. Doesn't restart for information-
1163 * only interfaces.
1164 *
1165 * input: dhcp_smach_t *: the state machine to restart DHCP on
1166 * output: void
1167 */
1168
1169 void
dhcp_restart(dhcp_smach_t * dsmp)1170 dhcp_restart(dhcp_smach_t *dsmp)
1171 {
1172 if (dsmp->dsm_state == INFORM_SENT || dsmp->dsm_state == INFORMATION)
1173 return;
1174
1175 /*
1176 * As we're returning to INIT state, we need to discard any leases we
1177 * may have, and (for v4) canonize the LIF. There's a bit of tension
1178 * between keeping around a possibly still working address, and obeying
1179 * the RFCs. A more elaborate design would be to mark the addresses as
1180 * DEPRECATED, and then start a removal timer. Such a design would
1181 * probably compromise testing.
1182 */
1183 deprecate_leases(dsmp);
1184
1185 if (!set_start_timer(dsmp)) {
1186 dhcpmsg(MSG_ERROR, "dhcp_restart: cannot schedule dhcp_start, "
1187 "reverting to INIT state on %s", dsmp->dsm_name);
1188
1189 (void) set_smach_state(dsmp, INIT);
1190 dsmp->dsm_dflags |= DHCP_IF_FAILED;
1191 ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
1192 } else {
1193 dhcpmsg(MSG_DEBUG, "dhcp_restart: restarting DHCP on %s",
1194 dsmp->dsm_name);
1195 }
1196 }
1197
1198 /*
1199 * stop_requesting(): decides when to stop retransmitting REQUESTs
1200 *
1201 * input: dhcp_smach_t *: the state machine REQUESTs are being sent from
1202 * unsigned int: the number of REQUESTs sent so far
1203 * output: boolean_t: B_TRUE if retransmissions should stop
1204 */
1205
1206 static boolean_t
stop_requesting(dhcp_smach_t * dsmp,unsigned int n_requests)1207 stop_requesting(dhcp_smach_t *dsmp, unsigned int n_requests)
1208 {
1209 uint_t maxreq;
1210
1211 maxreq = dsmp->dsm_isv6 ? DHCPV6_REQ_MAX_RC : DHCP_MAX_REQUESTS;
1212 if (n_requests >= maxreq) {
1213
1214 dhcpmsg(MSG_INFO, "no ACK/NAK/Reply to REQUEST on %s",
1215 dsmp->dsm_name);
1216
1217 request_failed(dsmp);
1218 return (B_TRUE);
1219 } else {
1220 return (B_FALSE);
1221 }
1222 }
1223