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 (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include <sys/types.h>
26 #include <time.h>
27 #include <netinet/in.h>
28 #include <netinet/dhcp.h>
29 #include <netinet/udp.h>
30 #include <netinet/ip_var.h>
31 #include <netinet/udp_var.h>
32 #include <libinetutil.h>
33 #include <dhcpmsg.h>
34 #include <dhcp_hostconf.h>
35 #include <string.h>
36
37 #include "packet.h"
38 #include "agent.h"
39 #include "script_handler.h"
40 #include "interface.h"
41 #include "states.h"
42 #include "util.h"
43
44 /*
45 * Number of seconds to wait for a retry if the user is interacting with the
46 * daemon.
47 */
48 #define RETRY_DELAY 10
49
50 /*
51 * If the renew timer fires within this number of seconds of the rebind timer,
52 * then skip renew. This prevents us from sending back-to-back renew and
53 * rebind messages -- a pointless activity.
54 */
55 #define TOO_CLOSE 2
56
57 static boolean_t stop_extending(dhcp_smach_t *, unsigned int);
58
59 /*
60 * dhcp_renew(): attempts to renew a DHCP lease on expiration of the T1 timer.
61 *
62 * input: iu_tq_t *: unused
63 * void *: the lease to renew (dhcp_lease_t)
64 * output: void
65 *
66 * notes: The primary expense involved with DHCP (like most UDP protocols) is
67 * with the generation and handling of packets, not the contents of
68 * those packets. Thus, we try to reduce the number of packets that
69 * are sent. It would be nice to just renew all leases here (each one
70 * added has trivial added overhead), but the DHCPv6 RFC doesn't
71 * explicitly allow that behavior. Rather than having that argument,
72 * we settle for ones that are close in expiry to the one that fired.
73 * For v4, we repeatedly reschedule the T1 timer to do the
74 * retransmissions. For v6, we rely on the common timer computation
75 * in packet.c.
76 */
77
78 /* ARGSUSED */
79 void
dhcp_renew(iu_tq_t * tqp,void * arg)80 dhcp_renew(iu_tq_t *tqp, void *arg)
81 {
82 dhcp_lease_t *dlp = arg;
83 dhcp_smach_t *dsmp = dlp->dl_smach;
84 uint32_t t2;
85
86 dhcpmsg(MSG_VERBOSE, "dhcp_renew: T1 timer expired on %s",
87 dsmp->dsm_name);
88
89 dlp->dl_t1.dt_id = -1;
90
91 if (dsmp->dsm_state == RENEWING || dsmp->dsm_state == REBINDING) {
92 dhcpmsg(MSG_DEBUG, "dhcp_renew: already renewing");
93 release_lease(dlp);
94 return;
95 }
96
97 /*
98 * Sanity check: don't send packets if we're past T2, or if we're
99 * extremely close.
100 */
101
102 t2 = dsmp->dsm_curstart_monosec + dlp->dl_t2.dt_start;
103 if (monosec() + TOO_CLOSE >= t2) {
104 dhcpmsg(MSG_DEBUG, "dhcp_renew: %spast T2 on %s",
105 monosec() > t2 ? "" : "almost ", dsmp->dsm_name);
106 release_lease(dlp);
107 return;
108 }
109
110 /*
111 * If there isn't an async event pending, or if we can cancel the one
112 * that's there, then try to renew by sending an extension request. If
113 * that fails, we'll try again when the next timer fires.
114 */
115 if (!async_cancel(dsmp) || !async_start(dsmp, DHCP_EXTEND, B_FALSE) ||
116 !dhcp_extending(dsmp)) {
117 if (monosec() + RETRY_DELAY < t2) {
118 /*
119 * Try again in RETRY_DELAY seconds; user command
120 * should be gone.
121 */
122 init_timer(&dlp->dl_t1, RETRY_DELAY);
123 (void) set_smach_state(dsmp, BOUND);
124 if (!schedule_lease_timer(dlp, &dlp->dl_t1,
125 dhcp_renew)) {
126 dhcpmsg(MSG_INFO, "dhcp_renew: unable to "
127 "reschedule renewal around user command "
128 "on %s; will wait for rebind",
129 dsmp->dsm_name);
130 }
131 } else {
132 dhcpmsg(MSG_DEBUG, "dhcp_renew: user busy on %s; will "
133 "wait for rebind", dsmp->dsm_name);
134 }
135 }
136 release_lease(dlp);
137 }
138
139 /*
140 * dhcp_rebind(): attempts to renew a DHCP lease from the REBINDING state (T2
141 * timer expiry).
142 *
143 * input: iu_tq_t *: unused
144 * void *: the lease to renew
145 * output: void
146 * notes: For v4, we repeatedly reschedule the T2 timer to do the
147 * retransmissions. For v6, we rely on the common timer computation
148 * in packet.c.
149 */
150
151 /* ARGSUSED */
152 void
dhcp_rebind(iu_tq_t * tqp,void * arg)153 dhcp_rebind(iu_tq_t *tqp, void *arg)
154 {
155 dhcp_lease_t *dlp = arg;
156 dhcp_smach_t *dsmp = dlp->dl_smach;
157 int nlifs;
158 dhcp_lif_t *lif;
159 boolean_t some_valid;
160 uint32_t expiremax;
161 DHCPSTATE oldstate;
162
163 dhcpmsg(MSG_VERBOSE, "dhcp_rebind: T2 timer expired on %s",
164 dsmp->dsm_name);
165
166 dlp->dl_t2.dt_id = -1;
167
168 if ((oldstate = dsmp->dsm_state) == REBINDING) {
169 dhcpmsg(MSG_DEBUG, "dhcp_renew: already rebinding");
170 release_lease(dlp);
171 return;
172 }
173
174 /*
175 * Sanity check: don't send packets if we've already expired on all of
176 * the addresses. We compute the maximum expiration time here, because
177 * it won't matter for v4 (there's only one lease) and for v6 we need
178 * to know when the last lease ages away.
179 */
180
181 some_valid = B_FALSE;
182 expiremax = monosec();
183 lif = dlp->dl_lifs;
184 for (nlifs = dlp->dl_nlifs; nlifs > 0; nlifs--, lif = lif->lif_next) {
185 uint32_t expire;
186
187 expire = dsmp->dsm_curstart_monosec + lif->lif_expire.dt_start;
188 if (expire > expiremax) {
189 expiremax = expire;
190 some_valid = B_TRUE;
191 }
192 }
193 if (!some_valid) {
194 dhcpmsg(MSG_DEBUG, "dhcp_rebind: all leases expired on %s",
195 dsmp->dsm_name);
196 release_lease(dlp);
197 return;
198 }
199
200 /*
201 * This is our first venture into the REBINDING state, so reset the
202 * server address. We know the renew timer has already been cancelled
203 * (or we wouldn't be here).
204 */
205 if (dsmp->dsm_isv6) {
206 dsmp->dsm_server = ipv6_all_dhcp_relay_and_servers;
207 } else {
208 IN6_IPADDR_TO_V4MAPPED(htonl(INADDR_BROADCAST),
209 &dsmp->dsm_server);
210 }
211
212 /* {Bound,Renew}->rebind transitions cannot fail */
213 (void) set_smach_state(dsmp, REBINDING);
214
215 /*
216 * If there isn't an async event pending, or if we can cancel the one
217 * that's there, then try to rebind by sending an extension request.
218 * If that fails, we'll clean up when the lease expires.
219 */
220 if (!async_cancel(dsmp) || !async_start(dsmp, DHCP_EXTEND, B_FALSE) ||
221 !dhcp_extending(dsmp)) {
222 if (monosec() + RETRY_DELAY < expiremax) {
223 /*
224 * Try again in RETRY_DELAY seconds; user command
225 * should be gone.
226 */
227 init_timer(&dlp->dl_t2, RETRY_DELAY);
228 (void) set_smach_state(dsmp, oldstate);
229 if (!schedule_lease_timer(dlp, &dlp->dl_t2,
230 dhcp_rebind)) {
231 dhcpmsg(MSG_INFO, "dhcp_rebind: unable to "
232 "reschedule rebind around user command on "
233 "%s; lease may expire", dsmp->dsm_name);
234 }
235 } else {
236 dhcpmsg(MSG_WARNING, "dhcp_rebind: user busy on %s; "
237 "will expire", dsmp->dsm_name);
238 }
239 }
240 release_lease(dlp);
241 }
242
243 /*
244 * dhcp_finish_expire(): finish expiration of a lease after the user script
245 * runs. If this is the last lease, then restart DHCP.
246 * The caller has a reference to the LIF, which will be
247 * dropped.
248 *
249 * input: dhcp_smach_t *: the state machine to be restarted
250 * void *: logical interface that has expired
251 * output: int: always 1
252 */
253
254 static int
dhcp_finish_expire(dhcp_smach_t * dsmp,void * arg)255 dhcp_finish_expire(dhcp_smach_t *dsmp, void *arg)
256 {
257 dhcp_lif_t *lif = arg;
258 dhcp_lease_t *dlp;
259
260 dhcpmsg(MSG_DEBUG, "lease expired on %s; removing", lif->lif_name);
261
262 dlp = lif->lif_lease;
263 unplumb_lif(lif);
264 if (dlp->dl_nlifs == 0)
265 remove_lease(dlp);
266 release_lif(lif);
267
268 /* If some valid leases remain, then drive on */
269 if (dsmp->dsm_leases != NULL) {
270 dhcpmsg(MSG_DEBUG,
271 "dhcp_finish_expire: some leases remain on %s",
272 dsmp->dsm_name);
273 return (1);
274 }
275
276 (void) remove_hostconf(dsmp->dsm_name, dsmp->dsm_isv6);
277
278 dhcpmsg(MSG_INFO, "last lease expired on %s -- restarting DHCP",
279 dsmp->dsm_name);
280
281 /*
282 * in the case where the lease is less than DHCP_REBIND_MIN
283 * seconds, we will never enter dhcp_renew() and thus the packet
284 * counters will not be reset. in that case, reset them here.
285 */
286
287 if (dsmp->dsm_state == BOUND) {
288 dsmp->dsm_bad_offers = 0;
289 dsmp->dsm_sent = 0;
290 dsmp->dsm_received = 0;
291 }
292
293 deprecate_leases(dsmp);
294
295 /* reset_smach() in dhcp_selecting() will clean up any leftover state */
296 dhcp_selecting(dsmp);
297
298 return (1);
299 }
300
301 /*
302 * dhcp_deprecate(): deprecates an address on a given logical interface when
303 * the preferred lifetime expires.
304 *
305 * input: iu_tq_t *: unused
306 * void *: the logical interface whose lease is expiring
307 * output: void
308 */
309
310 /* ARGSUSED */
311 void
dhcp_deprecate(iu_tq_t * tqp,void * arg)312 dhcp_deprecate(iu_tq_t *tqp, void *arg)
313 {
314 dhcp_lif_t *lif = arg;
315
316 set_lif_deprecated(lif);
317 release_lif(lif);
318 }
319
320 /*
321 * dhcp_expire(): expires a lease on a given logical interface and, if there
322 * are no more leases, restarts DHCP.
323 *
324 * input: iu_tq_t *: unused
325 * void *: the logical interface whose lease has expired
326 * output: void
327 */
328
329 /* ARGSUSED */
330 void
dhcp_expire(iu_tq_t * tqp,void * arg)331 dhcp_expire(iu_tq_t *tqp, void *arg)
332 {
333 dhcp_lif_t *lif = arg;
334 dhcp_smach_t *dsmp;
335 const char *event;
336
337 dhcpmsg(MSG_VERBOSE, "dhcp_expire: lease timer expired on %s",
338 lif->lif_name);
339
340 lif->lif_expire.dt_id = -1;
341 if (lif->lif_lease == NULL) {
342 release_lif(lif);
343 return;
344 }
345
346 set_lif_deprecated(lif);
347
348 dsmp = lif->lif_lease->dl_smach;
349
350 if (!async_cancel(dsmp)) {
351
352 dhcpmsg(MSG_WARNING,
353 "dhcp_expire: cannot cancel current asynchronous command "
354 "on %s", dsmp->dsm_name);
355
356 /*
357 * Try to schedule ourselves for callback. We're really
358 * situation-critical here; there's not much hope for us if
359 * this fails.
360 */
361 init_timer(&lif->lif_expire, DHCP_EXPIRE_WAIT);
362 if (schedule_lif_timer(lif, &lif->lif_expire, dhcp_expire))
363 return;
364
365 dhcpmsg(MSG_CRIT, "dhcp_expire: cannot reschedule dhcp_expire "
366 "to get called back, proceeding...");
367 }
368
369 if (!async_start(dsmp, DHCP_START, B_FALSE))
370 dhcpmsg(MSG_WARNING, "dhcp_expire: cannot start asynchronous "
371 "transaction on %s, continuing...", dsmp->dsm_name);
372
373 /*
374 * Determine if this state machine has any non-expired LIFs left in it.
375 * If it doesn't, then this is an "expire" event. Otherwise, if some
376 * valid leases remain, it's a "loss" event. The SOMEEXP case can
377 * occur only with DHCPv6.
378 */
379 if (expired_lif_state(dsmp) == DHCP_EXP_SOMEEXP)
380 event = EVENT_LOSS6;
381 else if (dsmp->dsm_isv6)
382 event = EVENT_EXPIRE6;
383 else
384 event = EVENT_EXPIRE;
385
386 /*
387 * just march on if this fails; at worst someone will be able
388 * to async_start() while we're actually busy with our own
389 * asynchronous transaction. better than not having a lease.
390 */
391
392 (void) script_start(dsmp, event, dhcp_finish_expire, lif, NULL);
393 }
394
395 /*
396 * dhcp_extending(): sends a REQUEST (IPv4 DHCP) or Rebind/Renew (DHCPv6) to
397 * extend a lease on a given state machine
398 *
399 * input: dhcp_smach_t *: the state machine to send the message from
400 * output: boolean_t: B_TRUE if the extension request was sent
401 */
402
403 boolean_t
dhcp_extending(dhcp_smach_t * dsmp)404 dhcp_extending(dhcp_smach_t *dsmp)
405 {
406 dhcp_pkt_t *dpkt;
407
408 stop_pkt_retransmission(dsmp);
409
410 /*
411 * We change state here because this function is also called when
412 * adopting a lease and on demand by the user.
413 */
414 if (dsmp->dsm_state == BOUND) {
415 dsmp->dsm_neg_hrtime = gethrtime();
416 dsmp->dsm_bad_offers = 0;
417 dsmp->dsm_sent = 0;
418 dsmp->dsm_received = 0;
419 /* Bound->renew can't fail */
420 (void) set_smach_state(dsmp, RENEWING);
421 }
422
423 dhcpmsg(MSG_DEBUG, "dhcp_extending: sending request on %s",
424 dsmp->dsm_name);
425
426 if (dsmp->dsm_isv6) {
427 dhcp_lease_t *dlp;
428 dhcp_lif_t *lif;
429 uint_t nlifs;
430 uint_t irt, mrt;
431
432 /*
433 * Start constructing the Renew/Rebind message. Only Renew has
434 * a server ID, as we still think our server might be
435 * reachable.
436 */
437 if (dsmp->dsm_state == RENEWING) {
438 dpkt = init_pkt(dsmp, DHCPV6_MSG_RENEW);
439 (void) add_pkt_opt(dpkt, DHCPV6_OPT_SERVERID,
440 dsmp->dsm_serverid, dsmp->dsm_serveridlen);
441 irt = DHCPV6_REN_TIMEOUT;
442 mrt = DHCPV6_REN_MAX_RT;
443 } else {
444 dpkt = init_pkt(dsmp, DHCPV6_MSG_REBIND);
445 irt = DHCPV6_REB_TIMEOUT;
446 mrt = DHCPV6_REB_MAX_RT;
447 }
448
449 /*
450 * Loop over the leases, and add an IA_NA for each and an
451 * IAADDR for each address.
452 */
453 for (dlp = dsmp->dsm_leases; dlp != NULL; dlp = dlp->dl_next) {
454 lif = dlp->dl_lifs;
455 for (nlifs = dlp->dl_nlifs; nlifs > 0;
456 nlifs--, lif = lif->lif_next) {
457 (void) add_pkt_lif(dpkt, lif,
458 DHCPV6_STAT_SUCCESS, NULL);
459 }
460 }
461
462 /* Add required Option Request option */
463 (void) add_pkt_prl(dpkt, dsmp);
464
465 return (send_pkt_v6(dsmp, dpkt, dsmp->dsm_server,
466 stop_extending, irt, mrt));
467 } else {
468 dhcp_lif_t *lif = dsmp->dsm_lif;
469 ipaddr_t server;
470
471 /* assemble the DHCPREQUEST message. */
472 dpkt = init_pkt(dsmp, REQUEST);
473 dpkt->pkt->ciaddr.s_addr = lif->lif_addr;
474
475 /*
476 * The max dhcp message size option is set to the interface
477 * max, minus the size of the udp and ip headers.
478 */
479 (void) add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE,
480 htons(lif->lif_max - sizeof (struct udpiphdr)));
481 (void) add_pkt_opt32(dpkt, CD_LEASE_TIME, htonl(DHCP_PERM));
482
483 if (class_id_len != 0) {
484 (void) add_pkt_opt(dpkt, CD_CLASS_ID, class_id,
485 class_id_len);
486 }
487 (void) add_pkt_prl(dpkt, dsmp);
488 /*
489 * dsm_reqhost was set for this state machine in
490 * dhcp_selecting() if the REQUEST_HOSTNAME option was set and
491 * a host name was found.
492 */
493 if (dsmp->dsm_reqhost != NULL) {
494 (void) add_pkt_opt(dpkt, CD_HOSTNAME, dsmp->dsm_reqhost,
495 strlen(dsmp->dsm_reqhost));
496 }
497 (void) add_pkt_opt(dpkt, CD_END, NULL, 0);
498
499 IN6_V4MAPPED_TO_IPADDR(&dsmp->dsm_server, server);
500 return (send_pkt(dsmp, dpkt, server, stop_extending));
501 }
502 }
503
504 /*
505 * stop_extending(): decides when to stop retransmitting v4 REQUEST or v6
506 * Renew/Rebind messages. If we're renewing, then stop if
507 * T2 is soon approaching.
508 *
509 * input: dhcp_smach_t *: the state machine REQUESTs are being sent from
510 * unsigned int: the number of REQUESTs sent so far
511 * output: boolean_t: B_TRUE if retransmissions should stop
512 */
513
514 /* ARGSUSED */
515 static boolean_t
stop_extending(dhcp_smach_t * dsmp,unsigned int n_requests)516 stop_extending(dhcp_smach_t *dsmp, unsigned int n_requests)
517 {
518 dhcp_lease_t *dlp;
519
520 /*
521 * If we're renewing and rebind time is soon approaching, then don't
522 * schedule
523 */
524 if (dsmp->dsm_state == RENEWING) {
525 monosec_t t2;
526
527 t2 = 0;
528 for (dlp = dsmp->dsm_leases; dlp != NULL; dlp = dlp->dl_next) {
529 if (dlp->dl_t2.dt_start > t2)
530 t2 = dlp->dl_t2.dt_start;
531 }
532 t2 += dsmp->dsm_curstart_monosec;
533 if (monosec() + TOO_CLOSE >= t2) {
534 dhcpmsg(MSG_DEBUG, "stop_extending: %spast T2 on %s",
535 monosec() > t2 ? "" : "almost ", dsmp->dsm_name);
536 return (B_TRUE);
537 }
538 }
539
540 /*
541 * Note that returning B_TRUE cancels both this transmission and the
542 * one that would occur at dsm_send_timeout, and that for v4 we cut the
543 * time in half for each retransmission. Thus we check here against
544 * half of the minimum.
545 */
546 if (!dsmp->dsm_isv6 &&
547 dsmp->dsm_send_timeout < DHCP_REBIND_MIN * MILLISEC / 2) {
548 dhcpmsg(MSG_DEBUG, "stop_extending: next retry would be in "
549 "%d.%03d; stopping", dsmp->dsm_send_timeout / MILLISEC,
550 dsmp->dsm_send_timeout % MILLISEC);
551 return (B_TRUE);
552 }
553
554 /* Otherwise, w stop only when the next timer (rebind, expire) fires */
555 return (B_FALSE);
556 }
557