File: | src/sbin/iked/vroute.c |
Warning: | line 358, column 2 Value stored to 'ptr' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: vroute.c,v 1.15 2021/12/01 16:42:13 deraadt Exp $ */ |
2 | |
3 | /* |
4 | * Copyright (c) 2021 Tobias Heider <tobhe@openbsd.org> |
5 | * |
6 | * Permission to use, copy, modify, and distribute this software for any |
7 | * purpose with or without fee is hereby granted, provided that the above |
8 | * copyright notice and this permission notice appear in all copies. |
9 | * |
10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
17 | */ |
18 | |
19 | #include <sys/ioctl.h> |
20 | |
21 | #include <net/if.h> |
22 | #include <net/route.h> |
23 | #include <netinet/in.h> |
24 | #include <netinet6/in6_var.h> |
25 | #include <netinet6/nd6.h> |
26 | |
27 | #include <event.h> |
28 | #include <err.h> |
29 | #include <errno(*__errno()).h> |
30 | #include <poll.h> |
31 | #include <string.h> |
32 | #include <strings.h> |
33 | #include <unistd.h> |
34 | #include <netdb.h> |
35 | |
36 | #include <iked.h> |
37 | |
38 | #define ROUTE_SOCKET_BUF_SIZE16384 16384 |
39 | #define IKED_VROUTE_PRIO6 6 |
40 | |
41 | #define ROUNDUP(a)(a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long )) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) |
42 | |
43 | int vroute_setroute(struct iked *, uint8_t, struct sockaddr *, uint8_t, |
44 | struct sockaddr *, int); |
45 | int vroute_doroute(struct iked *, int, int, int, uint8_t, struct sockaddr *, |
46 | struct sockaddr *, struct sockaddr *, int *); |
47 | int vroute_doaddr(struct iked *, char *, struct sockaddr *, struct sockaddr *, int); |
48 | int vroute_dodns(struct iked *, struct sockaddr *, int, unsigned int); |
49 | void vroute_cleanup(struct iked *); |
50 | void vroute_rtmsg_cb(int, short, void *); |
51 | |
52 | void vroute_insertaddr(struct iked *, int, struct sockaddr *, struct sockaddr *); |
53 | void vroute_removeaddr(struct iked *, int, struct sockaddr *, struct sockaddr *); |
54 | void vroute_insertdns(struct iked *, int, struct sockaddr *); |
55 | void vroute_removedns(struct iked *, int, struct sockaddr *); |
56 | void vroute_insertroute(struct iked *, int, struct sockaddr *, struct sockaddr *); |
57 | void vroute_removeroute(struct iked *, int, struct sockaddr *, struct sockaddr *); |
58 | |
59 | struct vroute_addr { |
60 | int va_ifidx; |
61 | struct sockaddr_storage va_addr; |
62 | struct sockaddr_storage va_mask; |
63 | TAILQ_ENTRY(vroute_addr)struct { struct vroute_addr *tqe_next; struct vroute_addr **tqe_prev ; } va_entry; |
64 | }; |
65 | TAILQ_HEAD(vroute_addrs, vroute_addr)struct vroute_addrs { struct vroute_addr *tqh_first; struct vroute_addr **tqh_last; }; |
66 | |
67 | struct vroute_route { |
68 | int vr_rdomain; |
69 | int vr_flags; |
70 | struct sockaddr_storage vr_dest; |
71 | struct sockaddr_storage vr_mask; |
72 | TAILQ_ENTRY(vroute_route)struct { struct vroute_route *tqe_next; struct vroute_route * *tqe_prev; } vr_entry; |
73 | }; |
74 | TAILQ_HEAD(vroute_routes, vroute_route)struct vroute_routes { struct vroute_route *tqh_first; struct vroute_route **tqh_last; }; |
75 | |
76 | struct vroute_dns { |
77 | struct sockaddr_storage vd_addr; |
78 | int vd_ifidx; |
79 | }; |
80 | |
81 | struct iked_vroute_sc { |
82 | struct vroute_addrs ivr_addrs; |
83 | struct vroute_routes ivr_routes; |
84 | struct vroute_dns *ivr_dns; |
85 | struct event ivr_routeev; |
86 | int ivr_iosock; |
87 | int ivr_iosock6; |
88 | int ivr_rtsock; |
89 | int ivr_rtseq; |
90 | pid_t ivr_pid; |
91 | }; |
92 | |
93 | struct vroute_msg { |
94 | struct rt_msghdr vm_rtm; |
95 | uint8_t vm_space[512]; |
96 | }; |
97 | |
98 | int vroute_process(struct iked *, int msglen, struct vroute_msg *, |
99 | struct sockaddr *, struct sockaddr *, struct sockaddr *, int *); |
100 | |
101 | void |
102 | vroute_rtmsg_cb(int fd, short events, void *arg) |
103 | { |
104 | struct iked *env = (struct iked *) arg; |
105 | struct iked_vroute_sc *ivr = env->sc_vroute; |
106 | static uint8_t *buf; |
107 | struct rt_msghdr *rtm; |
108 | ssize_t n; |
109 | |
110 | if (buf == NULL((void *)0)) { |
111 | buf = malloc(ROUTE_SOCKET_BUF_SIZE16384); |
112 | if (buf == NULL((void *)0)) |
113 | fatal("malloc"); |
114 | } |
115 | rtm = (struct rt_msghdr *)buf; |
116 | if ((n = read(fd, buf, ROUTE_SOCKET_BUF_SIZE16384)) == -1) { |
117 | if (errno(*__errno()) == EAGAIN35 || errno(*__errno()) == EINTR4) |
118 | return; |
119 | log_warn("%s: read error", __func__); |
120 | return; |
121 | } |
122 | |
123 | if (n == 0) |
124 | fatal("routing socket closed"); |
125 | |
126 | if (n < (ssize_t)sizeof(rtm->rtm_msglen) || n < rtm->rtm_msglen) { |
127 | log_warnx("partial rtm of %zd in buffer", n); |
128 | return; |
129 | } |
130 | |
131 | if (rtm->rtm_version != RTM_VERSION5) |
132 | return; |
133 | |
134 | switch(rtm->rtm_type) { |
135 | case RTM_PROPOSAL0x13: |
136 | if (rtm->rtm_priority == RTP_PROPOSAL_SOLICIT62) { |
137 | log_debug("%s: got solicit", __func__); |
138 | vroute_dodns(env, (struct sockaddr *)&ivr->ivr_dns->vd_addr, 1, |
139 | ivr->ivr_dns->vd_ifidx); |
140 | } |
141 | break; |
142 | default: |
143 | log_debug("%s: unexpected RTM: %d", __func__, rtm->rtm_type); |
144 | break; |
145 | } |
146 | } |
147 | |
148 | void |
149 | vroute_init(struct iked *env) |
150 | { |
151 | struct iked_vroute_sc *ivr; |
152 | int rtfilter; |
153 | |
154 | ivr = calloc(1, sizeof(*ivr)); |
155 | if (ivr == NULL((void *)0)) |
156 | fatal("%s: calloc.", __func__); |
157 | |
158 | if ((ivr->ivr_iosock = socket(AF_INET2, SOCK_DGRAM2, 0)) == -1) |
159 | fatal("%s: failed to create ioctl socket", __func__); |
160 | |
161 | if ((ivr->ivr_iosock6 = socket(AF_INET624, SOCK_DGRAM2, 0)) == -1) |
162 | fatal("%s: failed to create ioctl socket", __func__); |
163 | |
164 | if ((ivr->ivr_rtsock = socket(AF_ROUTE17, SOCK_RAW3, AF_UNSPEC0)) == -1) |
165 | fatal("%s: failed to create routing socket", __func__); |
166 | |
167 | rtfilter = ROUTE_FILTER(RTM_GET)(1 << (0x4)) | ROUTE_FILTER(RTM_PROPOSAL)(1 << (0x13)); |
168 | if (setsockopt(ivr->ivr_rtsock, AF_ROUTE17, ROUTE_MSGFILTER1, &rtfilter, |
169 | sizeof(rtfilter)) == -1) |
170 | fatal("%s: setsockopt(ROUTE_MSGFILTER)", __func__); |
171 | |
172 | TAILQ_INIT(&ivr->ivr_addrs)do { (&ivr->ivr_addrs)->tqh_first = ((void *)0); (& ivr->ivr_addrs)->tqh_last = &(&ivr->ivr_addrs )->tqh_first; } while (0); |
173 | TAILQ_INIT(&ivr->ivr_routes)do { (&ivr->ivr_routes)->tqh_first = ((void *)0); ( &ivr->ivr_routes)->tqh_last = &(&ivr->ivr_routes )->tqh_first; } while (0); |
174 | |
175 | ivr->ivr_pid = getpid(); |
176 | |
177 | env->sc_vroute = ivr; |
178 | |
179 | event_set(&ivr->ivr_routeev, ivr->ivr_rtsock, EV_READ0x02 | EV_PERSIST0x10, |
180 | vroute_rtmsg_cb, env); |
181 | event_add(&ivr->ivr_routeev, NULL((void *)0)); |
182 | } |
183 | |
184 | void |
185 | vroute_cleanup(struct iked *env) |
186 | { |
187 | char ifname[IF_NAMESIZE16]; |
188 | struct iked_vroute_sc *ivr = env->sc_vroute; |
189 | struct vroute_addr *addr; |
190 | struct vroute_route *route; |
191 | |
192 | while ((addr = TAILQ_FIRST(&ivr->ivr_addrs)((&ivr->ivr_addrs)->tqh_first))) { |
193 | if_indextoname(addr->va_ifidx, ifname); |
194 | vroute_doaddr(env, ifname, |
195 | (struct sockaddr *)&addr->va_addr, |
196 | (struct sockaddr *)&addr->va_mask, 0); |
197 | TAILQ_REMOVE(&ivr->ivr_addrs, addr, va_entry)do { if (((addr)->va_entry.tqe_next) != ((void *)0)) (addr )->va_entry.tqe_next->va_entry.tqe_prev = (addr)->va_entry .tqe_prev; else (&ivr->ivr_addrs)->tqh_last = (addr )->va_entry.tqe_prev; *(addr)->va_entry.tqe_prev = (addr )->va_entry.tqe_next; ; ; } while (0); |
198 | free(addr); |
199 | } |
200 | |
201 | while ((route = TAILQ_FIRST(&ivr->ivr_routes)((&ivr->ivr_routes)->tqh_first))) { |
202 | vroute_doroute(env, RTF_UP0x1 | RTF_GATEWAY0x2 | RTF_STATIC0x800, |
203 | route->vr_flags, route->vr_rdomain, RTM_DELETE0x2, |
204 | (struct sockaddr *)&route->vr_dest, |
205 | (struct sockaddr *)&route->vr_mask, |
206 | NULL((void *)0), NULL((void *)0)); |
207 | TAILQ_REMOVE(&ivr->ivr_routes, route, vr_entry)do { if (((route)->vr_entry.tqe_next) != ((void *)0)) (route )->vr_entry.tqe_next->vr_entry.tqe_prev = (route)->vr_entry .tqe_prev; else (&ivr->ivr_routes)->tqh_last = (route )->vr_entry.tqe_prev; *(route)->vr_entry.tqe_prev = (route )->vr_entry.tqe_next; ; ; } while (0); |
208 | free(route); |
209 | } |
210 | |
211 | if (ivr->ivr_dns) { |
212 | vroute_dodns(env, (struct sockaddr *)&ivr->ivr_dns->vd_addr, 0, |
213 | ivr->ivr_dns->vd_ifidx); |
214 | free(ivr->ivr_dns); |
215 | } |
216 | } |
217 | |
218 | int |
219 | vroute_setaddr(struct iked *env, int add, struct sockaddr *addr, |
220 | int mask, unsigned int ifidx) |
221 | { |
222 | struct iovec iov[4]; |
223 | int iovcnt; |
224 | struct sockaddr_in mask4; |
225 | struct sockaddr_in6 mask6; |
226 | |
227 | iovcnt = 0; |
228 | iov[0].iov_base = addr; |
229 | iov[0].iov_len = addr->sa_len; |
230 | iovcnt++; |
231 | |
232 | switch(addr->sa_family) { |
233 | case AF_INET2: |
234 | bzero(&mask, sizeof(mask)); |
235 | mask4.sin_addr.s_addr = prefixlen2mask(mask ? mask : 32); |
236 | mask4.sin_family = AF_INET2; |
237 | mask4.sin_len = sizeof(mask4); |
238 | |
239 | iov[1].iov_base = &mask4; |
240 | iov[1].iov_len = sizeof(mask4); |
241 | iovcnt++; |
242 | break; |
243 | case AF_INET624: |
244 | bzero(&mask6, sizeof(mask6)); |
245 | prefixlen2mask6(mask ? mask : 128, |
246 | (uint32_t *)&mask6.sin6_addr.s6_addr__u6_addr.__u6_addr8); |
247 | mask6.sin6_family = AF_INET624; |
248 | mask6.sin6_len = sizeof(mask6); |
249 | iov[1].iov_base = &mask6; |
250 | iov[1].iov_len = sizeof(mask6); |
251 | iovcnt++; |
252 | break; |
253 | default: |
254 | return -1; |
255 | } |
256 | |
257 | iov[2].iov_base = &ifidx; |
258 | iov[2].iov_len = sizeof(ifidx); |
259 | iovcnt++; |
260 | |
261 | return (proc_composev(&env->sc_ps, PROC_PARENT, |
262 | add ? IMSG_IF_ADDADDR : IMSG_IF_DELADDR, iov, iovcnt)); |
263 | } |
264 | |
265 | int |
266 | vroute_getaddr(struct iked *env, struct imsg *imsg) |
267 | { |
268 | char ifname[IF_NAMESIZE16]; |
269 | struct sockaddr *addr, *mask; |
270 | uint8_t *ptr; |
271 | size_t left; |
272 | int af, add; |
273 | unsigned int ifidx; |
274 | |
275 | ptr = imsg->data; |
276 | left = IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)); |
277 | |
278 | if (left < sizeof(*addr)) |
279 | fatalx("bad length imsg received"); |
280 | |
281 | addr = (struct sockaddr *) ptr; |
282 | af = addr->sa_family; |
283 | |
284 | if (left < addr->sa_len) |
285 | fatalx("bad length imsg received"); |
286 | ptr += addr->sa_len; |
287 | left -= addr->sa_len; |
288 | |
289 | if (left < sizeof(*mask)) |
290 | fatalx("bad length imsg received"); |
291 | mask = (struct sockaddr *) ptr; |
292 | if (mask->sa_family != af) |
293 | return (-1); |
294 | |
295 | if (left < mask->sa_len) |
296 | fatalx("bad length imsg received"); |
297 | ptr += mask->sa_len; |
298 | left -= mask->sa_len; |
299 | |
300 | if (left != sizeof(ifidx)) |
301 | fatalx("bad length imsg received"); |
302 | memcpy(&ifidx, ptr, sizeof(ifidx)); |
303 | ptr += sizeof(ifidx); |
304 | left -= sizeof(ifidx); |
305 | |
306 | add = (imsg->hdr.type == IMSG_IF_ADDADDR); |
307 | /* Store address for cleanup */ |
308 | if (add) |
309 | vroute_insertaddr(env, ifidx, addr, mask); |
310 | else |
311 | vroute_removeaddr(env, ifidx, addr, mask); |
312 | |
313 | if_indextoname(ifidx, ifname); |
314 | return (vroute_doaddr(env, ifname, addr, mask, add)); |
315 | } |
316 | |
317 | int |
318 | vroute_setdns(struct iked *env, int add, struct sockaddr *addr, |
319 | unsigned int ifidx) |
320 | { |
321 | struct iovec iov[2]; |
322 | |
323 | iov[0].iov_base = addr; |
324 | iov[0].iov_len = addr->sa_len; |
325 | |
326 | iov[1].iov_base = &ifidx; |
327 | iov[1].iov_len = sizeof(ifidx); |
328 | |
329 | return (proc_composev(&env->sc_ps, PROC_PARENT, |
330 | add ? IMSG_VDNS_ADD: IMSG_VDNS_DEL, iov, 2)); |
331 | } |
332 | |
333 | int |
334 | vroute_getdns(struct iked *env, struct imsg *imsg) |
335 | { |
336 | struct iked_vroute_sc *ivr = env->sc_vroute; |
337 | struct sockaddr *dns; |
338 | uint8_t *ptr; |
339 | size_t left; |
340 | int add; |
341 | unsigned int ifidx; |
342 | |
343 | ptr = imsg->data; |
344 | left = IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)); |
345 | |
346 | if (left < sizeof(*dns)) |
347 | fatalx("bad length imsg received"); |
348 | |
349 | dns = (struct sockaddr *) ptr; |
350 | if (left < dns->sa_len) |
351 | fatalx("bad length imsg received"); |
352 | ptr += dns->sa_len; |
353 | left -= dns->sa_len; |
354 | |
355 | if (left != sizeof(ifidx)) |
356 | fatalx("bad length imsg received"); |
357 | memcpy(&ifidx, ptr, sizeof(ifidx)); |
358 | ptr += sizeof(ifidx); |
Value stored to 'ptr' is never read | |
359 | left -= sizeof(ifidx); |
360 | |
361 | add = (imsg->hdr.type == IMSG_VDNS_ADD); |
362 | if (add) { |
363 | if (ivr->ivr_dns != NULL((void *)0)) |
364 | return (0); |
365 | vroute_insertdns(env, ifidx, dns); |
366 | } else { |
367 | if (ivr->ivr_dns == NULL((void *)0)) |
368 | return (0); |
369 | vroute_removedns(env, ifidx, dns); |
370 | } |
371 | |
372 | return (vroute_dodns(env, dns, add, ifidx)); |
373 | } |
374 | |
375 | void |
376 | vroute_insertroute(struct iked *env, int rdomain, struct sockaddr *dest, |
377 | struct sockaddr *mask) |
378 | { |
379 | struct iked_vroute_sc *ivr = env->sc_vroute; |
380 | struct vroute_route *route; |
381 | |
382 | route = calloc(1, sizeof(*route)); |
383 | if (route == NULL((void *)0)) |
384 | fatalx("%s: calloc.", __func__); |
385 | |
386 | if (dest != NULL((void *)0)) { |
387 | route->vr_flags |= RTA_DST0x1; |
388 | memcpy(&route->vr_dest, dest, dest->sa_len); |
389 | } |
390 | if (mask != NULL((void *)0)) { |
391 | route->vr_flags |= RTA_NETMASK0x4; |
392 | memcpy(&route->vr_mask, mask, mask->sa_len); |
393 | } |
394 | route->vr_rdomain = rdomain; |
395 | |
396 | TAILQ_INSERT_TAIL(&ivr->ivr_routes, route, vr_entry)do { (route)->vr_entry.tqe_next = ((void *)0); (route)-> vr_entry.tqe_prev = (&ivr->ivr_routes)->tqh_last; * (&ivr->ivr_routes)->tqh_last = (route); (&ivr-> ivr_routes)->tqh_last = &(route)->vr_entry.tqe_next ; } while (0); |
397 | } |
398 | |
399 | void |
400 | vroute_removeroute(struct iked *env, int rdomain, struct sockaddr *dest, |
401 | struct sockaddr *mask) |
402 | { |
403 | struct iked_vroute_sc *ivr = env->sc_vroute; |
404 | struct vroute_route *route, *troute; |
405 | |
406 | TAILQ_FOREACH_SAFE(route, &ivr->ivr_routes, vr_entry, troute)for ((route) = ((&ivr->ivr_routes)->tqh_first); (route ) != ((void *)0) && ((troute) = ((route)->vr_entry .tqe_next), 1); (route) = (troute)) { |
407 | if (sockaddr_cmp(dest, (struct sockaddr *)&route->vr_dest, -1)) |
408 | continue; |
409 | if (mask && !(route->vr_flags & RTA_NETMASK0x4)) |
410 | continue; |
411 | if (mask && |
412 | sockaddr_cmp(mask, (struct sockaddr *)&route->vr_mask, -1)) |
413 | continue; |
414 | if (rdomain != route->vr_rdomain) |
415 | continue; |
416 | TAILQ_REMOVE(&ivr->ivr_routes, route, vr_entry)do { if (((route)->vr_entry.tqe_next) != ((void *)0)) (route )->vr_entry.tqe_next->vr_entry.tqe_prev = (route)->vr_entry .tqe_prev; else (&ivr->ivr_routes)->tqh_last = (route )->vr_entry.tqe_prev; *(route)->vr_entry.tqe_prev = (route )->vr_entry.tqe_next; ; ; } while (0); |
417 | free(route); |
418 | } |
419 | } |
420 | |
421 | void |
422 | vroute_insertdns(struct iked *env, int ifidx, struct sockaddr *addr) |
423 | { |
424 | struct iked_vroute_sc *ivr = env->sc_vroute; |
425 | struct vroute_dns *dns; |
426 | |
427 | dns = calloc(1, sizeof(*dns)); |
428 | if (dns == NULL((void *)0)) |
429 | fatalx("%s: calloc.", __func__); |
430 | |
431 | memcpy(&dns->vd_addr, addr, addr->sa_len); |
432 | dns->vd_ifidx = ifidx; |
433 | |
434 | ivr->ivr_dns = dns; |
435 | } |
436 | |
437 | void |
438 | vroute_removedns(struct iked *env, int ifidx, struct sockaddr *addr) |
439 | { |
440 | struct iked_vroute_sc *ivr = env->sc_vroute; |
441 | |
442 | if (ifidx == ivr->ivr_dns->vd_ifidx && |
443 | sockaddr_cmp(addr, (struct sockaddr *) |
444 | &ivr->ivr_dns->vd_addr, -1) == 0) { |
445 | free(ivr->ivr_dns); |
446 | ivr->ivr_dns = NULL((void *)0); |
447 | } |
448 | } |
449 | |
450 | void |
451 | vroute_insertaddr(struct iked *env, int ifidx, struct sockaddr *addr, |
452 | struct sockaddr *mask) |
453 | { |
454 | struct iked_vroute_sc *ivr = env->sc_vroute; |
455 | struct vroute_addr *vaddr; |
456 | |
457 | vaddr = calloc(1, sizeof(*vaddr)); |
458 | if (vaddr == NULL((void *)0)) |
459 | fatalx("%s: calloc.", __func__); |
460 | |
461 | memcpy(&vaddr->va_addr, addr, addr->sa_len); |
462 | memcpy(&vaddr->va_mask, mask, mask->sa_len); |
463 | vaddr->va_ifidx = ifidx; |
464 | |
465 | TAILQ_INSERT_TAIL(&ivr->ivr_addrs, vaddr, va_entry)do { (vaddr)->va_entry.tqe_next = ((void *)0); (vaddr)-> va_entry.tqe_prev = (&ivr->ivr_addrs)->tqh_last; *( &ivr->ivr_addrs)->tqh_last = (vaddr); (&ivr-> ivr_addrs)->tqh_last = &(vaddr)->va_entry.tqe_next; } while (0); |
466 | } |
467 | |
468 | void |
469 | vroute_removeaddr(struct iked *env, int ifidx, struct sockaddr *addr, |
470 | struct sockaddr *mask) |
471 | { |
472 | struct iked_vroute_sc *ivr = env->sc_vroute; |
473 | struct vroute_addr *vaddr, *tvaddr; |
474 | |
475 | TAILQ_FOREACH_SAFE(vaddr, &ivr->ivr_addrs, va_entry, tvaddr)for ((vaddr) = ((&ivr->ivr_addrs)->tqh_first); (vaddr ) != ((void *)0) && ((tvaddr) = ((vaddr)->va_entry .tqe_next), 1); (vaddr) = (tvaddr)) { |
476 | if (sockaddr_cmp(addr, (struct sockaddr *)&vaddr->va_addr, -1)) |
477 | continue; |
478 | if (sockaddr_cmp(mask, (struct sockaddr *)&vaddr->va_mask, -1)) |
479 | continue; |
480 | if (ifidx != vaddr->va_ifidx) |
481 | continue; |
482 | TAILQ_REMOVE(&ivr->ivr_addrs, vaddr, va_entry)do { if (((vaddr)->va_entry.tqe_next) != ((void *)0)) (vaddr )->va_entry.tqe_next->va_entry.tqe_prev = (vaddr)->va_entry .tqe_prev; else (&ivr->ivr_addrs)->tqh_last = (vaddr )->va_entry.tqe_prev; *(vaddr)->va_entry.tqe_prev = (vaddr )->va_entry.tqe_next; ; ; } while (0); |
483 | free(vaddr); |
484 | } |
485 | } |
486 | |
487 | int |
488 | vroute_setaddroute(struct iked *env, uint8_t rdomain, struct sockaddr *dst, |
489 | uint8_t mask, struct sockaddr *ifa) |
490 | { |
491 | return (vroute_setroute(env, rdomain, dst, mask, ifa, |
492 | IMSG_VROUTE_ADD)); |
493 | } |
494 | |
495 | int |
496 | vroute_setcloneroute(struct iked *env, uint8_t rdomain, struct sockaddr *dst, |
497 | uint8_t mask, struct sockaddr *addr) |
498 | { |
499 | return (vroute_setroute(env, rdomain, dst, mask, addr, |
500 | IMSG_VROUTE_CLONE)); |
501 | } |
502 | |
503 | int |
504 | vroute_setdelroute(struct iked *env, uint8_t rdomain, struct sockaddr *dst, |
505 | uint8_t mask, struct sockaddr *addr) |
506 | { |
507 | return (vroute_setroute(env, rdomain, dst, mask, addr, |
508 | IMSG_VROUTE_DEL)); |
509 | } |
510 | |
511 | int |
512 | vroute_setroute(struct iked *env, uint8_t rdomain, struct sockaddr *dst, |
513 | uint8_t mask, struct sockaddr *addr, int type) |
514 | { |
515 | struct sockaddr_storage sa; |
516 | struct sockaddr_in *in; |
517 | struct sockaddr_in6 *in6; |
518 | struct iovec iov[5]; |
519 | int iovcnt = 0; |
520 | uint8_t af; |
521 | |
522 | if (addr && dst->sa_family != addr->sa_family) |
523 | return (-1); |
524 | af = dst->sa_family; |
525 | |
526 | iov[iovcnt].iov_base = &rdomain; |
527 | iov[iovcnt].iov_len = sizeof(rdomain); |
528 | iovcnt++; |
529 | |
530 | iov[iovcnt].iov_base = dst; |
531 | iov[iovcnt].iov_len = dst->sa_len; |
532 | iovcnt++; |
533 | |
534 | if (type != IMSG_VROUTE_CLONE && addr) { |
535 | bzero(&sa, sizeof(sa)); |
536 | switch(af) { |
537 | case AF_INET2: |
538 | in = (struct sockaddr_in *)&sa; |
539 | in->sin_addr.s_addr = prefixlen2mask(mask); |
540 | in->sin_family = af; |
541 | in->sin_len = sizeof(*in); |
542 | iov[iovcnt].iov_base = in; |
543 | iov[iovcnt].iov_len = sizeof(*in); |
544 | iovcnt++; |
545 | break; |
546 | case AF_INET624: |
547 | in6 = (struct sockaddr_in6 *)&sa; |
548 | prefixlen2mask6(mask, |
549 | (uint32_t *)in6->sin6_addr.s6_addr__u6_addr.__u6_addr8); |
550 | in6->sin6_family = af; |
551 | in6->sin6_len = sizeof(*in6); |
552 | iov[iovcnt].iov_base = in6; |
553 | iov[iovcnt].iov_len = sizeof(*in6); |
554 | iovcnt++; |
555 | break; |
556 | } |
557 | |
558 | iov[iovcnt].iov_base = addr; |
559 | iov[iovcnt].iov_len = addr->sa_len; |
560 | iovcnt++; |
561 | } |
562 | |
563 | return (proc_composev(&env->sc_ps, PROC_PARENT, type, iov, iovcnt)); |
564 | } |
565 | |
566 | int |
567 | vroute_getroute(struct iked *env, struct imsg *imsg) |
568 | { |
569 | struct sockaddr *dest, *mask = NULL((void *)0), *gateway = NULL((void *)0); |
570 | uint8_t *ptr; |
571 | size_t left; |
572 | int addrs = 0; |
573 | int type, flags; |
574 | uint8_t rdomain; |
575 | |
576 | ptr = (uint8_t *)imsg->data; |
577 | left = IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)); |
578 | |
579 | if (left < sizeof(rdomain)) |
580 | return (-1); |
581 | rdomain = *ptr; |
582 | ptr += sizeof(rdomain); |
583 | left -= sizeof(rdomain); |
584 | |
585 | if (left < sizeof(struct sockaddr)) |
586 | return (-1); |
587 | dest = (struct sockaddr *)ptr; |
588 | if (left < dest->sa_len) |
589 | return (-1); |
590 | socket_setport(dest, 0); |
591 | ptr += dest->sa_len; |
592 | left -= dest->sa_len; |
593 | addrs |= RTA_DST0x1; |
594 | |
595 | flags = RTF_UP0x1 | RTF_GATEWAY0x2 | RTF_STATIC0x800; |
596 | if (left != 0) { |
597 | if (left < sizeof(struct sockaddr)) |
598 | return (-1); |
599 | mask = (struct sockaddr *)ptr; |
600 | if (left < mask->sa_len) |
601 | return (-1); |
602 | socket_setport(mask, 0); |
603 | ptr += mask->sa_len; |
604 | left -= mask->sa_len; |
605 | addrs |= RTA_NETMASK0x4; |
606 | |
607 | if (left < sizeof(struct sockaddr)) |
608 | return (-1); |
609 | gateway = (struct sockaddr *)ptr; |
610 | if (left < gateway->sa_len) |
611 | return (-1); |
612 | socket_setport(gateway, 0); |
613 | ptr += gateway->sa_len; |
614 | left -= gateway->sa_len; |
615 | addrs |= RTA_GATEWAY0x2; |
616 | } else { |
617 | flags |= RTF_HOST0x4; |
618 | } |
619 | |
620 | switch(imsg->hdr.type) { |
621 | case IMSG_VROUTE_ADD: |
622 | type = RTM_ADD0x1; |
623 | break; |
624 | case IMSG_VROUTE_DEL: |
625 | type = RTM_DELETE0x2; |
626 | break; |
627 | } |
628 | |
629 | if (type == RTM_ADD0x1) |
630 | vroute_insertroute(env, rdomain, dest, mask); |
631 | else |
632 | vroute_removeroute(env, rdomain, dest, mask); |
633 | return (vroute_doroute(env, flags, addrs, rdomain, type, |
634 | dest, mask, gateway, NULL((void *)0))); |
635 | } |
636 | |
637 | int |
638 | vroute_getcloneroute(struct iked *env, struct imsg *imsg) |
639 | { |
640 | struct sockaddr *dst; |
641 | struct sockaddr_storage dest; |
642 | struct sockaddr_storage mask; |
643 | struct sockaddr_storage addr; |
644 | uint8_t *ptr; |
645 | size_t left; |
646 | uint8_t rdomain; |
647 | int flags; |
648 | int addrs; |
649 | int need_gw; |
650 | |
651 | ptr = (uint8_t *)imsg->data; |
652 | left = IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)); |
653 | |
654 | if (left < sizeof(rdomain)) |
655 | return (-1); |
656 | rdomain = *ptr; |
657 | ptr += sizeof(rdomain); |
658 | left -= sizeof(rdomain); |
659 | |
660 | bzero(&dest, sizeof(dest)); |
661 | bzero(&mask, sizeof(mask)); |
662 | bzero(&addr, sizeof(addr)); |
663 | |
664 | if (left < sizeof(struct sockaddr)) |
665 | return (-1); |
666 | dst = (struct sockaddr *)ptr; |
667 | if (left < dst->sa_len) |
668 | return (-1); |
669 | memcpy(&dest, dst, dst->sa_len); |
670 | ptr += dst->sa_len; |
671 | left -= dst->sa_len; |
672 | |
673 | /* Get route to peer */ |
674 | flags = RTF_UP0x1 | RTF_HOST0x4 | RTF_STATIC0x800; |
675 | if (vroute_doroute(env, flags, RTA_DST0x1, rdomain, RTM_GET0x4, |
676 | (struct sockaddr *)&dest, (struct sockaddr *)&mask, |
677 | (struct sockaddr *)&addr, &need_gw)) |
678 | return (-1); |
679 | |
680 | if (need_gw) |
681 | flags |= RTF_GATEWAY0x2; |
682 | |
683 | memcpy(&dest, dst, dst->sa_len); |
684 | socket_setport((struct sockaddr *)&dest, 0); |
685 | vroute_insertroute(env, rdomain, (struct sockaddr *)&dest, NULL((void *)0)); |
686 | |
687 | /* Set explicit route to peer with gateway addr*/ |
688 | addrs = RTA_DST0x1 | RTA_GATEWAY0x2 | RTA_NETMASK0x4; |
689 | return (vroute_doroute(env, flags, addrs, rdomain, RTM_ADD0x1, |
690 | (struct sockaddr *)&dest, (struct sockaddr *)&mask, |
691 | (struct sockaddr *)&addr, NULL((void *)0))); |
692 | } |
693 | |
694 | int |
695 | vroute_dodns(struct iked *env, struct sockaddr *dns, int add, |
696 | unsigned int ifidx) |
697 | { |
698 | struct vroute_msg m_rtmsg; |
699 | struct sockaddr_in *in; |
700 | struct sockaddr_in6 *in6; |
701 | struct sockaddr_rtdns rtdns; |
702 | struct iked_vroute_sc *ivr = env->sc_vroute; |
703 | struct iovec iov[3]; |
704 | int i; |
705 | long pad = 0; |
706 | int iovcnt = 0, padlen; |
707 | |
708 | bzero(&m_rtmsg, sizeof(m_rtmsg)); |
709 | #define rtm m_rtmsg.vm_rtm |
710 | rtm.rtm_version = RTM_VERSION5; |
711 | rtm.rtm_type = RTM_PROPOSAL0x13; |
712 | rtm.rtm_seq = ++ivr->ivr_rtseq; |
713 | rtm.rtm_priority = RTP_PROPOSAL_STATIC57; |
714 | rtm.rtm_flags = RTF_UP0x1; |
715 | rtm.rtm_addrs = RTA_DNS0x1000; |
716 | rtm.rtm_index = ifidx; |
717 | |
718 | iov[iovcnt].iov_base = &rtm; |
719 | iov[iovcnt].iov_len = sizeof(rtm); |
720 | iovcnt++; |
721 | |
722 | bzero(&rtdns, sizeof(rtdns)); |
723 | rtdns.sr_family = dns->sa_family; |
724 | rtdns.sr_len = 2; |
725 | if (add) { |
726 | switch(dns->sa_family) { |
727 | case AF_INET2: |
728 | rtdns.sr_family = AF_INET2; |
729 | rtdns.sr_len += sizeof(struct in_addr); |
730 | in = (struct sockaddr_in *)dns; |
731 | memcpy(rtdns.sr_dns, &in->sin_addr, sizeof(struct in_addr)); |
732 | break; |
733 | case AF_INET624: |
734 | rtdns.sr_family = AF_INET624; |
735 | rtdns.sr_len += sizeof(struct in6_addr); |
736 | in6 = (struct sockaddr_in6 *)dns; |
737 | memcpy(rtdns.sr_dns, &in6->sin6_addr, sizeof(struct in6_addr)); |
738 | break; |
739 | default: |
740 | return (-1); |
741 | } |
742 | } |
743 | iov[iovcnt].iov_base = &rtdns; |
744 | iov[iovcnt++].iov_len = sizeof(rtdns); |
745 | padlen = ROUNDUP(sizeof(rtdns))(sizeof(rtdns)>0 ? (1 + (((sizeof(rtdns)) - 1) | (sizeof(long ) - 1))) : sizeof(long)) - sizeof(rtdns); |
746 | if (padlen > 0) { |
747 | iov[iovcnt].iov_base = &pad; |
748 | iov[iovcnt++].iov_len = padlen; |
749 | } |
750 | |
751 | for (i = 0; i < iovcnt; i++) |
752 | rtm.rtm_msglen += iov[i].iov_len; |
753 | #undef rtm |
754 | |
755 | if (writev(ivr->ivr_rtsock, iov, iovcnt) == -1) |
756 | log_warn("failed to send route message"); |
757 | |
758 | return (0); |
759 | } |
760 | |
761 | int |
762 | vroute_doroute(struct iked *env, int flags, int addrs, int rdomain, uint8_t type, |
763 | struct sockaddr *dest, struct sockaddr *mask, struct sockaddr *addr, int *need_gw) |
764 | { |
765 | struct vroute_msg m_rtmsg; |
766 | struct iovec iov[7]; |
767 | struct iked_vroute_sc *ivr = env->sc_vroute; |
768 | ssize_t len; |
769 | int iovcnt = 0; |
770 | int i; |
771 | long pad = 0; |
772 | size_t padlen; |
773 | |
774 | bzero(&m_rtmsg, sizeof(m_rtmsg)); |
775 | #define rtm m_rtmsg.vm_rtm |
776 | rtm.rtm_version = RTM_VERSION5; |
777 | rtm.rtm_tableid = rdomain; |
778 | rtm.rtm_type = type; |
779 | rtm.rtm_seq = ++ivr->ivr_rtseq; |
780 | if (type != RTM_GET0x4) |
781 | rtm.rtm_priority = IKED_VROUTE_PRIO6; |
782 | rtm.rtm_flags = flags; |
783 | rtm.rtm_addrs = addrs; |
784 | |
785 | iov[iovcnt].iov_base = &rtm; |
786 | iov[iovcnt].iov_len = sizeof(rtm); |
787 | iovcnt++; |
788 | |
789 | if (rtm.rtm_addrs & RTA_DST0x1) { |
790 | iov[iovcnt].iov_base = dest; |
791 | iov[iovcnt].iov_len = dest->sa_len; |
792 | iovcnt++; |
793 | padlen = ROUNDUP(dest->sa_len)(dest->sa_len>0 ? (1 + (((dest->sa_len) - 1) | (sizeof (long) - 1))) : sizeof(long)) - dest->sa_len; |
794 | if (padlen > 0) { |
795 | iov[iovcnt].iov_base = &pad; |
796 | iov[iovcnt].iov_len = padlen; |
797 | iovcnt++; |
798 | } |
799 | } |
800 | |
801 | if (rtm.rtm_addrs & RTA_GATEWAY0x2) { |
802 | iov[iovcnt].iov_base = addr; |
803 | iov[iovcnt].iov_len = addr->sa_len; |
804 | iovcnt++; |
805 | padlen = ROUNDUP(addr->sa_len)(addr->sa_len>0 ? (1 + (((addr->sa_len) - 1) | (sizeof (long) - 1))) : sizeof(long)) - addr->sa_len; |
806 | if (padlen > 0) { |
807 | iov[iovcnt].iov_base = &pad; |
808 | iov[iovcnt].iov_len = padlen; |
809 | iovcnt++; |
810 | } |
811 | } |
812 | |
813 | if (rtm.rtm_addrs & RTA_NETMASK0x4) { |
814 | iov[iovcnt].iov_base = mask; |
815 | iov[iovcnt].iov_len = mask->sa_len; |
816 | iovcnt++; |
817 | padlen = ROUNDUP(mask->sa_len)(mask->sa_len>0 ? (1 + (((mask->sa_len) - 1) | (sizeof (long) - 1))) : sizeof(long)) - mask->sa_len; |
818 | if (padlen > 0) { |
819 | iov[iovcnt].iov_base = &pad; |
820 | iov[iovcnt].iov_len = padlen; |
821 | iovcnt++; |
822 | } |
823 | } |
824 | |
825 | for (i = 0; i < iovcnt; i++) |
826 | rtm.rtm_msglen += iov[i].iov_len; |
827 | |
828 | log_debug("%s: len: %u type: %s rdomain: %d flags %x (%s%s)" |
829 | " addrs %x (dst %s mask %s gw %s)", __func__, rtm.rtm_msglen, |
830 | type == RTM_ADD0x1 ? "RTM_ADD" : type == RTM_DELETE0x2 ? "RTM_DELETE" : |
831 | type == RTM_GET0x4 ? "RTM_GET" : "unknown", rdomain, |
832 | flags, |
833 | flags & RTF_HOST0x4 ? "H" : "", |
834 | flags & RTF_GATEWAY0x2 ? "G" : "", |
835 | addrs, |
836 | addrs & RTA_DST0x1 ? print_host(dest, NULL((void *)0), 0) : "<>", |
837 | addrs & RTA_NETMASK0x4 ? print_host(mask, NULL((void *)0), 0) : "<>", |
838 | addrs & RTA_GATEWAY0x2 ? print_host(addr, NULL((void *)0), 0) : "<>"); |
839 | |
840 | if (writev(ivr->ivr_rtsock, iov, iovcnt) == -1) { |
841 | if ((type == RTM_ADD0x1 && errno(*__errno()) != EEXIST17) || |
842 | (type == RTM_DELETE0x2 && errno(*__errno()) != ESRCH3)) { |
843 | log_warn("%s: write %d", __func__, rtm.rtm_errno); |
844 | return (0); |
845 | } |
846 | } |
847 | |
848 | if (type == RTM_GET0x4) { |
849 | do { |
850 | len = read(ivr->ivr_rtsock, &m_rtmsg, sizeof(m_rtmsg)); |
851 | } while(len > 0 && (rtm.rtm_version != RTM_VERSION5 || |
852 | rtm.rtm_seq != ivr->ivr_rtseq || rtm.rtm_pid != ivr->ivr_pid)); |
853 | return (vroute_process(env, len, &m_rtmsg, dest, mask, addr, need_gw)); |
854 | } |
855 | #undef rtm |
856 | |
857 | return (0); |
858 | } |
859 | |
860 | int |
861 | vroute_process(struct iked *env, int msglen, struct vroute_msg *m_rtmsg, |
862 | struct sockaddr *dest, struct sockaddr *mask, struct sockaddr *addr, int *need_gw) |
863 | { |
864 | struct sockaddr *sa; |
865 | char *cp; |
866 | int i; |
867 | |
868 | #define rtm m_rtmsg->vm_rtm |
869 | if (rtm.rtm_version != RTM_VERSION5) { |
870 | warnx("routing message version %u not understood", |
871 | rtm.rtm_version); |
872 | return (-1); |
873 | } |
874 | if (rtm.rtm_msglen > msglen) { |
875 | warnx("message length mismatch, in packet %u, returned %d", |
876 | rtm.rtm_msglen, msglen); |
877 | return (-1); |
878 | } |
879 | if (rtm.rtm_errno) { |
880 | warnx("RTM_GET: %s (errno %d)", |
881 | strerror(rtm.rtm_errno), rtm.rtm_errno); |
882 | return (-1); |
883 | } |
884 | cp = m_rtmsg->vm_space; |
885 | *need_gw = rtm.rtm_flags & RTF_GATEWAY0x2; |
886 | if(rtm.rtm_addrs) { |
887 | for (i = 1; i; i <<= 1) { |
888 | if (i & rtm.rtm_addrs) { |
889 | sa = (struct sockaddr *)cp; |
890 | switch(i) { |
891 | case RTA_DST0x1: |
892 | memcpy(dest, cp, sa->sa_len); |
893 | break; |
894 | case RTA_NETMASK0x4: |
895 | memcpy(mask, cp, sa->sa_len); |
896 | break; |
897 | case RTA_GATEWAY0x2: |
898 | memcpy(addr, cp, sa->sa_len); |
899 | break; |
900 | } |
901 | cp += ROUNDUP(sa->sa_len)(sa->sa_len>0 ? (1 + (((sa->sa_len) - 1) | (sizeof(long ) - 1))) : sizeof(long)); |
902 | } |
903 | } |
904 | } |
905 | #undef rtm |
906 | return (0); |
907 | } |
908 | |
909 | int |
910 | vroute_doaddr(struct iked *env, char *ifname, struct sockaddr *addr, |
911 | struct sockaddr *mask, int add) |
912 | { |
913 | struct iked_vroute_sc *ivr = env->sc_vroute; |
914 | struct ifaliasreq req; |
915 | struct in6_aliasreq req6; |
916 | unsigned long ioreq; |
917 | int af; |
918 | |
919 | af = addr->sa_family; |
920 | switch (af) { |
921 | case AF_INET2: |
922 | bzero(&req, sizeof(req)); |
923 | strncpy(req.ifra_name, ifname, sizeof(req.ifra_name)); |
924 | memcpy(&req.ifra_addrifra_ifrau.ifrau_addr, addr, sizeof(req.ifra_addrifra_ifrau.ifrau_addr)); |
925 | if (add) |
926 | memcpy(&req.ifra_mask, mask, sizeof(req.ifra_addrifra_ifrau.ifrau_addr)); |
927 | |
928 | log_debug("%s: %s inet %s netmask %s", __func__, |
929 | add ? "add" : "del", |
930 | print_host((struct sockaddr *)addr, NULL((void *)0), 0), |
931 | print_host((struct sockaddr *)mask, NULL((void *)0), 0)); |
932 | |
933 | ioreq = add ? SIOCAIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifaliasreq) & 0x1fff) << 16) | ((('i')) << 8) | ((26))) : SIOCDIFADDR((unsigned long)0x80000000 | ((sizeof(struct ifreq) & 0x1fff ) << 16) | ((('i')) << 8) | ((25))); |
934 | if (ioctl(ivr->ivr_iosock, ioreq, &req) == -1) { |
935 | log_warn("%s: req: %lu", __func__, ioreq); |
936 | return (-1); |
937 | } |
938 | break; |
939 | case AF_INET624: |
940 | bzero(&req6, sizeof(req6)); |
941 | strncpy(req6.ifra_name, ifname, sizeof(req6.ifra_name)); |
942 | req6.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME0xffffffff; |
943 | req6.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME0xffffffff; |
944 | |
945 | memcpy(&req6.ifra_addrifra_ifrau.ifrau_addr, addr, sizeof(req6.ifra_addrifra_ifrau.ifrau_addr)); |
946 | if (add) |
947 | memcpy(&req6.ifra_prefixmask, mask, |
948 | sizeof(req6.ifra_prefixmask)); |
949 | |
950 | log_debug("%s: %s inet6 %s netmask %s", __func__, |
951 | add ? "add" : "del", |
952 | print_host((struct sockaddr *)addr, NULL((void *)0), 0), |
953 | print_host((struct sockaddr *)mask, NULL((void *)0), 0)); |
954 | |
955 | ioreq = add ? SIOCAIFADDR_IN6((unsigned long)0x80000000 | ((sizeof(struct in6_aliasreq) & 0x1fff) << 16) | ((('i')) << 8) | ((26))) : SIOCDIFADDR_IN6((unsigned long)0x80000000 | ((sizeof(struct in6_ifreq) & 0x1fff) << 16) | ((('i')) << 8) | ((25))); |
956 | if (ioctl(ivr->ivr_iosock6, ioreq, &req6) == -1) { |
957 | log_warn("%s: req: %lu", __func__, ioreq); |
958 | return (-1); |
959 | } |
960 | break; |
961 | default: |
962 | return (-1); |
963 | } |
964 | |
965 | return (0); |
966 | } |