1/* SPDX-License-Identifier: BSD-2-Clause */
2/*
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2023 Roy Marples <roy@marples.name>
5 * All rights reserved
6
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/socket.h>
30#include <sys/types.h>
31
32#include <arpa/inet.h>
33#include <net/if.h>
34#include <net/route.h>
35#include <netinet/if_ether.h>
36#include <netinet/in.h>
37
38#include <assert.h>
39#include <ctype.h>
40#include <errno.h>
41#include <stdbool.h>
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45#include <unistd.h>
46
47#include "config.h"
48#include "arp.h"
49#include "common.h"
50#include "dhcpcd.h"
51#include "dhcp.h"
52#include "eloop.h"
53#include "if.h"
54#include "if-options.h"
55#include "ipv4.h"
56#include "ipv4ll.h"
57#include "logerr.h"
58#include "route.h"
59#include "script.h"
60#include "sa.h"
61
62#define IPV4_LOOPBACK_ROUTE
63#if defined(__linux__) || defined(__sun) || (defined(BSD) && defined(RTF_LOCAL))
64/* Linux has had loopback routes in the local table since 2.2
65 * Solaris does not seem to support loopback routes. */
66#undef IPV4_LOOPBACK_ROUTE
67#endif
68
69uint8_t
70inet_ntocidr(struct in_addr address)
71{
72	uint8_t cidr = 0;
73	uint32_t mask = htonl(address.s_addr);
74
75	while (mask) {
76		cidr++;
77		mask <<= 1;
78	}
79	return cidr;
80}
81
82int
83inet_cidrtoaddr(int cidr, struct in_addr *addr)
84{
85	int ocets;
86
87	if (cidr < 1 || cidr > 32) {
88		errno = EINVAL;
89		return -1;
90	}
91	ocets = (cidr + 7) / NBBY;
92
93	addr->s_addr = 0;
94	if (ocets > 0) {
95		memset(&addr->s_addr, 255, (size_t)ocets - 1);
96		memset((unsigned char *)&addr->s_addr + (ocets - 1),
97		    (256 - (1 << (32 - cidr) % NBBY)), 1);
98	}
99
100	return 0;
101}
102
103uint32_t
104ipv4_getnetmask(uint32_t addr)
105{
106	uint32_t dst;
107
108	if (addr == 0)
109		return 0;
110
111	dst = htonl(addr);
112	if (IN_CLASSA(dst))
113		return ntohl(IN_CLASSA_NET);
114	if (IN_CLASSB(dst))
115		return ntohl(IN_CLASSB_NET);
116	if (IN_CLASSC(dst))
117		return ntohl(IN_CLASSC_NET);
118
119	return 0;
120}
121
122struct ipv4_addr *
123ipv4_iffindaddr(struct interface *ifp,
124    const struct in_addr *addr, const struct in_addr *mask)
125{
126	struct ipv4_state *state;
127	struct ipv4_addr *ap;
128
129	state = IPV4_STATE(ifp);
130	if (state) {
131		TAILQ_FOREACH(ap, &state->addrs, next) {
132			if ((addr == NULL || ap->addr.s_addr == addr->s_addr) &&
133			    (mask == NULL || ap->mask.s_addr == mask->s_addr))
134				return ap;
135		}
136	}
137	return NULL;
138}
139
140struct ipv4_addr *
141ipv4_iffindlladdr(struct interface *ifp)
142{
143	struct ipv4_state *state;
144	struct ipv4_addr *ap;
145
146	state = IPV4_STATE(ifp);
147	if (state) {
148		TAILQ_FOREACH(ap, &state->addrs, next) {
149			if (IN_LINKLOCAL(ntohl(ap->addr.s_addr)))
150				return ap;
151		}
152	}
153	return NULL;
154}
155
156static struct ipv4_addr *
157ipv4_iffindmaskaddr(struct interface *ifp, const struct in_addr *addr)
158{
159	struct ipv4_state *state;
160	struct ipv4_addr *ap;
161
162	state = IPV4_STATE(ifp);
163	if (state) {
164		TAILQ_FOREACH (ap, &state->addrs, next) {
165			if ((ap->addr.s_addr & ap->mask.s_addr) ==
166			    (addr->s_addr & ap->mask.s_addr))
167				return ap;
168		}
169	}
170	return NULL;
171}
172
173static struct ipv4_addr *
174ipv4_iffindmaskbrd(struct interface *ifp, const struct in_addr *addr)
175{
176	struct ipv4_state *state;
177	struct ipv4_addr *ap;
178
179	state = IPV4_STATE(ifp);
180	if (state) {
181		TAILQ_FOREACH (ap, &state->addrs, next) {
182			if ((ap->brd.s_addr & ap->mask.s_addr) ==
183			    (addr->s_addr & ap->mask.s_addr))
184				return ap;
185		}
186	}
187	return NULL;
188}
189
190struct ipv4_addr *
191ipv4_findaddr(struct dhcpcd_ctx *ctx, const struct in_addr *addr)
192{
193	struct interface *ifp;
194	struct ipv4_addr *ap;
195
196	TAILQ_FOREACH(ifp, ctx->ifaces, next) {
197		ap = ipv4_iffindaddr(ifp, addr, NULL);
198		if (ap)
199			return ap;
200	}
201	return NULL;
202}
203
204struct ipv4_addr *
205ipv4_findmaskaddr(struct dhcpcd_ctx *ctx, const struct in_addr *addr)
206{
207	struct interface *ifp;
208	struct ipv4_addr *ap;
209
210	TAILQ_FOREACH(ifp, ctx->ifaces, next) {
211		ap = ipv4_iffindmaskaddr(ifp, addr);
212		if (ap)
213			return ap;
214	}
215	return NULL;
216}
217
218struct ipv4_addr *
219ipv4_findmaskbrd(struct dhcpcd_ctx *ctx, const struct in_addr *addr)
220{
221	struct interface *ifp;
222	struct ipv4_addr *ap;
223
224	TAILQ_FOREACH(ifp, ctx->ifaces, next) {
225		ap = ipv4_iffindmaskbrd(ifp, addr);
226		if (ap)
227			return ap;
228	}
229	return NULL;
230}
231
232int
233ipv4_hasaddr(const struct interface *ifp)
234{
235	const struct dhcp_state *dstate;
236
237#ifdef IPV4LL
238	if (IPV4LL_STATE_RUNNING(ifp))
239		return 1;
240#endif
241
242	dstate = D_CSTATE(ifp);
243	return (dstate &&
244	    dstate->added == STATE_ADDED &&
245	    dstate->addr != NULL);
246}
247
248/* Interface comparer for working out ordering. */
249int
250ipv4_ifcmp(const struct interface *si, const struct interface *ti)
251{
252	const struct dhcp_state *sis, *tis;
253
254	sis = D_CSTATE(si);
255	tis = D_CSTATE(ti);
256	if (sis && !tis)
257		return -1;
258	if (!sis && tis)
259		return 1;
260	if (!sis && !tis)
261		return 0;
262	/* If one has a lease and the other not, it takes precedence. */
263	if (sis->new && !tis->new)
264		return -1;
265	if (!sis->new && tis->new)
266		return 1;
267	/* Always prefer proper leases */
268	if (!(sis->added & STATE_FAKE) && (tis->added & STATE_FAKE))
269		return -1;
270	if ((sis->added & STATE_FAKE) && !(tis->added & STATE_FAKE))
271		return 1;
272	/* If we are either, they neither have a lease, or they both have.
273	 * We need to check for IPv4LL and make it non-preferred. */
274	if (sis->new && tis->new) {
275		if (IS_DHCP(sis->new) && !IS_DHCP(tis->new))
276			return -1;
277		if (!IS_DHCP(sis->new) && IS_DHCP(tis->new))
278			return 1;
279	}
280	return 0;
281}
282
283static int
284inet_dhcproutes(rb_tree_t *routes, struct interface *ifp, bool *have_default)
285{
286	const struct dhcp_state *state;
287	rb_tree_t nroutes;
288	struct rt *rt, *r = NULL;
289	struct in_addr in;
290	uint16_t mtu;
291	int n;
292
293	state = D_CSTATE(ifp);
294	if (state == NULL || state->state != DHS_BOUND || !state->added)
295		return 0;
296
297	/* An address does have to exist. */
298	assert(state->addr);
299
300	rb_tree_init(&nroutes, &rt_compare_proto_ops);
301
302	/* First, add a subnet route. */
303	if (state->addr->mask.s_addr != INADDR_ANY
304#ifndef BSD
305	    /* BSD adds a route in this instance */
306	    && state->addr->mask.s_addr != INADDR_BROADCAST
307#endif
308	) {
309		if ((rt = rt_new(ifp)) == NULL)
310			return -1;
311		rt->rt_dflags |= RTDF_IFA_ROUTE;
312		in.s_addr = state->addr->addr.s_addr & state->addr->mask.s_addr;
313		sa_in_init(&rt->rt_dest, &in);
314		in.s_addr = state->addr->mask.s_addr;
315		sa_in_init(&rt->rt_netmask, &in);
316		//in.s_addr = INADDR_ANY;
317		//sa_in_init(&rt->rt_gateway, &in);
318		rt->rt_gateway.sa_family = AF_UNSPEC;
319		rt_proto_add(&nroutes, rt);
320	}
321
322	/* If any set routes, grab them, otherwise DHCP routes. */
323	if (RB_TREE_MIN(&ifp->options->routes)) {
324		RB_TREE_FOREACH(r, &ifp->options->routes) {
325			if (sa_is_unspecified(&r->rt_gateway))
326				break;
327			if ((rt = rt_new0(ifp->ctx)) == NULL)
328				return -1;
329			memcpy(rt, r, sizeof(*rt));
330			rt_setif(rt, ifp);
331			rt->rt_dflags = RTDF_STATIC;
332			rt_proto_add(&nroutes, rt);
333		}
334	} else {
335		if (dhcp_get_routes(&nroutes, ifp) == -1)
336			return -1;
337	}
338
339	/* If configured, install a gateway to the desintion
340	 * for P2P interfaces. */
341	if (ifp->flags & IFF_POINTOPOINT &&
342	    has_option_mask(ifp->options->dstmask, DHO_ROUTER))
343	{
344		if ((rt = rt_new(ifp)) == NULL)
345			return -1;
346		in.s_addr = INADDR_ANY;
347		sa_in_init(&rt->rt_dest, &in);
348		sa_in_init(&rt->rt_netmask, &in);
349		sa_in_init(&rt->rt_gateway, &state->addr->brd);
350		sa_in_init(&rt->rt_ifa, &state->addr->addr);
351		rt_proto_add(&nroutes, rt);
352	}
353
354	/* Copy our address as the source address and set mtu */
355	mtu = dhcp_get_mtu(ifp);
356	n = 0;
357	while ((rt = RB_TREE_MIN(&nroutes)) != NULL) {
358		rb_tree_remove_node(&nroutes, rt);
359		rt->rt_mtu = mtu;
360		if (!(rt->rt_dflags & RTDF_STATIC))
361			rt->rt_dflags |= RTDF_DHCP;
362		sa_in_init(&rt->rt_ifa, &state->addr->addr);
363		if (rb_tree_insert_node(routes, rt) != rt) {
364			rt_free(rt);
365			continue;
366		}
367		if (rt_is_default(rt))
368			*have_default = true;
369		n = 1;
370	}
371
372	return n;
373}
374
375/* We should check to ensure the routers are on the same subnet
376 * OR supply a host route. If not, warn and add a host route. */
377static int
378inet_routerhostroute(rb_tree_t *routes, struct interface *ifp)
379{
380	struct rt *rt, *rth, *rtp;
381	struct sockaddr_in *dest, *netmask, *gateway;
382	const char *cp, *cp2, *cp3, *cplim;
383	struct if_options *ifo;
384	const struct dhcp_state *state;
385	struct in_addr in;
386	rb_tree_t troutes;
387
388	/* Don't add a host route for these interfaces. */
389	if (ifp->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))
390		return 0;
391
392	rb_tree_init(&troutes, &rt_compare_proto_ops);
393
394	RB_TREE_FOREACH(rt, routes) {
395		if (rt->rt_dest.sa_family != AF_INET)
396			continue;
397		if (!sa_is_unspecified(&rt->rt_dest) ||
398		    sa_is_unspecified(&rt->rt_gateway))
399			continue;
400		gateway = satosin(&rt->rt_gateway);
401		/* Scan for a route to match */
402		RB_TREE_FOREACH(rth, routes) {
403			if (rth == rt)
404				break;
405			/* match host */
406			if (sa_cmp(&rth->rt_dest, &rt->rt_gateway) == 0)
407				break;
408			/* match subnet */
409			/* XXX ADD TO RT_COMARE? XXX */
410			cp = (const char *)&gateway->sin_addr.s_addr;
411			dest = satosin(&rth->rt_dest);
412			cp2 = (const char *)&dest->sin_addr.s_addr;
413			netmask = satosin(&rth->rt_netmask);
414			cp3 = (const char *)&netmask->sin_addr.s_addr;
415			cplim = cp3 + sizeof(netmask->sin_addr.s_addr);
416			while (cp3 < cplim) {
417				if ((*cp++ ^ *cp2++) & *cp3++)
418					break;
419			}
420			if (cp3 == cplim)
421				break;
422		}
423		if (rth != rt)
424			continue;
425		if ((state = D_CSTATE(ifp)) == NULL)
426			continue;
427		ifo = ifp->options;
428		if (ifp->flags & IFF_NOARP) {
429			if (!(ifo->options & DHCPCD_ROUTER_HOST_ROUTE_WARNED) &&
430			    !(state->added & STATE_FAKE))
431			{
432				char buf[INET_MAX_ADDRSTRLEN];
433
434				ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED;
435				logwarnx("%s: forcing router %s through "
436				    "interface",
437				    ifp->name,
438				    sa_addrtop(&rt->rt_gateway,
439				    buf, sizeof(buf)));
440			}
441			gateway->sin_addr.s_addr = INADDR_ANY;
442			continue;
443		}
444		if (!(ifo->options & DHCPCD_ROUTER_HOST_ROUTE_WARNED) &&
445		    !(state->added & STATE_FAKE))
446		{
447			char buf[INET_MAX_ADDRSTRLEN];
448
449			ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED;
450			logwarnx("%s: router %s requires a host route",
451			    ifp->name,
452			    sa_addrtop(&rt->rt_gateway, buf, sizeof(buf)));
453		}
454
455		if ((rth = rt_new(ifp)) == NULL)
456			return -1;
457		rth->rt_flags |= RTF_HOST;
458		sa_in_init(&rth->rt_dest, &gateway->sin_addr);
459		in.s_addr = INADDR_BROADCAST;
460		sa_in_init(&rth->rt_netmask, &in);
461		in.s_addr = INADDR_ANY;
462		sa_in_init(&rth->rt_gateway, &in);
463		rth->rt_mtu = dhcp_get_mtu(ifp);
464		if (state->addr != NULL)
465			sa_in_init(&rth->rt_ifa, &state->addr->addr);
466		else
467			rth->rt_ifa.sa_family = AF_UNSPEC;
468
469		/* We need to insert the host route just before the router. */
470		while ((rtp = RB_TREE_MAX(routes)) != NULL) {
471			rb_tree_remove_node(routes, rtp);
472			rt_proto_add(&troutes, rtp);
473			if (rtp == rt)
474				break;
475		}
476		rt_proto_add(routes, rth);
477		/* troutes is now reversed, so add backwards again. */
478		while ((rtp = RB_TREE_MAX(&troutes)) != NULL) {
479			rb_tree_remove_node(&troutes, rtp);
480			rt_proto_add(routes, rtp);
481		}
482	}
483	return 0;
484}
485
486bool
487inet_getroutes(struct dhcpcd_ctx *ctx, rb_tree_t *routes)
488{
489	struct interface *ifp;
490	bool have_default = false;
491
492	TAILQ_FOREACH(ifp, ctx->ifaces, next) {
493		if (!ifp->active)
494			continue;
495		if (inet_dhcproutes(routes, ifp, &have_default) == -1)
496			return false;
497#ifdef IPV4LL
498		if (ipv4ll_subnetroute(routes, ifp) == -1)
499			return false;
500#endif
501		if (inet_routerhostroute(routes, ifp) == -1)
502			return false;
503	}
504
505#ifdef IPV4LL
506	/* If there is no default route, see if we can use an IPv4LL one. */
507	if (have_default)
508		return true;
509
510	TAILQ_FOREACH(ifp, ctx->ifaces, next) {
511		if (ifp->active &&
512		    ipv4ll_defaultroute(routes, ifp) == 1)
513			break;
514	}
515#endif
516
517	return true;
518}
519
520int
521ipv4_deladdr(struct ipv4_addr *addr, int keeparp)
522{
523	int r;
524	struct ipv4_state *state;
525	struct ipv4_addr *ap;
526
527	logdebugx("%s: deleting IP address %s",
528	    addr->iface->name, addr->saddr);
529
530	r = if_address(RTM_DELADDR, addr);
531	if (r == -1 &&
532	    errno != EADDRNOTAVAIL && errno != ESRCH &&
533	    errno != ENXIO && errno != ENODEV)
534		logerr("%s: %s", addr->iface->name, __func__);
535
536#ifdef ARP
537	if (!keeparp)
538		arp_freeaddr(addr->iface, &addr->addr);
539#else
540	UNUSED(keeparp);
541#endif
542
543	state = IPV4_STATE(addr->iface);
544	TAILQ_FOREACH(ap, &state->addrs, next) {
545		if (IPV4_MASK_EQ(ap, addr)) {
546			struct dhcp_state *dstate;
547
548			dstate = D_STATE(ap->iface);
549			TAILQ_REMOVE(&state->addrs, ap, next);
550			free(ap);
551
552			if (dstate && dstate->addr == ap) {
553				dstate->added = 0;
554				dstate->addr = NULL;
555			}
556			break;
557		}
558	}
559
560	return r;
561}
562
563static int
564delete_address(struct interface *ifp)
565{
566	int r;
567	struct if_options *ifo;
568	struct dhcp_state *state;
569
570	state = D_STATE(ifp);
571	ifo = ifp->options;
572	/* The lease could have been added, but the address deleted
573	 * by a 3rd party. */
574	if (state->addr == NULL ||
575	    ifo->options & DHCPCD_INFORM ||
576	    (ifo->options & DHCPCD_STATIC && ifo->req_addr.s_addr == 0))
577		return 0;
578#ifdef ARP
579	arp_freeaddr(ifp, &state->addr->addr);
580#endif
581	r = ipv4_deladdr(state->addr, 0);
582	return r;
583}
584
585struct ipv4_state *
586ipv4_getstate(struct interface *ifp)
587{
588	struct ipv4_state *state;
589
590	state = IPV4_STATE(ifp);
591	if (state == NULL) {
592	        ifp->if_data[IF_DATA_IPV4] = malloc(sizeof(*state));
593		state = IPV4_STATE(ifp);
594		if (state == NULL) {
595			logerr(__func__);
596			return NULL;
597		}
598		TAILQ_INIT(&state->addrs);
599	}
600	return state;
601}
602
603#ifdef ALIAS_ADDR
604/* Find the next logical aliase address we can use. */
605static int
606ipv4_aliasaddr(struct ipv4_addr *ia, struct ipv4_addr **repl)
607{
608	struct ipv4_state *state;
609	struct ipv4_addr *iap;
610	unsigned int lun;
611	char alias[IF_NAMESIZE];
612
613	if (ia->alias[0] != '\0')
614		return 0;
615
616	lun = 0;
617	state = IPV4_STATE(ia->iface);
618find_lun:
619	if (if_makealias(alias, IF_NAMESIZE, ia->iface->name, lun) >=
620	    IF_NAMESIZE)
621	{
622		errno = ENOMEM;
623		return -1;
624	}
625	TAILQ_FOREACH(iap, &state->addrs, next) {
626		if (iap->alias[0] != '\0' && iap->addr.s_addr == INADDR_ANY) {
627			/* No address assigned? Lets use it. */
628			strlcpy(ia->alias, iap->alias, sizeof(ia->alias));
629			if (repl)
630				*repl = iap;
631			return 1;
632		}
633		if (strcmp(iap->alias, alias) == 0)
634			break;
635	}
636
637	if (iap != NULL) {
638		if (lun == UINT_MAX) {
639			errno = ERANGE;
640			return -1;
641		}
642		lun++;
643		goto find_lun;
644	}
645
646	strlcpy(ia->alias, alias, sizeof(ia->alias));
647	return 0;
648}
649#endif
650
651struct ipv4_addr *
652ipv4_addaddr(struct interface *ifp, const struct in_addr *addr,
653    const struct in_addr *mask, const struct in_addr *bcast,
654    uint32_t vltime, uint32_t pltime)
655{
656	struct ipv4_state *state;
657	struct ipv4_addr *ia;
658#ifdef ALIAS_ADDR
659	int replaced, blank;
660	struct ipv4_addr *replaced_ia;
661#endif
662
663	if ((state = ipv4_getstate(ifp)) == NULL) {
664		logerr(__func__);
665		return NULL;
666	}
667	if (ifp->options->options & DHCPCD_NOALIAS) {
668		struct ipv4_addr *ian;
669
670		TAILQ_FOREACH_SAFE(ia, &state->addrs, next, ian) {
671			if (ia->addr.s_addr != addr->s_addr)
672				ipv4_deladdr(ia, 0);
673		}
674	}
675
676	ia = ipv4_iffindaddr(ifp, addr, NULL);
677	if (ia == NULL) {
678		ia = malloc(sizeof(*ia));
679		if (ia == NULL) {
680			logerr(__func__);
681			return NULL;
682		}
683		ia->iface = ifp;
684		ia->addr = *addr;
685#ifdef IN_IFF_TENTATIVE
686		ia->addr_flags = IN_IFF_TENTATIVE;
687#endif
688		ia->flags = IPV4_AF_NEW;
689	} else
690		ia->flags &= ~IPV4_AF_NEW;
691
692	ia->mask = *mask;
693	ia->brd = *bcast;
694#ifdef IP_LIFETIME
695	if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) {
696		/* We don't want the kernel to expire the address. */
697		ia->vltime = ia->pltime = DHCP_INFINITE_LIFETIME;
698	} else {
699		ia->vltime = vltime;
700		ia->pltime = pltime;
701	}
702#else
703	UNUSED(vltime);
704	UNUSED(pltime);
705#endif
706	snprintf(ia->saddr, sizeof(ia->saddr), "%s/%d",
707	    inet_ntoa(*addr), inet_ntocidr(*mask));
708
709#ifdef ALIAS_ADDR
710	blank = (ia->alias[0] == '\0');
711	if ((replaced = ipv4_aliasaddr(ia, &replaced_ia)) == -1) {
712		logerr("%s: ipv4_aliasaddr", ifp->name);
713		free(ia);
714		return NULL;
715	}
716	if (blank)
717		logdebugx("%s: aliased %s", ia->alias, ia->saddr);
718#endif
719
720	logdebugx("%s: adding IP address %s %s %s",
721	    ifp->name, ia->saddr,
722	    ifp->flags & IFF_POINTOPOINT ? "destination" : "broadcast",
723	    inet_ntoa(*bcast));
724	if (if_address(RTM_NEWADDR, ia) == -1) {
725		if (errno != EEXIST)
726			logerr("%s: if_addaddress",
727			    __func__);
728		if (ia->flags & IPV4_AF_NEW)
729			free(ia);
730		return NULL;
731	}
732
733#ifdef ALIAS_ADDR
734	if (replaced) {
735		TAILQ_REMOVE(&state->addrs, replaced_ia, next);
736		free(replaced_ia);
737	}
738#endif
739
740	if (ia->flags & IPV4_AF_NEW)
741		TAILQ_INSERT_TAIL(&state->addrs, ia, next);
742	return ia;
743}
744
745static int
746ipv4_daddaddr(struct interface *ifp, const struct dhcp_lease *lease)
747{
748	struct dhcp_state *state;
749	struct ipv4_addr *ia;
750
751	ia = ipv4_addaddr(ifp, &lease->addr, &lease->mask, &lease->brd,
752	    lease->leasetime, lease->rebindtime);
753	if (ia == NULL)
754		return -1;
755
756	state = D_STATE(ifp);
757	state->added = STATE_ADDED;
758	state->addr = ia;
759	return 0;
760}
761
762struct ipv4_addr *
763ipv4_applyaddr(void *arg)
764{
765	struct interface *ifp = arg;
766	struct dhcp_state *state = D_STATE(ifp);
767	struct dhcp_lease *lease;
768	struct if_options *ifo = ifp->options;
769	struct ipv4_addr *ia;
770
771	if (state == NULL)
772		return NULL;
773
774	lease = &state->lease;
775	if (state->new == NULL) {
776		if ((ifo->options & (DHCPCD_EXITING | DHCPCD_PERSISTENT)) !=
777		    (DHCPCD_EXITING | DHCPCD_PERSISTENT))
778		{
779			if (state->added) {
780				delete_address(ifp);
781				rt_build(ifp->ctx, AF_INET);
782#ifdef ARP
783				/* Announce the preferred address to
784				 * kick ARP caches. */
785				arp_announceaddr(ifp->ctx,&lease->addr);
786#endif
787			}
788			script_runreason(ifp, state->reason);
789		} else
790			rt_build(ifp->ctx, AF_INET);
791		return NULL;
792	}
793
794	ia = ipv4_iffindaddr(ifp, &lease->addr, NULL);
795	/* If the netmask or broadcast is different, re-add the addresss.
796	 * If IP addresses do not have lifetimes, there is a very real chance
797	 * that re-adding them will scrub the subnet route temporarily
798	 * which is a bad thing, so avoid it. */
799	if (ia != NULL &&
800	    ia->mask.s_addr == lease->mask.s_addr &&
801	    ia->brd.s_addr == lease->brd.s_addr)
802	{
803#ifndef IP_LIFETIME
804		logdebugx("%s: IP address %s already exists",
805		    ifp->name, ia->saddr);
806#endif
807	} else {
808#ifdef __linux__
809		/* Linux does not change netmask/broadcast address
810		 * for re-added addresses, so we need to delete the old one
811		 * first. */
812		if (ia != NULL)
813			ipv4_deladdr(ia, 0);
814#endif
815#ifndef IP_LIFETIME
816		if (ipv4_daddaddr(ifp, lease) == -1 && errno != EEXIST)
817			return NULL;
818#endif
819	}
820#ifdef IP_LIFETIME
821	if (ipv4_daddaddr(ifp, lease) == -1 && errno != EEXIST)
822		return NULL;
823#endif
824
825	ia = ipv4_iffindaddr(ifp, &lease->addr, NULL);
826	if (ia == NULL) {
827		logerrx("%s: added address vanished", ifp->name);
828		return NULL;
829	}
830#if defined(ARP) && defined(IN_IFF_NOTUSEABLE)
831	if (ia->addr_flags & IN_IFF_NOTUSEABLE)
832		return NULL;
833#endif
834
835	/* Delete the old address if different */
836	if (state->addr &&
837	    state->addr->addr.s_addr != lease->addr.s_addr &&
838	    ipv4_iffindaddr(ifp, &lease->addr, NULL))
839		delete_address(ifp);
840
841	state->addr = ia;
842	state->added = STATE_ADDED;
843
844	rt_build(ifp->ctx, AF_INET);
845
846#ifdef ARP
847	arp_announceaddr(ifp->ctx, &state->addr->addr);
848#endif
849
850	if (state->state == DHS_BOUND) {
851		script_runreason(ifp, state->reason);
852		dhcpcd_daemonise(ifp->ctx);
853	}
854	return ia;
855}
856
857void
858ipv4_markaddrsstale(struct interface *ifp)
859{
860	struct ipv4_state *state;
861	struct ipv4_addr *ia;
862
863	state = IPV4_STATE(ifp);
864	if (state == NULL)
865		return;
866
867	TAILQ_FOREACH(ia, &state->addrs, next) {
868		ia->flags |= IPV4_AF_STALE;
869	}
870}
871
872void
873ipv4_deletestaleaddrs(struct interface *ifp)
874{
875	struct ipv4_state *state;
876	struct ipv4_addr *ia, *ia1;
877
878	state = IPV4_STATE(ifp);
879	if (state == NULL)
880		return;
881
882	TAILQ_FOREACH_SAFE(ia, &state->addrs, next, ia1) {
883		if (!(ia->flags & IPV4_AF_STALE))
884			continue;
885		ipv4_handleifa(ifp->ctx, RTM_DELADDR,
886		    ifp->ctx->ifaces, ifp->name,
887		    &ia->addr, &ia->mask, &ia->brd, 0, getpid());
888	}
889}
890
891void
892ipv4_handleifa(struct dhcpcd_ctx *ctx,
893    int cmd, struct if_head *ifs, const char *ifname,
894    const struct in_addr *addr, const struct in_addr *mask,
895    const struct in_addr *brd, int addrflags, pid_t pid)
896{
897	struct interface *ifp;
898	struct ipv4_state *state;
899	struct ipv4_addr *ia;
900	bool ia_is_new;
901
902#if 0
903	char sbrdbuf[INET_ADDRSTRLEN];
904	const char *sbrd;
905
906	if (brd)
907		sbrd = inet_ntop(AF_INET, brd, sbrdbuf, sizeof(sbrdbuf));
908	else
909		sbrd = NULL;
910	logdebugx("%s: %s %s/%d %s %d", ifname,
911	    cmd == RTM_NEWADDR ? "RTM_NEWADDR" :
912	    cmd == RTM_DELADDR ? "RTM_DELADDR" : "???",
913	    inet_ntoa(*addr), inet_ntocidr(*mask), sbrd, addrflags);
914#endif
915
916	if (ifs == NULL)
917		ifs = ctx->ifaces;
918	if (ifs == NULL) {
919		errno = ESRCH;
920		return;
921	}
922	if ((ifp = if_find(ifs, ifname)) == NULL)
923		return;
924	if ((state = ipv4_getstate(ifp)) == NULL) {
925		errno = ENOENT;
926		return;
927	}
928
929	ia = ipv4_iffindaddr(ifp, addr, NULL);
930	switch (cmd) {
931	case RTM_NEWADDR:
932		if (ia == NULL) {
933			if ((ia = malloc(sizeof(*ia))) == NULL) {
934				logerr(__func__);
935				return;
936			}
937			ia->iface = ifp;
938			ia->addr = *addr;
939			ia->mask = *mask;
940			ia->flags = 0;
941			ia_is_new = true;
942#ifdef ALIAS_ADDR
943			strlcpy(ia->alias, ifname, sizeof(ia->alias));
944#endif
945			TAILQ_INSERT_TAIL(&state->addrs, ia, next);
946		} else
947			ia_is_new = false;
948		/* Mask could have changed */
949		if (ia_is_new ||
950		    (mask->s_addr != INADDR_ANY &&
951		    mask->s_addr != ia->mask.s_addr))
952		{
953			ia->mask = *mask;
954			snprintf(ia->saddr, sizeof(ia->saddr), "%s/%d",
955			    inet_ntoa(*addr), inet_ntocidr(*mask));
956		}
957		if (brd != NULL)
958			ia->brd = *brd;
959		else
960			ia->brd.s_addr = INADDR_ANY;
961		ia->addr_flags = addrflags;
962		ia->flags &= ~IPV4_AF_STALE;
963		break;
964	case RTM_DELADDR:
965		if (ia == NULL)
966			return;
967		if (mask->s_addr != INADDR_ANY &&
968		    mask->s_addr != ia->mask.s_addr)
969			return;
970		TAILQ_REMOVE(&state->addrs, ia, next);
971		break;
972	default:
973		return;
974	}
975
976	if (addr->s_addr != INADDR_ANY && addr->s_addr != INADDR_BROADCAST) {
977		ia = dhcp_handleifa(cmd, ia, pid);
978#ifdef IPV4LL
979		if (ia != NULL)
980			ipv4ll_handleifa(cmd, ia, pid);
981#endif
982	}
983
984	if (cmd == RTM_DELADDR)
985		free(ia);
986}
987
988void
989ipv4_free(struct interface *ifp)
990{
991	struct ipv4_state *state;
992	struct ipv4_addr *ia;
993
994	if (ifp == NULL || (state = IPV4_STATE(ifp)) == NULL)
995		return;
996
997	while ((ia = TAILQ_FIRST(&state->addrs))) {
998		TAILQ_REMOVE(&state->addrs, ia, next);
999		free(ia);
1000	}
1001	free(state);
1002}
1003