1 #include <sys/cdefs.h>
2 __RCSID("$NetBSD: ipv4ll.c,v 1.12 2015/08/21 10:39:00 roy Exp $");
3
4 /*
5 * dhcpcd - DHCP client daemon
6 * Copyright (c) 2006-2015 Roy Marples <roy@marples.name>
7 * All rights reserved
8
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include <arpa/inet.h>
32
33 #include <assert.h>
34 #include <errno.h>
35 #include <signal.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <unistd.h>
39
40 #define ELOOP_QUEUE 6
41 #include "config.h"
42 #include "arp.h"
43 #include "common.h"
44 #include "eloop.h"
45 #include "if.h"
46 #include "if-options.h"
47 #include "ipv4.h"
48 #include "ipv4ll.h"
49 #include "script.h"
50
51 const struct in_addr inaddr_llmask = { HTONL(LINKLOCAL_MASK) };
52 const struct in_addr inaddr_llbcast = { HTONL(LINKLOCAL_BRDC) };
53
54 static in_addr_t
ipv4ll_pick_addr(const struct arp_state * astate)55 ipv4ll_pick_addr(const struct arp_state *astate)
56 {
57 struct in_addr addr;
58 struct ipv4ll_state *istate;
59
60 istate = IPV4LL_STATE(astate->iface);
61 setstate(istate->randomstate);
62
63 do {
64 /* RFC 3927 Section 2.1 states that the first 256 and
65 * last 256 addresses are reserved for future use.
66 * See ipv4ll_start for why we don't use arc4_random. */
67 addr.s_addr = ntohl(LINKLOCAL_ADDR |
68 ((uint32_t)(random() % 0xFD00) + 0x0100));
69
70 /* No point using a failed address */
71 if (addr.s_addr == astate->failed.s_addr)
72 continue;
73 /* Ensure we don't have the address on another interface */
74 } while (ipv4_findaddr(astate->iface->ctx, &addr) != NULL);
75
76 /* Restore the original random state */
77 setstate(astate->iface->ctx->randomstate);
78
79 return addr.s_addr;
80 }
81
82 struct rt *
ipv4ll_subnet_route(const struct interface * ifp)83 ipv4ll_subnet_route(const struct interface *ifp)
84 {
85 const struct ipv4ll_state *state;
86 struct rt *rt;
87
88 assert(ifp != NULL);
89 if ((state = IPV4LL_CSTATE(ifp)) == NULL ||
90 state->addr.s_addr == INADDR_ANY)
91 return NULL;
92
93 if ((rt = calloc(1, sizeof(*rt))) == NULL) {
94 logger(ifp->ctx, LOG_ERR, "%s: malloc: %m", __func__);
95 return NULL;
96 }
97 rt->iface = ifp;
98 rt->dest.s_addr = state->addr.s_addr & inaddr_llmask.s_addr;
99 rt->net = inaddr_llmask;
100 rt->gate.s_addr = INADDR_ANY;
101 rt->src = state->addr;
102 return rt;
103 }
104
105 struct rt *
ipv4ll_default_route(const struct interface * ifp)106 ipv4ll_default_route(const struct interface *ifp)
107 {
108 const struct ipv4ll_state *state;
109 struct rt *rt;
110
111 assert(ifp != NULL);
112 if ((state = IPV4LL_CSTATE(ifp)) == NULL ||
113 state->addr.s_addr == INADDR_ANY)
114 return NULL;
115
116 if ((rt = calloc(1, sizeof(*rt))) == NULL) {
117 logger(ifp->ctx, LOG_ERR, "%s: malloc: %m", __func__);
118 return NULL;
119 }
120 rt->iface = ifp;
121 rt->dest.s_addr = INADDR_ANY;
122 rt->net.s_addr = INADDR_ANY;
123 rt->gate.s_addr = INADDR_ANY;
124 rt->src = state->addr;
125 return rt;
126 }
127
128 ssize_t
ipv4ll_env(char ** env,const char * prefix,const struct interface * ifp)129 ipv4ll_env(char **env, const char *prefix, const struct interface *ifp)
130 {
131 const struct ipv4ll_state *state;
132 const char *pf = prefix == NULL ? "" : "_";
133 struct in_addr netnum;
134
135 assert(ifp != NULL);
136 if ((state = IPV4LL_CSTATE(ifp)) == NULL)
137 return 0;
138
139 if (env == NULL)
140 return 5;
141
142 /* Emulate a DHCP environment */
143 if (asprintf(&env[0], "%s%sip_address=%s",
144 prefix, pf, inet_ntoa(state->addr)) == -1)
145 return -1;
146 if (asprintf(&env[1], "%s%ssubnet_mask=%s",
147 prefix, pf, inet_ntoa(inaddr_llmask)) == -1)
148 return -1;
149 if (asprintf(&env[2], "%s%ssubnet_cidr=%d",
150 prefix, pf, inet_ntocidr(inaddr_llmask)) == -1)
151 return -1;
152 if (asprintf(&env[3], "%s%sbroadcast_address=%s",
153 prefix, pf, inet_ntoa(inaddr_llbcast)) == -1)
154 return -1;
155 netnum.s_addr = state->addr.s_addr & inaddr_llmask.s_addr;
156 if (asprintf(&env[4], "%s%snetwork_number=%s",
157 prefix, pf, inet_ntoa(netnum)) == -1)
158 return -1;
159 return 5;
160 }
161
162 static void
ipv4ll_probed(struct arp_state * astate)163 ipv4ll_probed(struct arp_state *astate)
164 {
165 struct interface *ifp;
166 struct ipv4ll_state *state;
167 struct ipv4_addr *ia;
168
169 assert(astate != NULL);
170 assert(astate->iface != NULL);
171
172 ifp = astate->iface;
173 state = IPV4LL_STATE(ifp);
174 assert(state != NULL);
175
176 ia = ipv4_iffindaddr(ifp, &astate->addr, &inaddr_llmask);
177 #ifdef IN_IFF_NOTREADY
178 if (ia == NULL || ia->addr_flags & IN_IFF_NOTREADY)
179 #endif
180 logger(ifp->ctx, LOG_INFO, "%s: using IPv4LL address %s",
181 ifp->name, inet_ntoa(astate->addr));
182 if (ia == NULL)
183 ia = ipv4_addaddr(ifp, &astate->addr,
184 &inaddr_llmask, &inaddr_llbcast);
185 if (ia == NULL)
186 return;
187 #ifdef IN_IFF_NOTREADY
188 if (ia->addr_flags & IN_IFF_NOTREADY)
189 return;
190 logger(ifp->ctx, LOG_DEBUG, "%s: DAD completed for %s",
191 ifp->name, inet_ntoa(astate->addr));
192 #endif
193 state->addr = astate->addr;
194 timespecclear(&state->defend);
195 if_initrt(ifp);
196 ipv4_buildroutes(ifp->ctx);
197 arp_announce(astate);
198 script_runreason(ifp, "IPV4LL");
199 dhcpcd_daemonise(ifp->ctx);
200 }
201
202 static void
ipv4ll_announced(struct arp_state * astate)203 ipv4ll_announced(struct arp_state *astate)
204 {
205 struct ipv4ll_state *state = IPV4LL_STATE(astate->iface);
206
207 state->conflicts = 0;
208 /* Need to keep the arp state so we can defend our IP. */
209 }
210
211 static void
ipv4ll_probe(void * arg)212 ipv4ll_probe(void *arg)
213 {
214
215 #ifdef IN_IFF_TENTATIVE
216 ipv4ll_probed(arg);
217 #else
218 arp_probe(arg);
219 #endif
220 }
221
222 static void
ipv4ll_conflicted(struct arp_state * astate,const struct arp_msg * amsg)223 ipv4ll_conflicted(struct arp_state *astate, const struct arp_msg *amsg)
224 {
225 struct interface *ifp;
226 struct ipv4ll_state *state;
227 in_addr_t fail;
228
229 assert(astate != NULL);
230 assert(astate->iface != NULL);
231 ifp = astate->iface;
232 state = IPV4LL_STATE(ifp);
233 assert(state != NULL);
234
235 fail = 0;
236 /* RFC 3927 2.2.1, Probe Conflict Detection */
237 if (amsg == NULL ||
238 (amsg->sip.s_addr == astate->addr.s_addr ||
239 (amsg->sip.s_addr == 0 && amsg->tip.s_addr == astate->addr.s_addr)))
240 fail = astate->addr.s_addr;
241
242 /* RFC 3927 2.5, Conflict Defense */
243 if (IN_LINKLOCAL(ntohl(state->addr.s_addr)) &&
244 amsg && amsg->sip.s_addr == state->addr.s_addr)
245 fail = state->addr.s_addr;
246
247 if (fail == 0)
248 return;
249
250 astate->failed.s_addr = fail;
251 arp_report_conflicted(astate, amsg);
252
253 if (astate->failed.s_addr == state->addr.s_addr) {
254 struct timespec now, defend;
255
256 /* RFC 3927 Section 2.5 */
257 defend.tv_sec = state->defend.tv_sec + DEFEND_INTERVAL;
258 defend.tv_nsec = state->defend.tv_nsec;
259 clock_gettime(CLOCK_MONOTONIC, &now);
260 if (timespeccmp(&defend, &now, >)) {
261 logger(ifp->ctx, LOG_WARNING,
262 "%s: IPv4LL %d second defence failed for %s",
263 ifp->name, DEFEND_INTERVAL,
264 inet_ntoa(state->addr));
265 ipv4_deladdr(ifp, &state->addr, &inaddr_llmask, 1);
266 state->down = 1;
267 script_runreason(ifp, "IPV4LL");
268 state->addr.s_addr = INADDR_ANY;
269 } else {
270 logger(ifp->ctx, LOG_DEBUG,
271 "%s: defended IPv4LL address %s",
272 ifp->name, inet_ntoa(state->addr));
273 state->defend = now;
274 return;
275 }
276 }
277
278 arp_cancel(astate);
279 if (++state->conflicts == MAX_CONFLICTS)
280 logger(ifp->ctx, LOG_ERR,
281 "%s: failed to acquire an IPv4LL address",
282 ifp->name);
283 astate->addr.s_addr = ipv4ll_pick_addr(astate);
284 eloop_timeout_add_sec(ifp->ctx->eloop,
285 state->conflicts >= MAX_CONFLICTS ?
286 RATE_LIMIT_INTERVAL : PROBE_WAIT,
287 ipv4ll_probe, astate);
288 }
289
290 static void
ipv4ll_arpfree(struct arp_state * astate)291 ipv4ll_arpfree(struct arp_state *astate)
292 {
293 struct ipv4ll_state *state;
294
295 state = IPV4LL_STATE(astate->iface);
296 if (state->arp == astate)
297 state->arp = NULL;
298 }
299
300 void
ipv4ll_start(void * arg)301 ipv4ll_start(void *arg)
302 {
303 struct interface *ifp;
304 struct ipv4ll_state *state;
305 struct arp_state *astate;
306 struct ipv4_addr *ia;
307
308 assert(arg != NULL);
309 ifp = arg;
310 if ((state = IPV4LL_STATE(ifp)) == NULL) {
311 ifp->if_data[IF_DATA_IPV4LL] = calloc(1, sizeof(*state));
312 if ((state = IPV4LL_STATE(ifp)) == NULL) {
313 syslog(LOG_ERR, "%s: calloc %m", __func__);
314 return;
315 }
316
317 state->addr.s_addr = INADDR_ANY;
318 }
319
320 if (state->arp != NULL)
321 return;
322
323 /* RFC 3927 Section 2.1 states that the random number generator
324 * SHOULD be seeded with a value derived from persistent information
325 * such as the IEEE 802 MAC address so that it usually picks
326 * the same address without persistent storage. */
327 if (state->conflicts == 0) {
328 unsigned int seed;
329 char *orig;
330
331 if (sizeof(seed) > ifp->hwlen) {
332 seed = 0;
333 memcpy(&seed, ifp->hwaddr, ifp->hwlen);
334 } else
335 memcpy(&seed, ifp->hwaddr + ifp->hwlen - sizeof(seed),
336 sizeof(seed));
337 orig = initstate(seed,
338 state->randomstate, sizeof(state->randomstate));
339
340 /* Save the original state. */
341 if (ifp->ctx->randomstate == NULL)
342 ifp->ctx->randomstate = orig;
343
344 /* Set back the original state until we need the seeded one. */
345 setstate(ifp->ctx->randomstate);
346 }
347
348 if ((astate = arp_new(ifp, NULL)) == NULL)
349 return;
350
351 state->arp = astate;
352 astate->probed_cb = ipv4ll_probed;
353 astate->announced_cb = ipv4ll_announced;
354 astate->conflicted_cb = ipv4ll_conflicted;
355 astate->free_cb = ipv4ll_arpfree;
356
357 /* Find an existing IPv4LL address and ensure we can work with it. */
358 ia = ipv4_iffindlladdr(ifp);
359 #ifdef IN_IFF_TENTATIVE
360 if (ia != NULL && ia->addr_flags & IN_IFF_DUPLICATED) {
361 ipv4_deladdr(ifp, &ia->addr, &ia->net, 0);
362 ia = NULL;
363 }
364 #endif
365 if (ia != NULL) {
366 astate->addr = ia->addr;
367 #ifdef IN_IFF_TENTATIVE
368 if (ia->addr_flags & (IN_IFF_TENTATIVE | IN_IFF_DETACHED)) {
369 logger(ifp->ctx, LOG_INFO,
370 "%s: waiting for DAD to complete on %s",
371 ifp->name, inet_ntoa(ia->addr));
372 return;
373 }
374 logger(ifp->ctx, LOG_INFO, "%s: using IPv4LL address %s",
375 ifp->name, inet_ntoa(astate->addr));
376 #endif
377 ipv4ll_probed(astate);
378 return;
379 }
380
381 logger(ifp->ctx, LOG_INFO, "%s: probing for an IPv4LL address",
382 ifp->name);
383 astate->addr.s_addr = ipv4ll_pick_addr(astate);
384 #ifdef IN_IFF_TENTATIVE
385 ipv4ll_probed(astate);
386 #else
387 arp_probe(astate);
388 #endif
389 }
390
391 void
ipv4ll_freedrop(struct interface * ifp,int drop)392 ipv4ll_freedrop(struct interface *ifp, int drop)
393 {
394 struct ipv4ll_state *state;
395 int dropped;
396
397 assert(ifp != NULL);
398 state = IPV4LL_STATE(ifp);
399 dropped = 0;
400
401 /* Free ARP state first because ipv4_deladdr might also ... */
402 if (state && state->arp) {
403 eloop_timeout_delete(ifp->ctx->eloop, NULL, state->arp);
404 arp_free(state->arp);
405 state->arp = NULL;
406 }
407
408 if (drop && (ifp->options->options & DHCPCD_NODROP) != DHCPCD_NODROP) {
409 struct ipv4_state *istate;
410
411 if (state && state->addr.s_addr != INADDR_ANY) {
412 ipv4_deladdr(ifp, &state->addr, &inaddr_llmask, 1);
413 state->addr.s_addr = INADDR_ANY;
414 dropped = 1;
415 }
416
417 /* Free any other link local addresses that might exist. */
418 if ((istate = IPV4_STATE(ifp)) != NULL) {
419 struct ipv4_addr *ia, *ian;
420
421 TAILQ_FOREACH_SAFE(ia, &istate->addrs, next, ian) {
422 if (IN_LINKLOCAL(ntohl(ia->addr.s_addr))) {
423 ipv4_deladdr(ifp, &ia->addr,
424 &ia->net, 0);
425 dropped = 1;
426 }
427 }
428 }
429 }
430
431 if (state) {
432 free(state);
433 ifp->if_data[IF_DATA_IPV4LL] = NULL;
434
435 if (dropped) {
436 ipv4_buildroutes(ifp->ctx);
437 script_runreason(ifp, "IPV4LL");
438 }
439 }
440 }
441