xref: /titanic_50/usr/src/cmd/cmd-inet/sbin/dhcpagent/renew.c (revision 672986541be54a7a471bb088e60780c37e371d7e)
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 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <sys/types.h>
29 #include <time.h>
30 #include <netinet/in.h>
31 #include <netinet/dhcp.h>
32 #include <netinet/udp.h>
33 #include <netinet/ip_var.h>
34 #include <netinet/udp_var.h>
35 #include <libinetutil.h>
36 #include <dhcpmsg.h>
37 #include <string.h>
38 
39 #include "packet.h"
40 #include "agent.h"
41 #include "script_handler.h"
42 #include "interface.h"
43 #include "states.h"
44 #include "util.h"
45 
46 /*
47  * Number of seconds to wait for a retry if the user is interacting with the
48  * daemon.
49  */
50 #define	RETRY_DELAY	10
51 
52 /*
53  * If the renew timer fires within this number of seconds of the rebind timer,
54  * then skip renew.  This prevents us from sending back-to-back renew and
55  * rebind messages -- a pointless activity.
56  */
57 #define	TOO_CLOSE	2
58 
59 static boolean_t stop_extending(dhcp_smach_t *, unsigned int);
60 
61 /*
62  * dhcp_renew(): attempts to renew a DHCP lease on expiration of the T1 timer.
63  *
64  *   input: iu_tq_t *: unused
65  *	    void *: the lease to renew (dhcp_lease_t)
66  *  output: void
67  *
68  *   notes: The primary expense involved with DHCP (like most UDP protocols) is
69  *	    with the generation and handling of packets, not the contents of
70  *	    those packets.  Thus, we try to reduce the number of packets that
71  *	    are sent.  It would be nice to just renew all leases here (each one
72  *	    added has trivial added overhead), but the DHCPv6 RFC doesn't
73  *	    explicitly allow that behavior.  Rather than having that argument,
74  *	    we settle for ones that are close in expiry to the one that fired.
75  *	    For v4, we repeatedly reschedule the T1 timer to do the
76  *	    retransmissions.  For v6, we rely on the common timer computation
77  *	    in packet.c.
78  */
79 
80 /* ARGSUSED */
81 void
82 dhcp_renew(iu_tq_t *tqp, void *arg)
83 {
84 	dhcp_lease_t *dlp = arg;
85 	dhcp_smach_t *dsmp = dlp->dl_smach;
86 	uint32_t	t2;
87 
88 	dhcpmsg(MSG_VERBOSE, "dhcp_renew: T1 timer expired on %s",
89 	    dsmp->dsm_name);
90 
91 	dlp->dl_t1.dt_id = -1;
92 
93 	if (dsmp->dsm_state == RENEWING || dsmp->dsm_state == REBINDING) {
94 		dhcpmsg(MSG_DEBUG, "dhcp_renew: already renewing");
95 		release_lease(dlp);
96 		return;
97 	}
98 
99 	/*
100 	 * Sanity check: don't send packets if we're past T2, or if we're
101 	 * extremely close.
102 	 */
103 
104 	t2 = dsmp->dsm_curstart_monosec + dlp->dl_t2.dt_start;
105 	if (monosec() + TOO_CLOSE >= t2) {
106 		dhcpmsg(MSG_DEBUG, "dhcp_renew: %spast T2 on %s",
107 		    monosec() > t2 ? "" : "almost ", dsmp->dsm_name);
108 		release_lease(dlp);
109 		return;
110 	}
111 
112 	/*
113 	 * If there isn't an async event pending, or if we can cancel the one
114 	 * that's there, then try to renew by sending an extension request.  If
115 	 * that fails, we'll try again when the next timer fires.
116 	 */
117 	if (!async_cancel(dsmp) || !async_start(dsmp, DHCP_EXTEND, B_FALSE) ||
118 	    !dhcp_extending(dsmp)) {
119 		if (monosec() + RETRY_DELAY < t2) {
120 			/*
121 			 * Try again in RETRY_DELAY seconds; user command
122 			 * should be gone.
123 			 */
124 			init_timer(&dlp->dl_t1, RETRY_DELAY);
125 			(void) set_smach_state(dsmp, BOUND);
126 			if (!schedule_lease_timer(dlp, &dlp->dl_t1,
127 			    dhcp_renew)) {
128 				dhcpmsg(MSG_INFO, "dhcp_renew: unable to "
129 				    "reschedule renewal around user command "
130 				    "on %s; will wait for rebind",
131 				    dsmp->dsm_name);
132 			}
133 		} else {
134 			dhcpmsg(MSG_DEBUG, "dhcp_renew: user busy on %s; will "
135 			    "wait for rebind", dsmp->dsm_name);
136 		}
137 	}
138 	release_lease(dlp);
139 }
140 
141 /*
142  * dhcp_rebind(): attempts to renew a DHCP lease from the REBINDING state (T2
143  *		  timer expiry).
144  *
145  *   input: iu_tq_t *: unused
146  *	    void *: the lease to renew
147  *  output: void
148  *   notes: For v4, we repeatedly reschedule the T2 timer to do the
149  *	    retransmissions.  For v6, we rely on the common timer computation
150  *	    in packet.c.
151  */
152 
153 /* ARGSUSED */
154 void
155 dhcp_rebind(iu_tq_t *tqp, void *arg)
156 {
157 	dhcp_lease_t	*dlp = arg;
158 	dhcp_smach_t	*dsmp = dlp->dl_smach;
159 	int		nlifs;
160 	dhcp_lif_t	*lif;
161 	boolean_t	some_valid;
162 	uint32_t	expiremax;
163 	DHCPSTATE	oldstate;
164 
165 	dhcpmsg(MSG_VERBOSE, "dhcp_rebind: T2 timer expired on %s",
166 	    dsmp->dsm_name);
167 
168 	dlp->dl_t2.dt_id = -1;
169 
170 	if ((oldstate = dsmp->dsm_state) == REBINDING) {
171 		dhcpmsg(MSG_DEBUG, "dhcp_renew: already rebinding");
172 		release_lease(dlp);
173 		return;
174 	}
175 
176 	/*
177 	 * Sanity check: don't send packets if we've already expired on all of
178 	 * the addresses.  We compute the maximum expiration time here, because
179 	 * it won't matter for v4 (there's only one lease) and for v6 we need
180 	 * to know when the last lease ages away.
181 	 */
182 
183 	some_valid = B_FALSE;
184 	expiremax = monosec();
185 	lif = dlp->dl_lifs;
186 	for (nlifs = dlp->dl_nlifs; nlifs > 0; nlifs--, lif = lif->lif_next) {
187 		uint32_t expire;
188 
189 		expire = dsmp->dsm_curstart_monosec + lif->lif_expire.dt_start;
190 		if (expire > expiremax) {
191 			expiremax = expire;
192 			some_valid = B_TRUE;
193 		}
194 	}
195 	if (!some_valid) {
196 		dhcpmsg(MSG_DEBUG, "dhcp_rebind: all leases expired on %s",
197 		    dsmp->dsm_name);
198 		release_lease(dlp);
199 		return;
200 	}
201 
202 	/*
203 	 * This is our first venture into the REBINDING state, so reset the
204 	 * server address.  We know the renew timer has already been cancelled
205 	 * (or we wouldn't be here).
206 	 */
207 	if (dsmp->dsm_isv6) {
208 		dsmp->dsm_server = ipv6_all_dhcp_relay_and_servers;
209 	} else {
210 		IN6_IPADDR_TO_V4MAPPED(htonl(INADDR_BROADCAST),
211 		    &dsmp->dsm_server);
212 	}
213 
214 	/* {Bound,Renew}->rebind transitions cannot fail */
215 	(void) set_smach_state(dsmp, REBINDING);
216 
217 	/*
218 	 * If there isn't an async event pending, or if we can cancel the one
219 	 * that's there, then try to rebind by sending an extension request.
220 	 * If that fails, we'll clean up when the lease expires.
221 	 */
222 	if (!async_cancel(dsmp) || !async_start(dsmp, DHCP_EXTEND, B_FALSE) ||
223 	    !dhcp_extending(dsmp)) {
224 		if (monosec() + RETRY_DELAY < expiremax) {
225 			/*
226 			 * Try again in RETRY_DELAY seconds; user command
227 			 * should be gone.
228 			 */
229 			init_timer(&dlp->dl_t2, RETRY_DELAY);
230 			(void) set_smach_state(dsmp, oldstate);
231 			if (!schedule_lease_timer(dlp, &dlp->dl_t2,
232 			    dhcp_rebind)) {
233 				dhcpmsg(MSG_INFO, "dhcp_rebind: unable to "
234 				    "reschedule rebind around user command on "
235 				    "%s; lease may expire", dsmp->dsm_name);
236 			}
237 		} else {
238 			dhcpmsg(MSG_WARNING, "dhcp_rebind: user busy on %s; "
239 			    "will expire", dsmp->dsm_name);
240 		}
241 	}
242 	release_lease(dlp);
243 }
244 
245 /*
246  * dhcp_finish_expire(): finish expiration of a lease after the user script
247  *			 runs.  If this is the last lease, then restart DHCP.
248  *			 The caller has a reference to the LIF, which will be
249  *			 dropped.
250  *
251  *   input: dhcp_smach_t *: the state machine to be restarted
252  *	    void *: logical interface that has expired
253  *  output: int: always 1
254  */
255 
256 static int
257 dhcp_finish_expire(dhcp_smach_t *dsmp, void *arg)
258 {
259 	dhcp_lif_t *lif = arg;
260 	dhcp_lease_t *dlp;
261 
262 	dhcpmsg(MSG_DEBUG, "lease expired on %s; removing", lif->lif_name);
263 
264 	dlp = lif->lif_lease;
265 	unplumb_lif(lif);
266 	if (dlp->dl_nlifs == 0)
267 		remove_lease(dlp);
268 	release_lif(lif);
269 
270 	/* If some valid leases remain, then drive on */
271 	if (dsmp->dsm_leases != NULL) {
272 		dhcpmsg(MSG_DEBUG,
273 		    "dhcp_finish_expire: some leases remain on %s",
274 		    dsmp->dsm_name);
275 		return (1);
276 	}
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
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
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
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
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