1 /* SPDX-License-Identifier: BSD-2-Clause */
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2020 Roy Marples <roy@marples.name>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
29 #include <arpa/inet.h>
39 #define ELOOP_QUEUE IPV4LL
46 #include "if-options.h"
53 static const struct in_addr inaddr_llmask = {
54 .s_addr = HTONL(LINKLOCAL_MASK)
56 static const struct in_addr inaddr_llbcast = {
57 .s_addr = HTONL(LINKLOCAL_BCAST)
61 ipv4ll_pickaddr(struct interface *ifp)
63 struct in_addr addr = { .s_addr = 0 };
64 struct ipv4ll_state *state;
66 state = IPV4LL_STATE(ifp);
67 setstate(state->randomstate);
73 /* RFC 3927 Section 2.1 states that the first 256 and
74 * last 256 addresses are reserved for future use.
75 * See ipv4ll_start for why we don't use arc4random. */
76 /* coverity[dont_call] */
78 addr.s_addr = ntohl(LINKLOCAL_ADDR |
79 ((uint32_t)(r % 0xFD00) + 0x0100));
81 /* No point using a failed address */
82 if (IN_ARE_ADDR_EQUAL(&addr, &state->pickedaddr))
84 /* Ensure we don't have the address on another interface */
85 } while (ipv4_findaddr(ifp->ctx, &addr) != NULL);
87 /* Restore the original random state */
88 setstate(ifp->ctx->randomstate);
89 state->pickedaddr = addr;
93 ipv4ll_subnetroute(rb_tree_t *routes, struct interface *ifp)
95 struct ipv4ll_state *state;
100 if ((state = IPV4LL_STATE(ifp)) == NULL ||
104 if ((rt = rt_new(ifp)) == NULL)
107 in.s_addr = state->addr->addr.s_addr & state->addr->mask.s_addr;
108 sa_in_init(&rt->rt_dest, &in);
109 in.s_addr = state->addr->mask.s_addr;
110 sa_in_init(&rt->rt_netmask, &in);
111 in.s_addr = INADDR_ANY;
112 sa_in_init(&rt->rt_gateway, &in);
113 sa_in_init(&rt->rt_ifa, &state->addr->addr);
114 return rt_proto_add(routes, rt) ? 1 : 0;
118 ipv4ll_defaultroute(rb_tree_t *routes, struct interface *ifp)
120 struct ipv4ll_state *state;
125 if ((state = IPV4LL_STATE(ifp)) == NULL ||
129 if ((rt = rt_new(ifp)) == NULL)
132 in.s_addr = INADDR_ANY;
133 sa_in_init(&rt->rt_dest, &in);
134 sa_in_init(&rt->rt_netmask, &in);
135 sa_in_init(&rt->rt_gateway, &in);
136 sa_in_init(&rt->rt_ifa, &state->addr->addr);
137 return rt_proto_add(routes, rt) ? 1 : 0;
141 ipv4ll_env(FILE *fp, const char *prefix, const struct interface *ifp)
143 const struct ipv4ll_state *state;
144 const char *pf = prefix == NULL ? "" : "_";
145 struct in_addr netnum;
148 if ((state = IPV4LL_CSTATE(ifp)) == NULL || state->addr == NULL)
151 /* Emulate a DHCP environment */
152 if (efprintf(fp, "%s%sip_address=%s",
153 prefix, pf, inet_ntoa(state->addr->addr)) == -1)
155 if (efprintf(fp, "%s%ssubnet_mask=%s",
156 prefix, pf, inet_ntoa(state->addr->mask)) == -1)
158 if (efprintf(fp, "%s%ssubnet_cidr=%d",
159 prefix, pf, inet_ntocidr(state->addr->mask)) == -1)
161 if (efprintf(fp, "%s%sbroadcast_address=%s",
162 prefix, pf, inet_ntoa(state->addr->brd)) == -1)
164 netnum.s_addr = state->addr->addr.s_addr & state->addr->mask.s_addr;
165 if (efprintf(fp, "%s%snetwork_number=%s",
166 prefix, pf, inet_ntoa(netnum)) == -1)
172 ipv4ll_announced_arp(struct arp_state *astate)
174 struct ipv4ll_state *state = IPV4LL_STATE(astate->iface);
176 state->conflicts = 0;
179 #ifndef KERNEL_RFC5227
180 /* This is the callback by ARP freeing */
182 ipv4ll_free_arp(struct arp_state *astate)
184 struct ipv4ll_state *state;
186 state = IPV4LL_STATE(astate->iface);
187 if (state != NULL && state->arp == astate)
191 /* This is us freeing any ARP state */
193 ipv4ll_freearp(struct interface *ifp)
195 struct ipv4ll_state *state;
197 state = IPV4LL_STATE(ifp);
198 if (state == NULL || state->arp == NULL)
201 eloop_timeout_delete(ifp->ctx->eloop, NULL, state->arp);
202 arp_free(state->arp);
206 #define ipv4ll_freearp(ifp)
210 ipv4ll_not_found(struct interface *ifp)
212 struct ipv4ll_state *state;
213 struct ipv4_addr *ia;
214 struct arp_state *astate;
216 state = IPV4LL_STATE(ifp);
217 ia = ipv4_iffindaddr(ifp, &state->pickedaddr, &inaddr_llmask);
218 #ifdef IN_IFF_NOTREADY
219 if (ia == NULL || ia->addr_flags & IN_IFF_NOTREADY)
221 loginfox("%s: using IPv4LL address %s",
222 ifp->name, inet_ntoa(state->pickedaddr));
224 if (ifp->ctx->options & DHCPCD_TEST)
226 ia = ipv4_addaddr(ifp, &state->pickedaddr,
227 &inaddr_llmask, &inaddr_llbcast,
228 DHCP_INFINITE_LIFETIME, DHCP_INFINITE_LIFETIME);
232 #ifdef IN_IFF_NOTREADY
233 if (ia->addr_flags & IN_IFF_NOTREADY)
235 logdebugx("%s: DAD completed for %s", ifp->name, ia->saddr);
241 if (ifp->ctx->options & DHCPCD_TEST) {
242 script_runreason(ifp, "TEST");
243 eloop_exit(ifp->ctx->eloop, EXIT_SUCCESS);
246 rt_build(ifp->ctx, AF_INET);
247 astate = arp_announceaddr(ifp->ctx, &ia->addr);
249 astate->announced_cb = ipv4ll_announced_arp;
250 script_runreason(ifp, "IPV4LL");
251 dhcpcd_daemonise(ifp->ctx);
255 ipv4ll_found(struct interface *ifp)
257 struct ipv4ll_state *state = IPV4LL_STATE(ifp);
260 if (++state->conflicts == MAX_CONFLICTS)
261 logerrx("%s: failed to acquire an IPv4LL address",
263 ipv4ll_pickaddr(ifp);
264 eloop_timeout_add_sec(ifp->ctx->eloop,
265 state->conflicts >= MAX_CONFLICTS ?
266 RATE_LIMIT_INTERVAL : PROBE_WAIT,
271 ipv4ll_defend_failed(struct interface *ifp)
273 struct ipv4ll_state *state = IPV4LL_STATE(ifp);
276 ipv4_deladdr(state->addr, 1);
278 rt_build(ifp->ctx, AF_INET);
279 script_runreason(ifp, "IPV4LL");
280 ipv4ll_pickaddr(ifp);
284 #ifndef KERNEL_RFC5227
286 ipv4ll_not_found_arp(struct arp_state *astate)
289 ipv4ll_not_found(astate->iface);
293 ipv4ll_found_arp(struct arp_state *astate, __unused const struct arp_msg *amsg)
296 ipv4ll_found(astate->iface);
300 ipv4ll_defend_failed_arp(struct arp_state *astate)
303 ipv4ll_defend_failed(astate->iface);
308 ipv4ll_start(void *arg)
310 struct interface *ifp = arg;
311 struct ipv4ll_state *state;
312 struct ipv4_addr *ia;
314 #ifndef KERNEL_RFC5227
315 struct arp_state *astate;
318 if ((state = IPV4LL_STATE(ifp)) == NULL) {
319 ifp->if_data[IF_DATA_IPV4LL] = calloc(1, sizeof(*state));
320 if ((state = IPV4LL_STATE(ifp)) == NULL) {
326 /* RFC 3927 Section 2.1 states that the random number generator
327 * SHOULD be seeded with a value derived from persistent information
328 * such as the IEEE 802 MAC address so that it usually picks
329 * the same address without persistent storage. */
330 if (!state->seeded) {
334 if (sizeof(seed) > ifp->hwlen) {
336 memcpy(&seed, ifp->hwaddr, ifp->hwlen);
338 memcpy(&seed, ifp->hwaddr + ifp->hwlen - sizeof(seed),
340 /* coverity[dont_call] */
341 orig = initstate(seed,
342 state->randomstate, sizeof(state->randomstate));
344 /* Save the original state. */
345 if (ifp->ctx->randomstate == NULL)
346 ifp->ctx->randomstate = orig;
348 /* Set back the original state until we need the seeded one. */
349 setstate(ifp->ctx->randomstate);
350 state->seeded = true;
353 /* Find the previosuly used address. */
354 if (state->pickedaddr.s_addr != INADDR_ANY)
355 ia = ipv4_iffindaddr(ifp, &state->pickedaddr, NULL);
359 /* Find an existing IPv4LL address and ensure we can work with it. */
361 ia = ipv4_iffindlladdr(ifp);
364 #ifdef IN_IFF_DUPLICATED
365 if (ia != NULL && ia->addr_flags & IN_IFF_DUPLICATED) {
366 state->pickedaddr = ia->addr; /* So it's not picked again. */
376 state->pickedaddr = ia->addr;
377 #ifdef IN_IFF_TENTATIVE
378 if (ia->addr_flags & (IN_IFF_TENTATIVE | IN_IFF_DETACHED)) {
379 loginfox("%s: waiting for DAD to complete on %s",
380 ifp->name, inet_ntoa(ia->addr));
384 #ifdef IN_IFF_DUPLICATED
385 loginfox("%s: using IPv4LL address %s", ifp->name, ia->saddr);
388 loginfox("%s: probing for an IPv4LL address", ifp->name);
389 if (repick || state->pickedaddr.s_addr == INADDR_ANY)
390 ipv4ll_pickaddr(ifp);
393 #ifdef KERNEL_RFC5227
394 ipv4ll_not_found(ifp);
397 state->arp = astate = arp_new(ifp, &state->pickedaddr);
398 if (state->arp == NULL)
401 astate->found_cb = ipv4ll_found_arp;
402 astate->not_found_cb = ipv4ll_not_found_arp;
403 astate->announced_cb = ipv4ll_announced_arp;
404 astate->defend_failed_cb = ipv4ll_defend_failed_arp;
405 astate->free_cb = ipv4ll_free_arp;
411 ipv4ll_drop(struct interface *ifp)
413 struct ipv4ll_state *state;
414 bool dropped = false;
415 struct ipv4_state *istate;
421 if ((ifp->options->options & DHCPCD_NODROP) == DHCPCD_NODROP)
424 state = IPV4LL_STATE(ifp);
425 if (state && state->addr != NULL) {
426 ipv4_deladdr(state->addr, 1);
431 /* Free any other link local addresses that might exist. */
432 if ((istate = IPV4_STATE(ifp)) != NULL) {
433 struct ipv4_addr *ia, *ian;
435 TAILQ_FOREACH_SAFE(ia, &istate->addrs, next, ian) {
436 if (IN_LINKLOCAL(ntohl(ia->addr.s_addr))) {
444 rt_build(ifp->ctx, AF_INET);
445 script_runreason(ifp, "IPV4LL");
450 ipv4ll_reset(struct interface *ifp)
452 struct ipv4ll_state *state = IPV4LL_STATE(ifp);
457 state->pickedaddr.s_addr = INADDR_ANY;
458 state->seeded = false;
462 ipv4ll_free(struct interface *ifp)
468 free(IPV4LL_STATE(ifp));
469 ifp->if_data[IF_DATA_IPV4LL] = NULL;
472 /* This may cause issues in BSD systems, where running as a single dhcpcd
473 * daemon would solve this issue easily. */
474 #ifdef HAVE_ROUTE_METRIC
476 ipv4ll_recvrt(__unused int cmd, const struct rt *rt)
478 struct dhcpcd_ctx *ctx;
479 struct interface *ifp;
481 /* Only interested in default route changes. */
482 if (sa_is_unspecified(&rt->rt_dest))
485 /* If any interface is running IPv4LL, rebuild our routing table. */
486 ctx = rt->rt_ifp->ctx;
487 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
488 if (IPV4LL_STATE_RUNNING(ifp)) {
489 rt_build(ctx, AF_INET);
499 ipv4ll_handleifa(int cmd, struct ipv4_addr *ia, pid_t pid)
501 struct interface *ifp;
502 struct ipv4ll_state *state;
505 state = IPV4LL_STATE(ifp);
509 if (cmd == RTM_DELADDR &&
510 state->addr != NULL &&
511 IN_ARE_ADDR_EQUAL(&state->addr->addr, &ia->addr))
513 loginfox("%s: pid %d deleted IP address %s",
514 ifp->name, pid, ia->saddr);
515 ipv4ll_defend_failed(ifp);
519 #ifdef IN_IFF_DUPLICATED
520 if (cmd != RTM_NEWADDR)
522 if (!IN_ARE_ADDR_EQUAL(&state->pickedaddr, &ia->addr))
524 if (!(ia->addr_flags & IN_IFF_NOTUSEABLE))
525 ipv4ll_not_found(ifp);
526 else if (ia->addr_flags & IN_IFF_DUPLICATED) {
527 logerrx("%s: DAD detected %s", ifp->name, ia->saddr);
531 rt_build(ifp->ctx, AF_INET);