Print this page
7127 remove -Wno-missing-braces from Makefile.uts
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/main.c
+++ new/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/main.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 *
21 21 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
22 22 */
23 23
24 24 #include "defs.h"
25 25 #include "tables.h"
26 26 #include <fcntl.h>
27 27 #include <sys/un.h>
28 28
29 29 static void initlog(void);
30 30 static void run_timeouts(void);
31 31
32 32 static void advertise(struct sockaddr_in6 *sin6, struct phyint *pi,
33 33 boolean_t no_prefixes);
34 34 static void solicit(struct sockaddr_in6 *sin6, struct phyint *pi);
35 35 static void initifs(boolean_t first);
36 36 static void check_if_removed(struct phyint *pi);
37 37 static void loopback_ra_enqueue(struct phyint *pi,
38 38 struct nd_router_advert *ra, int len);
39 39 static void loopback_ra_dequeue(void);
40 40 static void check_daemonize(void);
41 41
42 42 struct in6_addr all_nodes_mcast = { { 0xff, 0x2, 0x0, 0x0,
43 43 0x0, 0x0, 0x0, 0x0,
44 44 0x0, 0x0, 0x0, 0x0,
45 45 0x0, 0x0, 0x0, 0x1 } };
46 46
47 47 struct in6_addr all_routers_mcast = { { 0xff, 0x2, 0x0, 0x0,
48 48 0x0, 0x0, 0x0, 0x0,
49 49 0x0, 0x0, 0x0, 0x0,
50 50 0x0, 0x0, 0x0, 0x2 } };
51 51
52 52 static struct sockaddr_in6 v6allnodes = { AF_INET6, 0, 0,
53 53 { 0xff, 0x2, 0x0, 0x0,
54 54 0x0, 0x0, 0x0, 0x0,
55 55 0x0, 0x0, 0x0, 0x0,
56 56 0x0, 0x0, 0x0, 0x1 } };
57 57
58 58 static struct sockaddr_in6 v6allrouters = { AF_INET6, 0, 0,
59 59 { 0xff, 0x2, 0x0, 0x0,
60 60 0x0, 0x0, 0x0, 0x0,
61 61 0x0, 0x0, 0x0, 0x0,
62 62 0x0, 0x0, 0x0, 0x2 } };
63 63
64 64 static char **argv0; /* Saved for re-exec on SIGHUP */
65 65
66 66 static uint64_t packet[(IP_MAXPACKET + 1)/8];
67 67
68 68 static int show_ifs = 0;
69 69 static boolean_t already_daemonized = _B_FALSE;
70 70 int debug = 0;
71 71 int no_loopback = 0; /* Do not send RA packets to ourselves */
72 72
73 73 /*
74 74 * Size of routing socket message used by in.ndpd which includes the header,
75 75 * space for the RTA_DST, RTA_GATEWAY and RTA_NETMASK (each a sockaddr_in6)
76 76 * plus space for the RTA_IFP (a sockaddr_dl).
77 77 */
78 78 #define NDP_RTM_MSGLEN sizeof (struct rt_msghdr) + \
79 79 sizeof (struct sockaddr_in6) + \
80 80 sizeof (struct sockaddr_in6) + \
81 81 sizeof (struct sockaddr_in6) + \
82 82 sizeof (struct sockaddr_dl)
83 83
84 84 /*
85 85 * These are referenced externally in tables.c in order to fill in the
86 86 * dynamic portions of the routing socket message and then to send the message
87 87 * itself.
88 88 */
89 89 int rtsock = -1; /* Routing socket */
90 90 struct rt_msghdr *rt_msg; /* Routing socket message */
91 91 struct sockaddr_in6 *rta_gateway; /* RTA_GATEWAY sockaddr */
92 92 struct sockaddr_dl *rta_ifp; /* RTA_IFP sockaddr */
93 93
94 94 /*
95 95 * These sockets are used internally in this file.
96 96 */
97 97 static int mibsock = -1; /* mib request socket */
98 98 static int cmdsock = -1; /* command socket */
99 99
100 100 static int ndpd_setup_cmd_listener(void);
101 101 static void ndpd_cmd_handler(int);
102 102 static int ndpd_process_cmd(int, ipadm_ndpd_msg_t *);
103 103 static int ndpd_send_error(int, int);
104 104 static int ndpd_set_autoconf(const char *, boolean_t);
105 105 static int ndpd_create_addrs(const char *, struct sockaddr_in6, int,
106 106 boolean_t, boolean_t, char *);
107 107 static int ndpd_delete_addrs(const char *);
108 108 static int phyint_check_ipadm_intfid(struct phyint *);
109 109
110 110 /*
111 111 * Return the current time in milliseconds truncated to
112 112 * fit in an integer.
113 113 */
114 114 uint_t
115 115 getcurrenttime(void)
116 116 {
117 117 struct timeval tp;
118 118
119 119 if (gettimeofday(&tp, NULL) < 0) {
120 120 logperror("getcurrenttime: gettimeofday failed");
121 121 exit(1);
122 122 }
123 123 return (tp.tv_sec * 1000 + tp.tv_usec / 1000);
124 124 }
125 125
126 126 /*
127 127 * Output a preformated packet from the packet[] buffer.
128 128 */
129 129 static void
130 130 sendpacket(struct sockaddr_in6 *sin6, int sock, int size, int flags)
131 131 {
132 132 int cc;
133 133 char abuf[INET6_ADDRSTRLEN];
134 134
135 135 cc = sendto(sock, (char *)packet, size, flags,
136 136 (struct sockaddr *)sin6, sizeof (*sin6));
137 137 if (cc < 0 || cc != size) {
138 138 if (cc < 0) {
139 139 logperror("sendpacket: sendto");
140 140 }
141 141 logmsg(LOG_ERR, "sendpacket: wrote %s %d chars, ret=%d\n",
142 142 inet_ntop(sin6->sin6_family,
143 143 (void *)&sin6->sin6_addr,
144 144 abuf, sizeof (abuf)),
145 145 size, cc);
146 146 }
147 147 }
148 148
149 149 /*
150 150 * If possible, place an ND_OPT_SOURCE_LINKADDR option at `optp'.
151 151 * Return the number of bytes placed in the option.
152 152 */
153 153 static uint_t
154 154 add_opt_lla(struct phyint *pi, struct nd_opt_lla *optp)
155 155 {
156 156 uint_t optlen;
157 157 uint_t hwaddrlen;
158 158 struct lifreq lifr;
159 159
160 160 /* If this phyint doesn't have a link-layer address, bail */
161 161 if (phyint_get_lla(pi, &lifr) == -1)
162 162 return (0);
163 163
164 164 hwaddrlen = lifr.lifr_nd.lnr_hdw_len;
165 165 /* roundup to multiple of 8 and make padding zero */
166 166 optlen = ((sizeof (struct nd_opt_hdr) + hwaddrlen + 7) / 8) * 8;
167 167 bzero(optp, optlen);
168 168 optp->nd_opt_lla_type = ND_OPT_SOURCE_LINKADDR;
169 169 optp->nd_opt_lla_len = optlen / 8;
170 170 bcopy(lifr.lifr_nd.lnr_hdw_addr, optp->nd_opt_lla_hdw_addr, hwaddrlen);
171 171
172 172 return (optlen);
173 173 }
174 174
175 175 /* Send a Router Solicitation */
176 176 static void
177 177 solicit(struct sockaddr_in6 *sin6, struct phyint *pi)
178 178 {
179 179 int packetlen = 0;
180 180 struct nd_router_solicit *rs = (struct nd_router_solicit *)packet;
181 181 char *pptr = (char *)packet;
182 182
183 183 rs->nd_rs_type = ND_ROUTER_SOLICIT;
184 184 rs->nd_rs_code = 0;
185 185 rs->nd_rs_cksum = htons(0);
186 186 rs->nd_rs_reserved = htonl(0);
187 187
188 188 packetlen += sizeof (*rs);
189 189 pptr += sizeof (*rs);
190 190
191 191 /* add options */
192 192 packetlen += add_opt_lla(pi, (struct nd_opt_lla *)pptr);
193 193
194 194 if (debug & D_PKTOUT) {
195 195 print_route_sol("Sending solicitation to ", pi, rs, packetlen,
196 196 sin6);
197 197 }
198 198 sendpacket(sin6, pi->pi_sock, packetlen, 0);
199 199 }
200 200
201 201 /*
202 202 * Send a (set of) Router Advertisements and feed them back to ourselves
203 203 * for processing. Unless no_prefixes is set all prefixes are included.
204 204 * If there are too many prefix options to fit in one packet multiple
205 205 * packets will be sent - each containing a subset of the prefix options.
206 206 */
207 207 static void
208 208 advertise(struct sockaddr_in6 *sin6, struct phyint *pi, boolean_t no_prefixes)
209 209 {
210 210 struct nd_opt_prefix_info *po;
211 211 char *pptr = (char *)packet;
212 212 struct nd_router_advert *ra;
213 213 struct adv_prefix *adv_pr;
214 214 int packetlen = 0;
215 215
216 216 ra = (struct nd_router_advert *)pptr;
217 217 ra->nd_ra_type = ND_ROUTER_ADVERT;
218 218 ra->nd_ra_code = 0;
219 219 ra->nd_ra_cksum = htons(0);
220 220 ra->nd_ra_curhoplimit = pi->pi_AdvCurHopLimit;
221 221 ra->nd_ra_flags_reserved = 0;
222 222 if (pi->pi_AdvManagedFlag)
223 223 ra->nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;
224 224 if (pi->pi_AdvOtherConfigFlag)
225 225 ra->nd_ra_flags_reserved |= ND_RA_FLAG_OTHER;
226 226
227 227 if (pi->pi_adv_state == FINAL_ADV)
228 228 ra->nd_ra_router_lifetime = htons(0);
229 229 else
230 230 ra->nd_ra_router_lifetime = htons(pi->pi_AdvDefaultLifetime);
231 231 ra->nd_ra_reachable = htonl(pi->pi_AdvReachableTime);
232 232 ra->nd_ra_retransmit = htonl(pi->pi_AdvRetransTimer);
233 233
234 234 packetlen = sizeof (*ra);
235 235 pptr += sizeof (*ra);
236 236
237 237 if (pi->pi_adv_state == FINAL_ADV) {
238 238 if (debug & D_PKTOUT) {
239 239 print_route_adv("Sending advert (FINAL) to ", pi,
240 240 ra, packetlen, sin6);
241 241 }
242 242 sendpacket(sin6, pi->pi_sock, packetlen, 0);
243 243 /* Feed packet back in for router operation */
244 244 loopback_ra_enqueue(pi, ra, packetlen);
245 245 return;
246 246 }
247 247
248 248 /* add options */
249 249 packetlen += add_opt_lla(pi, (struct nd_opt_lla *)pptr);
250 250 pptr = (char *)packet + packetlen;
251 251
252 252 if (pi->pi_AdvLinkMTU != 0) {
253 253 struct nd_opt_mtu *mo = (struct nd_opt_mtu *)pptr;
254 254
255 255 mo->nd_opt_mtu_type = ND_OPT_MTU;
256 256 mo->nd_opt_mtu_len = sizeof (struct nd_opt_mtu) / 8;
257 257 mo->nd_opt_mtu_reserved = 0;
258 258 mo->nd_opt_mtu_mtu = htonl(pi->pi_AdvLinkMTU);
259 259
260 260 packetlen += sizeof (struct nd_opt_mtu);
261 261 pptr += sizeof (struct nd_opt_mtu);
262 262 }
263 263
264 264 if (no_prefixes) {
265 265 if (debug & D_PKTOUT) {
266 266 print_route_adv("Sending advert to ", pi,
267 267 ra, packetlen, sin6);
268 268 }
269 269 sendpacket(sin6, pi->pi_sock, packetlen, 0);
270 270 /* Feed packet back in for router operation */
271 271 loopback_ra_enqueue(pi, ra, packetlen);
272 272 return;
273 273 }
274 274
275 275 po = (struct nd_opt_prefix_info *)pptr;
276 276 for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL;
277 277 adv_pr = adv_pr->adv_pr_next) {
278 278 if (!adv_pr->adv_pr_AdvOnLinkFlag &&
279 279 !adv_pr->adv_pr_AdvAutonomousFlag) {
280 280 continue;
281 281 }
282 282
283 283 /*
284 284 * If the prefix doesn't fit in packet send
285 285 * what we have so far and start with new packet.
286 286 */
287 287 if (packetlen + sizeof (*po) >
288 288 pi->pi_LinkMTU - sizeof (struct ip6_hdr)) {
289 289 if (debug & D_PKTOUT) {
290 290 print_route_adv("Sending advert "
291 291 "(FRAG) to ",
292 292 pi, ra, packetlen, sin6);
293 293 }
294 294 sendpacket(sin6, pi->pi_sock, packetlen, 0);
295 295 /* Feed packet back in for router operation */
296 296 loopback_ra_enqueue(pi, ra, packetlen);
297 297 packetlen = sizeof (*ra);
298 298 pptr = (char *)packet + sizeof (*ra);
299 299 po = (struct nd_opt_prefix_info *)pptr;
300 300 }
301 301 po->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
302 302 po->nd_opt_pi_len = sizeof (*po)/8;
303 303 po->nd_opt_pi_flags_reserved = 0;
304 304 if (adv_pr->adv_pr_AdvOnLinkFlag) {
305 305 po->nd_opt_pi_flags_reserved |=
306 306 ND_OPT_PI_FLAG_ONLINK;
307 307 }
308 308 if (adv_pr->adv_pr_AdvAutonomousFlag) {
309 309 po->nd_opt_pi_flags_reserved |=
310 310 ND_OPT_PI_FLAG_AUTO;
311 311 }
312 312 po->nd_opt_pi_prefix_len = adv_pr->adv_pr_prefix_len;
313 313 /*
314 314 * If both Adv*Expiration and Adv*Lifetime are
315 315 * set we prefer the former and make the lifetime
316 316 * decrement in real time.
317 317 */
318 318 if (adv_pr->adv_pr_AdvValidRealTime) {
319 319 po->nd_opt_pi_valid_time =
320 320 htonl(adv_pr->adv_pr_AdvValidExpiration);
321 321 } else {
322 322 po->nd_opt_pi_valid_time =
323 323 htonl(adv_pr->adv_pr_AdvValidLifetime);
324 324 }
325 325 if (adv_pr->adv_pr_AdvPreferredRealTime) {
326 326 po->nd_opt_pi_preferred_time =
327 327 htonl(adv_pr->adv_pr_AdvPreferredExpiration);
328 328 } else {
329 329 po->nd_opt_pi_preferred_time =
330 330 htonl(adv_pr->adv_pr_AdvPreferredLifetime);
331 331 }
332 332 po->nd_opt_pi_reserved2 = htonl(0);
333 333 po->nd_opt_pi_prefix = adv_pr->adv_pr_prefix;
334 334
335 335 po++;
336 336 packetlen += sizeof (*po);
337 337 }
338 338 if (debug & D_PKTOUT) {
339 339 print_route_adv("Sending advert to ", pi,
340 340 ra, packetlen, sin6);
341 341 }
342 342 sendpacket(sin6, pi->pi_sock, packetlen, 0);
343 343 /* Feed packet back in for router operation */
344 344 loopback_ra_enqueue(pi, ra, packetlen);
345 345 }
346 346
347 347 /* Poll support */
348 348 static int pollfd_num = 0; /* Allocated and initialized */
349 349 static struct pollfd *pollfds = NULL;
350 350
351 351 /*
352 352 * Add fd to the set being polled. Returns 0 if ok; -1 if failed.
353 353 */
354 354 int
355 355 poll_add(int fd)
356 356 {
357 357 int i;
358 358 int new_num;
359 359 struct pollfd *newfds;
360 360
361 361 /* Check if already present */
362 362 for (i = 0; i < pollfd_num; i++) {
363 363 if (pollfds[i].fd == fd)
364 364 return (0);
365 365 }
366 366 /* Check for empty spot already present */
367 367 for (i = 0; i < pollfd_num; i++) {
368 368 if (pollfds[i].fd == -1) {
369 369 pollfds[i].fd = fd;
370 370 return (0);
371 371 }
372 372 }
373 373
374 374 /* Allocate space for 32 more fds and initialize to -1 */
375 375 new_num = pollfd_num + 32;
376 376 newfds = realloc(pollfds, new_num * sizeof (struct pollfd));
377 377 if (newfds == NULL) {
378 378 logperror("realloc");
379 379 return (-1);
380 380 }
381 381
382 382 newfds[pollfd_num].fd = fd;
383 383 newfds[pollfd_num++].events = POLLIN;
384 384
385 385 for (i = pollfd_num; i < new_num; i++) {
386 386 newfds[i].fd = -1;
387 387 newfds[i].events = POLLIN;
388 388 }
389 389 pollfd_num = new_num;
390 390 pollfds = newfds;
391 391 return (0);
392 392 }
393 393
394 394 /*
395 395 * Remove fd from the set being polled. Returns 0 if ok; -1 if failed.
396 396 */
397 397 int
398 398 poll_remove(int fd)
399 399 {
400 400 int i;
401 401
402 402 /* Check if already present */
403 403 for (i = 0; i < pollfd_num; i++) {
404 404 if (pollfds[i].fd == fd) {
405 405 pollfds[i].fd = -1;
406 406 return (0);
407 407 }
408 408 }
409 409 return (-1);
410 410 }
411 411
412 412 /*
413 413 * Extract information about the ifname (either a physical interface and
414 414 * the ":0" logical interface or just a logical interface).
415 415 * If the interface (still) exists in kernel set pr_in_use
416 416 * for caller to be able to detect interfaces that are removed.
417 417 * Starts sending advertisements/solicitations when new physical interfaces
418 418 * are detected.
419 419 */
420 420 static void
421 421 if_process(int s, char *ifname, boolean_t first)
422 422 {
423 423 struct lifreq lifr;
424 424 struct phyint *pi;
425 425 struct prefix *pr;
426 426 char *cp;
427 427 char phyintname[LIFNAMSIZ + 1];
428 428
429 429 if (debug & D_IFSCAN)
430 430 logmsg(LOG_DEBUG, "if_process(%s)\n", ifname);
431 431
432 432 (void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
433 433 lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0';
434 434 if (ioctl(s, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
435 435 if (errno == ENXIO) {
436 436 /*
437 437 * Interface has disappeared
438 438 */
439 439 return;
440 440 }
441 441 logperror("if_process: ioctl (get interface flags)");
442 442 return;
443 443 }
444 444
445 445 /*
446 446 * Ignore loopback, point-to-multipoint and VRRP interfaces.
447 447 * The IP addresses over VRRP interfaces cannot be auto-configured.
448 448 * Point-to-point interfaces always have IFF_MULTICAST set.
449 449 */
450 450 if (!(lifr.lifr_flags & IFF_MULTICAST) ||
451 451 (lifr.lifr_flags & (IFF_LOOPBACK|IFF_VRRP))) {
452 452 return;
453 453 }
454 454
455 455 if (!(lifr.lifr_flags & IFF_IPV6))
456 456 return;
457 457
458 458 (void) strncpy(phyintname, ifname, sizeof (phyintname));
459 459 phyintname[sizeof (phyintname) - 1] = '\0';
460 460 if ((cp = strchr(phyintname, IF_SEPARATOR)) != NULL) {
461 461 *cp = '\0';
462 462 }
463 463
464 464 pi = phyint_lookup(phyintname);
465 465 if (pi == NULL) {
466 466 pi = phyint_create(phyintname);
467 467 if (pi == NULL) {
468 468 logmsg(LOG_ERR, "if_process: out of memory\n");
469 469 return;
470 470 }
471 471 /*
472 472 * if in.ndpd is restarted, check with ipmgmtd if there is any
473 473 * interface id to be configured for this interface.
474 474 */
475 475 if (first) {
476 476 if (phyint_check_ipadm_intfid(pi) == -1)
477 477 logmsg(LOG_ERR, "Could not get ipadm info\n");
478 478 }
479 479 } else {
480 480 /*
481 481 * if the phyint already exists, synchronize it with
482 482 * the kernel state. For a newly created phyint, phyint_create
483 483 * calls phyint_init_from_k().
484 484 */
485 485 (void) phyint_init_from_k(pi);
486 486 }
487 487 if (pi->pi_sock == -1 && !(pi->pi_kernel_state & PI_PRESENT)) {
488 488 /* Interface is not yet present */
489 489 if (debug & D_PHYINT) {
490 490 logmsg(LOG_DEBUG, "if_process: interface not yet "
491 491 "present %s\n", pi->pi_name);
492 492 }
493 493 return;
494 494 }
495 495
496 496 if (pi->pi_sock != -1) {
497 497 if (poll_add(pi->pi_sock) == -1) {
498 498 /*
499 499 * reset state.
500 500 */
501 501 phyint_cleanup(pi);
502 502 }
503 503 }
504 504
505 505 /*
506 506 * Check if IFF_ROUTER has been turned off in kernel in which
507 507 * case we have to turn off AdvSendAdvertisements.
508 508 * The kernel will automatically turn off IFF_ROUTER if
509 509 * ip6_forwarding is turned off.
510 510 * Note that we do not switch back should IFF_ROUTER be turned on.
511 511 */
512 512 if (!first &&
513 513 pi->pi_AdvSendAdvertisements && !(pi->pi_flags & IFF_ROUTER)) {
514 514 logmsg(LOG_INFO, "No longer a router on %s\n", pi->pi_name);
515 515 check_to_advertise(pi, START_FINAL_ADV);
516 516
517 517 pi->pi_AdvSendAdvertisements = 0;
518 518 pi->pi_sol_state = NO_SOLICIT;
519 519 }
520 520
521 521 /*
522 522 * Send advertisments and solicitation only if the interface is
523 523 * present in the kernel.
524 524 */
525 525 if (pi->pi_kernel_state & PI_PRESENT) {
526 526
527 527 if (pi->pi_AdvSendAdvertisements) {
528 528 if (pi->pi_adv_state == NO_ADV)
529 529 check_to_advertise(pi, START_INIT_ADV);
530 530 } else {
531 531 if (pi->pi_sol_state == NO_SOLICIT)
532 532 check_to_solicit(pi, START_INIT_SOLICIT);
533 533 }
534 534 }
535 535
536 536 /*
537 537 * Track static kernel prefixes to prevent in.ndpd from clobbering
538 538 * them by creating a struct prefix for each prefix detected in the
539 539 * kernel.
540 540 */
541 541 pr = prefix_lookup_name(pi, ifname);
542 542 if (pr == NULL) {
543 543 pr = prefix_create_name(pi, ifname);
544 544 if (pr == NULL) {
545 545 logmsg(LOG_ERR, "if_process: out of memory\n");
546 546 return;
547 547 }
548 548 if (prefix_init_from_k(pr) == -1) {
549 549 prefix_delete(pr);
550 550 return;
551 551 }
552 552 }
553 553 /* Detect prefixes which are removed */
554 554 if (pr->pr_kernel_state != 0)
555 555 pr->pr_in_use = _B_TRUE;
556 556
557 557 if ((lifr.lifr_flags & IFF_DUPLICATE) &&
558 558 !(lifr.lifr_flags & IFF_DHCPRUNNING) &&
559 559 (pr->pr_flags & IFF_TEMPORARY)) {
560 560 in6_addr_t *token;
561 561 int i;
562 562 char abuf[INET6_ADDRSTRLEN];
563 563
564 564 if (++pr->pr_attempts >= MAX_DAD_FAILURES) {
565 565 logmsg(LOG_ERR, "%s: token %s is duplicate after %d "
566 566 "attempts; disabling temporary addresses on %s",
567 567 pr->pr_name, inet_ntop(AF_INET6,
568 568 (void *)&pi->pi_tmp_token, abuf, sizeof (abuf)),
569 569 pr->pr_attempts, pi->pi_name);
570 570 pi->pi_TmpAddrsEnabled = 0;
571 571 tmptoken_delete(pi);
572 572 prefix_delete(pr);
573 573 return;
574 574 }
575 575 logmsg(LOG_WARNING, "%s: token %s is duplicate; trying again",
576 576 pr->pr_name, inet_ntop(AF_INET6, (void *)&pi->pi_tmp_token,
577 577 abuf, sizeof (abuf)));
578 578 if (!tmptoken_create(pi)) {
579 579 prefix_delete(pr);
580 580 return;
581 581 }
582 582 token = &pi->pi_tmp_token;
583 583 for (i = 0; i < 16; i++) {
584 584 /*
585 585 * prefix_create ensures that pr_prefix has all-zero
586 586 * bits after prefixlen.
587 587 */
588 588 pr->pr_address.s6_addr[i] = pr->pr_prefix.s6_addr[i] |
589 589 token->s6_addr[i];
590 590 }
591 591 if (prefix_lookup_addr_match(pr) != NULL) {
592 592 prefix_delete(pr);
593 593 return;
594 594 }
595 595 pr->pr_CreateTime = getcurrenttime() / MILLISEC;
596 596 /*
597 597 * We've got a new token. Clearing PR_AUTO causes
598 598 * prefix_update_k to bring the interface up and set the
599 599 * address.
600 600 */
601 601 pr->pr_kernel_state &= ~PR_AUTO;
602 602 prefix_update_k(pr);
603 603 }
604 604 }
605 605
606 606 static int ifsock = -1;
607 607
608 608 /*
609 609 * Scan all interfaces to detect changes as well as new and deleted intefaces
610 610 * 'first' is set for the initial call only. Do not effect anything.
611 611 */
612 612 static void
613 613 initifs(boolean_t first)
614 614 {
615 615 char *buf;
616 616 int bufsize;
617 617 int numifs;
618 618 int n;
619 619 struct lifnum lifn;
620 620 struct lifconf lifc;
621 621 struct lifreq *lifr;
622 622 struct phyint *pi;
623 623 struct phyint *next_pi;
624 624 struct prefix *pr;
625 625
626 626 if (debug & D_IFSCAN)
627 627 logmsg(LOG_DEBUG, "Reading interface configuration\n");
628 628 if (ifsock < 0) {
629 629 ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
630 630 if (ifsock < 0) {
631 631 logperror("initifs: socket");
632 632 return;
633 633 }
634 634 }
635 635 lifn.lifn_family = AF_INET6;
636 636 lifn.lifn_flags = LIFC_NOXMIT | LIFC_TEMPORARY;
637 637 if (ioctl(ifsock, SIOCGLIFNUM, (char *)&lifn) < 0) {
638 638 logperror("initifs: ioctl (get interface numbers)");
639 639 return;
640 640 }
641 641 numifs = lifn.lifn_count;
642 642 bufsize = numifs * sizeof (struct lifreq);
643 643
644 644 buf = (char *)malloc(bufsize);
645 645 if (buf == NULL) {
646 646 logmsg(LOG_ERR, "initifs: out of memory\n");
647 647 return;
648 648 }
649 649
650 650 /*
651 651 * Mark the interfaces so that we can find phyints and prefixes
652 652 * which have disappeared from the kernel.
653 653 * if_process will set pr_in_use when it finds the interface
654 654 * in the kernel.
655 655 */
656 656 for (pi = phyints; pi != NULL; pi = pi->pi_next) {
657 657 /*
658 658 * Before re-examining the state of the interfaces,
659 659 * PI_PRESENT should be cleared from pi_kernel_state.
660 660 */
661 661 pi->pi_kernel_state &= ~PI_PRESENT;
662 662 for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) {
663 663 pr->pr_in_use = _B_FALSE;
664 664 }
665 665 }
666 666
667 667 lifc.lifc_family = AF_INET6;
668 668 lifc.lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY;
669 669 lifc.lifc_len = bufsize;
670 670 lifc.lifc_buf = buf;
671 671
672 672 if (ioctl(ifsock, SIOCGLIFCONF, (char *)&lifc) < 0) {
673 673 logperror("initifs: ioctl (get interface configuration)");
674 674 free(buf);
675 675 return;
676 676 }
677 677
678 678 lifr = (struct lifreq *)lifc.lifc_req;
679 679 for (n = lifc.lifc_len / sizeof (struct lifreq); n > 0; n--, lifr++)
680 680 if_process(ifsock, lifr->lifr_name, first);
681 681 free(buf);
682 682
683 683 /*
684 684 * Detect phyints that have been removed from the kernel.
685 685 * Since we can't recreate it here (would require ifconfig plumb
686 686 * logic) we just terminate use of that phyint.
687 687 */
688 688 for (pi = phyints; pi != NULL; pi = next_pi) {
689 689 next_pi = pi->pi_next;
690 690 /*
691 691 * If interface (still) exists in kernel, set
692 692 * pi_state to indicate that.
693 693 */
694 694 if (pi->pi_kernel_state & PI_PRESENT) {
695 695 pi->pi_state |= PI_PRESENT;
696 696 }
697 697
698 698 check_if_removed(pi);
699 699 }
700 700 if (show_ifs)
701 701 phyint_print_all();
702 702 }
703 703
704 704
705 705 /*
706 706 * Router advertisement state machine. Used for everything but timer
707 707 * events which use advertise_event directly.
708 708 */
709 709 void
710 710 check_to_advertise(struct phyint *pi, enum adv_events event)
711 711 {
712 712 uint_t delay;
713 713 enum adv_states old_state = pi->pi_adv_state;
714 714
715 715 if (debug & D_STATE) {
716 716 logmsg(LOG_DEBUG, "check_to_advertise(%s, %d) state %d\n",
717 717 pi->pi_name, (int)event, (int)old_state);
718 718 }
719 719 delay = advertise_event(pi, event, 0);
720 720 if (delay != TIMER_INFINITY) {
721 721 /* Make sure the global next event is updated */
722 722 timer_schedule(delay);
723 723 }
724 724
725 725 if (debug & D_STATE) {
726 726 logmsg(LOG_DEBUG, "check_to_advertise(%s, %d) state %d -> %d\n",
727 727 pi->pi_name, (int)event, (int)old_state,
728 728 (int)pi->pi_adv_state);
729 729 }
730 730 }
731 731
732 732 /*
733 733 * Router advertisement state machine.
734 734 * Return the number of milliseconds until next timeout (TIMER_INFINITY
735 735 * if never).
736 736 * For the ADV_TIMER event the caller passes in the number of milliseconds
737 737 * since the last timer event in the 'elapsed' parameter.
738 738 */
739 739 uint_t
740 740 advertise_event(struct phyint *pi, enum adv_events event, uint_t elapsed)
741 741 {
742 742 uint_t delay;
743 743
744 744 if (debug & D_STATE) {
745 745 logmsg(LOG_DEBUG, "advertise_event(%s, %d, %d) state %d\n",
746 746 pi->pi_name, (int)event, elapsed, (int)pi->pi_adv_state);
747 747 }
748 748 check_daemonize();
749 749 if (!pi->pi_AdvSendAdvertisements)
750 750 return (TIMER_INFINITY);
751 751 if (pi->pi_flags & IFF_NORTEXCH) {
752 752 if (debug & D_PKTOUT) {
753 753 logmsg(LOG_DEBUG, "Suppress sending RA packet on %s "
754 754 "(no route exchange on interface)\n",
755 755 pi->pi_name);
756 756 }
757 757 return (TIMER_INFINITY);
758 758 }
759 759
760 760 switch (event) {
761 761 case ADV_OFF:
762 762 pi->pi_adv_state = NO_ADV;
763 763 return (TIMER_INFINITY);
764 764
765 765 case START_INIT_ADV:
766 766 if (pi->pi_adv_state == INIT_ADV)
767 767 return (pi->pi_adv_time_left);
768 768 pi->pi_adv_count = ND_MAX_INITIAL_RTR_ADVERTISEMENTS;
769 769 pi->pi_adv_time_left = 0;
770 770 pi->pi_adv_state = INIT_ADV;
771 771 break; /* send advertisement */
772 772
773 773 case START_FINAL_ADV:
774 774 if (pi->pi_adv_state == NO_ADV)
775 775 return (TIMER_INFINITY);
776 776 if (pi->pi_adv_state == FINAL_ADV)
777 777 return (pi->pi_adv_time_left);
778 778 pi->pi_adv_count = ND_MAX_FINAL_RTR_ADVERTISEMENTS;
779 779 pi->pi_adv_time_left = 0;
780 780 pi->pi_adv_state = FINAL_ADV;
781 781 break; /* send advertisement */
782 782
783 783 case RECEIVED_SOLICIT:
784 784 if (pi->pi_adv_state == NO_ADV)
785 785 return (TIMER_INFINITY);
786 786 if (pi->pi_adv_state == SOLICIT_ADV) {
787 787 if (pi->pi_adv_time_left != 0)
788 788 return (pi->pi_adv_time_left);
789 789 break;
790 790 }
791 791 delay = GET_RANDOM(0, ND_MAX_RA_DELAY_TIME);
792 792 if (delay < pi->pi_adv_time_left)
793 793 pi->pi_adv_time_left = delay;
794 794 if (pi->pi_adv_time_since_sent < ND_MIN_DELAY_BETWEEN_RAS) {
795 795 /*
796 796 * Send an advertisement (ND_MIN_DELAY_BETWEEN_RAS
797 797 * plus random delay) after the previous
798 798 * advertisement was sent.
799 799 */
800 800 pi->pi_adv_time_left = delay +
801 801 ND_MIN_DELAY_BETWEEN_RAS -
802 802 pi->pi_adv_time_since_sent;
803 803 }
804 804 pi->pi_adv_state = SOLICIT_ADV;
805 805 break;
806 806
807 807 case ADV_TIMER:
808 808 if (pi->pi_adv_state == NO_ADV)
809 809 return (TIMER_INFINITY);
810 810 /* Decrease time left */
811 811 if (pi->pi_adv_time_left >= elapsed)
812 812 pi->pi_adv_time_left -= elapsed;
813 813 else
814 814 pi->pi_adv_time_left = 0;
815 815
816 816 /* Increase time since last advertisement was sent */
817 817 pi->pi_adv_time_since_sent += elapsed;
818 818 break;
819 819 default:
820 820 logmsg(LOG_ERR, "advertise_event: Unknown event %d\n",
821 821 (int)event);
822 822 return (TIMER_INFINITY);
823 823 }
824 824
825 825 if (pi->pi_adv_time_left != 0)
826 826 return (pi->pi_adv_time_left);
827 827
828 828 /* Send advertisement and calculate next time to send */
829 829 if (pi->pi_adv_state == FINAL_ADV) {
830 830 /* Omit the prefixes */
831 831 advertise(&v6allnodes, pi, _B_TRUE);
832 832 } else {
833 833 advertise(&v6allnodes, pi, _B_FALSE);
834 834 }
835 835 pi->pi_adv_time_since_sent = 0;
836 836
837 837 switch (pi->pi_adv_state) {
838 838 case SOLICIT_ADV:
839 839 /*
840 840 * The solicited advertisement has been sent.
841 841 * Revert to periodic advertisements.
842 842 */
843 843 pi->pi_adv_state = REG_ADV;
844 844 /* FALLTHRU */
845 845 case REG_ADV:
846 846 pi->pi_adv_time_left =
847 847 GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval,
848 848 1000 * pi->pi_MaxRtrAdvInterval);
849 849 break;
850 850
851 851 case INIT_ADV:
852 852 if (--pi->pi_adv_count > 0) {
853 853 delay = GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval,
854 854 1000 * pi->pi_MaxRtrAdvInterval);
855 855 if (delay > ND_MAX_INITIAL_RTR_ADVERT_INTERVAL)
856 856 delay = ND_MAX_INITIAL_RTR_ADVERT_INTERVAL;
857 857 pi->pi_adv_time_left = delay;
858 858 } else {
859 859 pi->pi_adv_time_left =
860 860 GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval,
861 861 1000 * pi->pi_MaxRtrAdvInterval);
862 862 pi->pi_adv_state = REG_ADV;
863 863 }
864 864 break;
865 865
866 866 case FINAL_ADV:
867 867 if (--pi->pi_adv_count > 0) {
868 868 pi->pi_adv_time_left =
869 869 ND_MAX_INITIAL_RTR_ADVERT_INTERVAL;
870 870 } else {
871 871 pi->pi_adv_state = NO_ADV;
872 872 }
873 873 break;
874 874 }
875 875 if (pi->pi_adv_state != NO_ADV)
876 876 return (pi->pi_adv_time_left);
877 877 else
878 878 return (TIMER_INFINITY);
879 879 }
880 880
881 881 /*
882 882 * Router solicitation state machine. Used for everything but timer
883 883 * events which use solicit_event directly.
884 884 */
885 885 void
886 886 check_to_solicit(struct phyint *pi, enum solicit_events event)
887 887 {
888 888 uint_t delay;
889 889 enum solicit_states old_state = pi->pi_sol_state;
890 890
891 891 if (debug & D_STATE) {
892 892 logmsg(LOG_DEBUG, "check_to_solicit(%s, %d) state %d\n",
893 893 pi->pi_name, (int)event, (int)old_state);
894 894 }
895 895 delay = solicit_event(pi, event, 0);
896 896 if (delay != TIMER_INFINITY) {
897 897 /* Make sure the global next event is updated */
898 898 timer_schedule(delay);
899 899 }
900 900
901 901 if (debug & D_STATE) {
902 902 logmsg(LOG_DEBUG, "check_to_solicit(%s, %d) state %d -> %d\n",
903 903 pi->pi_name, (int)event, (int)old_state,
904 904 (int)pi->pi_sol_state);
905 905 }
906 906 }
907 907
908 908 static void
909 909 daemonize_ndpd(void)
910 910 {
911 911 struct itimerval it;
912 912 boolean_t timerval = _B_TRUE;
913 913
914 914 /*
915 915 * Need to get current timer settings so they can be restored
916 916 * after the fork(), as the it_value and it_interval values for
917 917 * the ITIMER_REAL timer are reset to 0 in the child process.
918 918 */
919 919 if (getitimer(ITIMER_REAL, &it) < 0) {
920 920 if (debug & D_TIMER)
921 921 logmsg(LOG_DEBUG,
922 922 "daemonize_ndpd: failed to get itimerval\n");
923 923 timerval = _B_FALSE;
924 924 }
925 925
926 926 /* Daemonize. */
927 927 if (daemon(0, 0) == -1) {
928 928 logperror("fork");
929 929 exit(1);
930 930 }
931 931
932 932 already_daemonized = _B_TRUE;
933 933
934 934 /*
935 935 * Restore timer values, if we were able to save them; if not,
936 936 * check and set the right value by calling run_timeouts().
937 937 */
938 938 if (timerval) {
939 939 if (setitimer(ITIMER_REAL, &it, NULL) < 0) {
940 940 logperror("daemonize_ndpd: setitimer");
941 941 exit(2);
942 942 }
943 943 } else {
944 944 run_timeouts();
945 945 }
946 946 }
947 947
948 948 /*
949 949 * Check to see if the time is right to daemonize. The right time is when:
950 950 *
951 951 * 1. We haven't already daemonized.
952 952 * 2. We are not in debug mode.
953 953 * 3. All interfaces are marked IFF_NOXMIT.
954 954 * 4. All non-router interfaces have their prefixes set up and we're
955 955 * done sending router solicitations on those interfaces without
956 956 * prefixes.
957 957 */
958 958 static void
959 959 check_daemonize(void)
960 960 {
961 961 struct phyint *pi;
962 962
963 963 if (already_daemonized || debug != 0)
964 964 return;
965 965
966 966 for (pi = phyints; pi != NULL; pi = pi->pi_next) {
967 967 if (!(pi->pi_flags & IFF_NOXMIT))
968 968 break;
969 969 }
970 970
971 971 /*
972 972 * If we can't transmit on any of the interfaces there is no reason
973 973 * to hold up progress.
974 974 */
975 975 if (pi == NULL) {
976 976 daemonize_ndpd();
977 977 return;
978 978 }
979 979
980 980 /* Check all interfaces. If any are still soliciting, just return. */
981 981 for (pi = phyints; pi != NULL; pi = pi->pi_next) {
982 982 if (pi->pi_AdvSendAdvertisements ||
983 983 !(pi->pi_kernel_state & PI_PRESENT))
984 984 continue;
985 985
986 986 if (pi->pi_sol_state == INIT_SOLICIT)
987 987 return;
988 988 }
989 989
990 990 daemonize_ndpd();
991 991 }
992 992
993 993 /*
994 994 * Router solicitation state machine.
995 995 * Return the number of milliseconds until next timeout (TIMER_INFINITY
996 996 * if never).
997 997 * For the SOL_TIMER event the caller passes in the number of milliseconds
998 998 * since the last timer event in the 'elapsed' parameter.
999 999 */
1000 1000 uint_t
1001 1001 solicit_event(struct phyint *pi, enum solicit_events event, uint_t elapsed)
1002 1002 {
1003 1003 if (debug & D_STATE) {
1004 1004 logmsg(LOG_DEBUG, "solicit_event(%s, %d, %d) state %d\n",
1005 1005 pi->pi_name, (int)event, elapsed, (int)pi->pi_sol_state);
1006 1006 }
1007 1007
1008 1008 if (pi->pi_AdvSendAdvertisements)
1009 1009 return (TIMER_INFINITY);
1010 1010 if (pi->pi_flags & IFF_NORTEXCH) {
1011 1011 if (debug & D_PKTOUT) {
1012 1012 logmsg(LOG_DEBUG, "Suppress sending RS packet on %s "
1013 1013 "(no route exchange on interface)\n",
1014 1014 pi->pi_name);
1015 1015 }
1016 1016 return (TIMER_INFINITY);
1017 1017 }
1018 1018
1019 1019 switch (event) {
1020 1020 case SOLICIT_OFF:
1021 1021 pi->pi_sol_state = NO_SOLICIT;
1022 1022 check_daemonize();
1023 1023 return (TIMER_INFINITY);
1024 1024
1025 1025 case SOLICIT_DONE:
1026 1026 pi->pi_sol_state = DONE_SOLICIT;
1027 1027 check_daemonize();
1028 1028 return (TIMER_INFINITY);
1029 1029
1030 1030 case RESTART_INIT_SOLICIT:
1031 1031 /*
1032 1032 * This event allows us to start solicitation over again
1033 1033 * without losing the RA flags. We start solicitation over
1034 1034 * when we are missing an interface prefix for a newly-
1035 1035 * encountered DHCP interface.
1036 1036 */
1037 1037 if (pi->pi_sol_state == INIT_SOLICIT)
1038 1038 return (pi->pi_sol_time_left);
1039 1039 pi->pi_sol_count = ND_MAX_RTR_SOLICITATIONS;
1040 1040 pi->pi_sol_time_left =
1041 1041 GET_RANDOM(0, ND_MAX_RTR_SOLICITATION_DELAY);
1042 1042 pi->pi_sol_state = INIT_SOLICIT;
1043 1043 break;
1044 1044
1045 1045 case START_INIT_SOLICIT:
1046 1046 if (pi->pi_sol_state == INIT_SOLICIT)
1047 1047 return (pi->pi_sol_time_left);
1048 1048 pi->pi_ra_flags = 0;
1049 1049 pi->pi_sol_count = ND_MAX_RTR_SOLICITATIONS;
1050 1050 pi->pi_sol_time_left =
1051 1051 GET_RANDOM(0, ND_MAX_RTR_SOLICITATION_DELAY);
1052 1052 pi->pi_sol_state = INIT_SOLICIT;
1053 1053 break;
1054 1054
1055 1055 case SOL_TIMER:
1056 1056 if (pi->pi_sol_state == NO_SOLICIT)
1057 1057 return (TIMER_INFINITY);
1058 1058 /* Decrease time left */
1059 1059 if (pi->pi_sol_time_left >= elapsed)
1060 1060 pi->pi_sol_time_left -= elapsed;
1061 1061 else
1062 1062 pi->pi_sol_time_left = 0;
1063 1063 break;
1064 1064 default:
1065 1065 logmsg(LOG_ERR, "solicit_event: Unknown event %d\n",
1066 1066 (int)event);
1067 1067 return (TIMER_INFINITY);
1068 1068 }
1069 1069
1070 1070 if (pi->pi_sol_time_left != 0)
1071 1071 return (pi->pi_sol_time_left);
1072 1072
1073 1073 /* Send solicitation and calculate next time */
1074 1074 switch (pi->pi_sol_state) {
1075 1075 case INIT_SOLICIT:
1076 1076 solicit(&v6allrouters, pi);
1077 1077 if (--pi->pi_sol_count == 0) {
1078 1078 if (debug & D_STATE) {
1079 1079 logmsg(LOG_DEBUG, "solicit_event: no routers "
1080 1080 "found on %s; assuming default flags\n",
1081 1081 pi->pi_name);
1082 1082 }
1083 1083 if (pi->pi_autoconf && pi->pi_StatefulAddrConf) {
1084 1084 pi->pi_ra_flags |= ND_RA_FLAG_MANAGED |
1085 1085 ND_RA_FLAG_OTHER;
1086 1086 start_dhcp(pi);
1087 1087 }
1088 1088 pi->pi_sol_state = DONE_SOLICIT;
1089 1089 check_daemonize();
1090 1090 return (TIMER_INFINITY);
1091 1091 }
1092 1092 pi->pi_sol_time_left = ND_RTR_SOLICITATION_INTERVAL;
1093 1093 return (pi->pi_sol_time_left);
1094 1094 case NO_SOLICIT:
1095 1095 case DONE_SOLICIT:
1096 1096 return (TIMER_INFINITY);
1097 1097 default:
1098 1098 return (pi->pi_sol_time_left);
1099 1099 }
1100 1100 }
1101 1101
1102 1102 /*
1103 1103 * Timer mechanism using relative time (in milliseconds) from the
1104 1104 * previous timer event. Timers exceeding TIMER_INFINITY milliseconds
1105 1105 * will fire after TIMER_INFINITY milliseconds.
1106 1106 */
1107 1107 static uint_t timer_previous; /* When last SIGALRM occurred */
1108 1108 static uint_t timer_next; /* Currently scheduled timeout */
1109 1109
1110 1110 static void
1111 1111 timer_init(void)
1112 1112 {
1113 1113 timer_previous = getcurrenttime();
1114 1114 timer_next = TIMER_INFINITY;
1115 1115 run_timeouts();
1116 1116 }
1117 1117
1118 1118 /*
1119 1119 * Make sure the next SIGALRM occurs delay milliseconds from the current
1120 1120 * time if not earlier.
1121 1121 * Handles getcurrenttime (32 bit integer holding milliseconds) wraparound
1122 1122 * by treating differences greater than 0x80000000 as negative.
1123 1123 */
1124 1124 void
1125 1125 timer_schedule(uint_t delay)
1126 1126 {
1127 1127 uint_t now;
1128 1128 struct itimerval itimerval;
1129 1129
1130 1130 now = getcurrenttime();
1131 1131 if (debug & D_TIMER) {
1132 1132 logmsg(LOG_DEBUG, "timer_schedule(%u): now %u next %u\n",
1133 1133 delay, now, timer_next);
1134 1134 }
1135 1135 /* Will this timer occur before the currently scheduled SIGALRM? */
1136 1136 if (delay >= timer_next - now) {
1137 1137 if (debug & D_TIMER) {
1138 1138 logmsg(LOG_DEBUG, "timer_schedule(%u): no action - "
1139 1139 "next in %u ms\n",
1140 1140 delay, timer_next - now);
1141 1141 }
1142 1142 return;
1143 1143 }
1144 1144 if (delay == 0) {
1145 1145 /* Minimum allowed delay */
1146 1146 delay = 1;
1147 1147 }
1148 1148 timer_next = now + delay;
1149 1149
1150 1150 itimerval.it_value.tv_sec = delay / 1000;
1151 1151 itimerval.it_value.tv_usec = (delay % 1000) * 1000;
1152 1152 itimerval.it_interval.tv_sec = 0;
1153 1153 itimerval.it_interval.tv_usec = 0;
1154 1154 if (debug & D_TIMER) {
1155 1155 logmsg(LOG_DEBUG, "timer_schedule(%u): sec %lu usec %lu\n",
1156 1156 delay,
1157 1157 itimerval.it_value.tv_sec, itimerval.it_value.tv_usec);
1158 1158 }
1159 1159 if (setitimer(ITIMER_REAL, &itimerval, NULL) < 0) {
1160 1160 logperror("timer_schedule: setitimer");
1161 1161 exit(2);
1162 1162 }
1163 1163 }
1164 1164
1165 1165 /*
1166 1166 * Conditional running of timer. If more than 'minimal_time' millseconds
1167 1167 * since the timer routines were last run we run them.
1168 1168 * Used when packets arrive.
1169 1169 */
1170 1170 static void
1171 1171 conditional_run_timeouts(uint_t minimal_time)
1172 1172 {
1173 1173 uint_t now;
1174 1174 uint_t elapsed;
1175 1175
1176 1176 now = getcurrenttime();
1177 1177 elapsed = now - timer_previous;
1178 1178 if (elapsed > minimal_time) {
1179 1179 if (debug & D_TIMER) {
1180 1180 logmsg(LOG_DEBUG, "conditional_run_timeouts: "
1181 1181 "elapsed %d\n", elapsed);
1182 1182 }
1183 1183 run_timeouts();
1184 1184 }
1185 1185 }
1186 1186
1187 1187 /*
1188 1188 * Timer has fired.
1189 1189 * Determine when the next timer event will occur by asking all
1190 1190 * the timer routines.
1191 1191 * Should not be called from a timer routine but in some cases this is
1192 1192 * done because the code doesn't know that e.g. it was called from
1193 1193 * ifconfig_timer(). In this case the nested run_timeouts will just return but
1194 1194 * the running run_timeouts will ensure to call all the timer functions by
1195 1195 * looping once more.
1196 1196 */
1197 1197 static void
1198 1198 run_timeouts(void)
1199 1199 {
1200 1200 uint_t now;
1201 1201 uint_t elapsed;
1202 1202 uint_t next;
1203 1203 uint_t nexti;
1204 1204 struct phyint *pi;
1205 1205 struct phyint *next_pi;
1206 1206 struct prefix *pr;
1207 1207 struct prefix *next_pr;
1208 1208 struct adv_prefix *adv_pr;
1209 1209 struct adv_prefix *next_adv_pr;
1210 1210 struct router *dr;
1211 1211 struct router *next_dr;
1212 1212 static boolean_t timeout_running;
1213 1213 static boolean_t do_retry;
1214 1214
1215 1215 if (timeout_running) {
1216 1216 if (debug & D_TIMER)
1217 1217 logmsg(LOG_DEBUG, "run_timeouts: nested call\n");
1218 1218 do_retry = _B_TRUE;
1219 1219 return;
1220 1220 }
1221 1221 timeout_running = _B_TRUE;
1222 1222 retry:
1223 1223 /* How much time since the last time we were called? */
1224 1224 now = getcurrenttime();
1225 1225 elapsed = now - timer_previous;
1226 1226 timer_previous = now;
1227 1227
1228 1228 if (debug & D_TIMER)
1229 1229 logmsg(LOG_DEBUG, "run_timeouts: elapsed %d\n", elapsed);
1230 1230
1231 1231 next = TIMER_INFINITY;
1232 1232 for (pi = phyints; pi != NULL; pi = next_pi) {
1233 1233 next_pi = pi->pi_next;
1234 1234 nexti = phyint_timer(pi, elapsed);
1235 1235 if (nexti != TIMER_INFINITY && nexti < next)
1236 1236 next = nexti;
1237 1237 if (debug & D_TIMER) {
1238 1238 logmsg(LOG_DEBUG, "run_timeouts (pi %s): %d -> %u ms\n",
1239 1239 pi->pi_name, nexti, next);
1240 1240 }
1241 1241 for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
1242 1242 next_pr = pr->pr_next;
1243 1243 nexti = prefix_timer(pr, elapsed);
1244 1244 if (nexti != TIMER_INFINITY && nexti < next)
1245 1245 next = nexti;
1246 1246 if (debug & D_TIMER) {
1247 1247 logmsg(LOG_DEBUG, "run_timeouts (pr %s): "
1248 1248 "%d -> %u ms\n", pr->pr_name, nexti, next);
1249 1249 }
1250 1250 }
1251 1251 for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL;
1252 1252 adv_pr = next_adv_pr) {
1253 1253 next_adv_pr = adv_pr->adv_pr_next;
1254 1254 nexti = adv_prefix_timer(adv_pr, elapsed);
1255 1255 if (nexti != TIMER_INFINITY && nexti < next)
1256 1256 next = nexti;
1257 1257 if (debug & D_TIMER) {
1258 1258 logmsg(LOG_DEBUG, "run_timeouts "
1259 1259 "(adv pr on %s): %d -> %u ms\n",
1260 1260 adv_pr->adv_pr_physical->pi_name,
1261 1261 nexti, next);
1262 1262 }
1263 1263 }
1264 1264 for (dr = pi->pi_router_list; dr != NULL; dr = next_dr) {
1265 1265 next_dr = dr->dr_next;
1266 1266 nexti = router_timer(dr, elapsed);
1267 1267 if (nexti != TIMER_INFINITY && nexti < next)
1268 1268 next = nexti;
1269 1269 if (debug & D_TIMER) {
1270 1270 logmsg(LOG_DEBUG, "run_timeouts (dr): "
1271 1271 "%d -> %u ms\n", nexti, next);
1272 1272 }
1273 1273 }
1274 1274 if (pi->pi_TmpAddrsEnabled) {
1275 1275 nexti = tmptoken_timer(pi, elapsed);
1276 1276 if (nexti != TIMER_INFINITY && nexti < next)
1277 1277 next = nexti;
1278 1278 if (debug & D_TIMER) {
1279 1279 logmsg(LOG_DEBUG, "run_timeouts (tmp on %s): "
1280 1280 "%d -> %u ms\n", pi->pi_name, nexti, next);
1281 1281 }
1282 1282 }
1283 1283 }
1284 1284 /*
1285 1285 * Make sure the timer functions are run at least once
1286 1286 * an hour.
1287 1287 */
1288 1288 if (next == TIMER_INFINITY)
1289 1289 next = 3600 * 1000; /* 1 hour */
1290 1290
1291 1291 if (debug & D_TIMER)
1292 1292 logmsg(LOG_DEBUG, "run_timeouts: %u ms\n", next);
1293 1293 timer_schedule(next);
1294 1294 if (do_retry) {
1295 1295 if (debug & D_TIMER)
1296 1296 logmsg(LOG_DEBUG, "run_timeouts: retry\n");
1297 1297 do_retry = _B_FALSE;
1298 1298 goto retry;
1299 1299 }
1300 1300 timeout_running = _B_FALSE;
1301 1301 }
1302 1302
1303 1303 static int eventpipe_read = -1; /* Used for synchronous signal delivery */
1304 1304 static int eventpipe_write = -1;
1305 1305
1306 1306 /*
1307 1307 * Ensure that signals are processed synchronously with the rest of
1308 1308 * the code by just writing a one character signal number on the pipe.
1309 1309 * The poll loop will pick this up and process the signal event.
1310 1310 */
1311 1311 static void
1312 1312 sig_handler(int signo)
1313 1313 {
1314 1314 uchar_t buf = (uchar_t)signo;
1315 1315
1316 1316 if (eventpipe_write == -1) {
1317 1317 logmsg(LOG_ERR, "sig_handler: no pipe\n");
1318 1318 return;
1319 1319 }
1320 1320 if (write(eventpipe_write, &buf, sizeof (buf)) < 0)
1321 1321 logperror("sig_handler: write");
1322 1322 }
1323 1323
1324 1324 /*
1325 1325 * Pick up a signal "byte" from the pipe and process it.
1326 1326 */
1327 1327 static void
1328 1328 in_signal(int fd)
1329 1329 {
1330 1330 uchar_t buf;
1331 1331 struct phyint *pi;
1332 1332 struct phyint *next_pi;
1333 1333
1334 1334 switch (read(fd, &buf, sizeof (buf))) {
1335 1335 case -1:
1336 1336 logperror("in_signal: read");
1337 1337 exit(1);
1338 1338 /* NOTREACHED */
1339 1339 case 1:
1340 1340 break;
1341 1341 case 0:
1342 1342 logmsg(LOG_ERR, "in_signal: read eof\n");
1343 1343 exit(1);
1344 1344 /* NOTREACHED */
1345 1345 default:
1346 1346 logmsg(LOG_ERR, "in_signal: read > 1\n");
1347 1347 exit(1);
1348 1348 }
1349 1349
1350 1350 if (debug & D_TIMER)
1351 1351 logmsg(LOG_DEBUG, "in_signal() got %d\n", buf);
1352 1352
1353 1353 switch (buf) {
1354 1354 case SIGALRM:
1355 1355 if (debug & D_TIMER) {
1356 1356 uint_t now = getcurrenttime();
1357 1357
1358 1358 logmsg(LOG_DEBUG, "in_signal(SIGALRM) delta %u\n",
1359 1359 now - timer_next);
1360 1360 }
1361 1361 timer_next = TIMER_INFINITY;
1362 1362 run_timeouts();
1363 1363 break;
1364 1364 case SIGHUP:
1365 1365 /* Re-read config file by exec'ing ourselves */
1366 1366 for (pi = phyints; pi != NULL; pi = next_pi) {
1367 1367 next_pi = pi->pi_next;
1368 1368 if (pi->pi_AdvSendAdvertisements)
1369 1369 check_to_advertise(pi, START_FINAL_ADV);
1370 1370
1371 1371 /*
1372 1372 * Remove all the configured addresses.
1373 1373 * Remove the addrobj names created with ipmgmtd.
1374 1374 * Release the dhcpv6 addresses if any.
1375 1375 * Cleanup the phyints.
1376 1376 */
1377 1377 phyint_delete(pi);
1378 1378 }
1379 1379
1380 1380 /*
1381 1381 * Prevent fd leaks. Everything gets re-opened at start-up
1382 1382 * time. 0, 1, and 2 are closed and re-opened as
1383 1383 * /dev/null, so we'll leave those open.
1384 1384 */
1385 1385 closefrom(3);
1386 1386
1387 1387 logmsg(LOG_ERR, "SIGHUP: restart and reread config file\n");
1388 1388 (void) execv(argv0[0], argv0);
1389 1389 _exit(0177);
1390 1390 /* NOTREACHED */
1391 1391 case SIGUSR1:
1392 1392 logmsg(LOG_DEBUG, "Printing configuration:\n");
1393 1393 phyint_print_all();
1394 1394 break;
1395 1395 case SIGINT:
1396 1396 case SIGTERM:
1397 1397 case SIGQUIT:
1398 1398 for (pi = phyints; pi != NULL; pi = next_pi) {
1399 1399 next_pi = pi->pi_next;
1400 1400 if (pi->pi_AdvSendAdvertisements)
1401 1401 check_to_advertise(pi, START_FINAL_ADV);
1402 1402
1403 1403 phyint_delete(pi);
1404 1404 }
1405 1405 (void) unlink(NDPD_SNMP_SOCKET);
1406 1406 exit(0);
1407 1407 /* NOTREACHED */
1408 1408 case 255:
1409 1409 /*
1410 1410 * Special "signal" from loopback_ra_enqueue.
1411 1411 * Handle any queued loopback router advertisements.
1412 1412 */
1413 1413 loopback_ra_dequeue();
1414 1414 break;
1415 1415 default:
1416 1416 logmsg(LOG_ERR, "in_signal: unknown signal: %d\n", buf);
1417 1417 }
1418 1418 }
1419 1419
1420 1420 /*
1421 1421 * Create pipe for signal delivery and set up signal handlers.
1422 1422 */
1423 1423 static void
1424 1424 setup_eventpipe(void)
1425 1425 {
1426 1426 int fds[2];
1427 1427 struct sigaction act;
1428 1428
1429 1429 if ((pipe(fds)) < 0) {
1430 1430 logperror("setup_eventpipe: pipe");
1431 1431 exit(1);
1432 1432 }
1433 1433 eventpipe_read = fds[0];
1434 1434 eventpipe_write = fds[1];
1435 1435 if (poll_add(eventpipe_read) == -1) {
1436 1436 exit(1);
1437 1437 }
1438 1438 act.sa_handler = sig_handler;
1439 1439 act.sa_flags = SA_RESTART;
1440 1440 (void) sigaction(SIGALRM, &act, NULL);
1441 1441
1442 1442 (void) sigset(SIGHUP, sig_handler);
1443 1443 (void) sigset(SIGUSR1, sig_handler);
1444 1444 (void) sigset(SIGTERM, sig_handler);
1445 1445 (void) sigset(SIGINT, sig_handler);
1446 1446 (void) sigset(SIGQUIT, sig_handler);
1447 1447 }
1448 1448
1449 1449 /*
1450 1450 * Create a routing socket for receiving RTM_IFINFO messages and initialize
1451 1451 * the routing socket message header and as much of the sockaddrs as possible.
1452 1452 */
1453 1453 static int
1454 1454 setup_rtsock(void)
1455 1455 {
1456 1456 int s;
1457 1457 int ret;
1458 1458 char *cp;
1459 1459 struct sockaddr_in6 *sin6;
1460 1460
1461 1461 s = socket(PF_ROUTE, SOCK_RAW, AF_INET6);
1462 1462 if (s == -1) {
1463 1463 logperror("socket(PF_ROUTE)");
1464 1464 exit(1);
1465 1465 }
1466 1466 ret = fcntl(s, F_SETFL, O_NDELAY|O_NONBLOCK);
1467 1467 if (ret < 0) {
1468 1468 logperror("fcntl(O_NDELAY)");
1469 1469 exit(1);
1470 1470 }
1471 1471 if (poll_add(s) == -1) {
1472 1472 exit(1);
1473 1473 }
1474 1474
1475 1475 /*
1476 1476 * Allocate storage for the routing socket message.
1477 1477 */
1478 1478 rt_msg = (struct rt_msghdr *)malloc(NDP_RTM_MSGLEN);
1479 1479 if (rt_msg == NULL) {
1480 1480 logperror("malloc");
1481 1481 exit(1);
1482 1482 }
1483 1483
1484 1484 /*
1485 1485 * Initialize the routing socket message by zero-filling it and then
1486 1486 * setting the fields where are constant through the lifetime of the
1487 1487 * process.
1488 1488 */
1489 1489 bzero(rt_msg, NDP_RTM_MSGLEN);
1490 1490 rt_msg->rtm_msglen = NDP_RTM_MSGLEN;
1491 1491 rt_msg->rtm_version = RTM_VERSION;
1492 1492 rt_msg->rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK | RTA_IFP;
1493 1493 rt_msg->rtm_pid = getpid();
1494 1494 if (rt_msg->rtm_pid < 0) {
1495 1495 logperror("getpid");
1496 1496 exit(1);
1497 1497 }
1498 1498
1499 1499 /*
1500 1500 * The RTA_DST sockaddr does not change during the lifetime of the
1501 1501 * process so it can be completely initialized at this time.
1502 1502 */
1503 1503 cp = (char *)rt_msg + sizeof (struct rt_msghdr);
1504 1504 sin6 = (struct sockaddr_in6 *)cp;
1505 1505 sin6->sin6_family = AF_INET6;
1506 1506 sin6->sin6_addr = in6addr_any;
1507 1507
1508 1508 /*
1509 1509 * Initialize the constant portion of the RTA_GATEWAY sockaddr.
1510 1510 */
1511 1511 cp += sizeof (struct sockaddr_in6);
1512 1512 rta_gateway = (struct sockaddr_in6 *)cp;
1513 1513 rta_gateway->sin6_family = AF_INET6;
1514 1514
1515 1515 /*
1516 1516 * The RTA_NETMASK sockaddr does not change during the lifetime of the
1517 1517 * process so it can be completely initialized at this time.
1518 1518 */
1519 1519 cp += sizeof (struct sockaddr_in6);
1520 1520 sin6 = (struct sockaddr_in6 *)cp;
1521 1521 sin6->sin6_family = AF_INET6;
1522 1522 sin6->sin6_addr = in6addr_any;
1523 1523
1524 1524 /*
1525 1525 * Initialize the constant portion of the RTA_IFP sockaddr.
1526 1526 */
1527 1527 cp += sizeof (struct sockaddr_in6);
1528 1528 rta_ifp = (struct sockaddr_dl *)cp;
1529 1529 rta_ifp->sdl_family = AF_LINK;
1530 1530
1531 1531 return (s);
1532 1532 }
1533 1533
1534 1534 static int
1535 1535 setup_mibsock(void)
1536 1536 {
1537 1537 int sock;
1538 1538 int ret;
1539 1539 int len;
1540 1540 struct sockaddr_un laddr;
1541 1541
1542 1542 sock = socket(AF_UNIX, SOCK_DGRAM, 0);
1543 1543 if (sock == -1) {
1544 1544 logperror("setup_mibsock: socket(AF_UNIX)");
1545 1545 exit(1);
1546 1546 }
1547 1547
1548 1548 bzero(&laddr, sizeof (laddr));
1549 1549 laddr.sun_family = AF_UNIX;
1550 1550
1551 1551 (void) strncpy(laddr.sun_path, NDPD_SNMP_SOCKET,
1552 1552 sizeof (laddr.sun_path));
1553 1553 len = sizeof (struct sockaddr_un);
1554 1554
1555 1555 (void) unlink(NDPD_SNMP_SOCKET);
1556 1556 ret = bind(sock, (struct sockaddr *)&laddr, len);
1557 1557 if (ret < 0) {
1558 1558 logperror("setup_mibsock: bind\n");
1559 1559 exit(1);
1560 1560 }
1561 1561
1562 1562 ret = fcntl(sock, F_SETFL, O_NONBLOCK);
1563 1563 if (ret < 0) {
1564 1564 logperror("fcntl(O_NONBLOCK)");
1565 1565 exit(1);
1566 1566 }
1567 1567 if (poll_add(sock) == -1) {
1568 1568 exit(1);
1569 1569 }
1570 1570 return (sock);
1571 1571 }
1572 1572
1573 1573 /*
1574 1574 * Retrieve one routing socket message. If RTM_IFINFO indicates
1575 1575 * new phyint do a full scan of the interfaces. If RTM_IFINFO
1576 1576 * indicates an existing phyint, only scan that phyint and associated
1577 1577 * prefixes.
1578 1578 */
1579 1579 static void
1580 1580 process_rtsock(int rtsock)
1581 1581 {
1582 1582 int n;
1583 1583 #define MSG_SIZE 2048/8
1584 1584 int64_t msg[MSG_SIZE];
1585 1585 struct rt_msghdr *rtm;
1586 1586 struct if_msghdr *ifm;
1587 1587 struct phyint *pi;
1588 1588 struct prefix *pr;
1589 1589 boolean_t need_initifs = _B_FALSE;
1590 1590 boolean_t need_ifscan = _B_FALSE;
1591 1591 int64_t ifscan_msg[10][MSG_SIZE];
1592 1592 int ifscan_index = 0;
1593 1593 int i;
1594 1594
1595 1595 /* Empty the rtsock and coealesce all the work that we have */
1596 1596 while (ifscan_index < 10) {
1597 1597 n = read(rtsock, msg, sizeof (msg));
1598 1598 if (n <= 0) {
1599 1599 /* No more messages */
1600 1600 break;
1601 1601 }
1602 1602 rtm = (struct rt_msghdr *)msg;
1603 1603 if (rtm->rtm_version != RTM_VERSION) {
1604 1604 logmsg(LOG_ERR,
1605 1605 "process_rtsock: version %d not understood\n",
1606 1606 rtm->rtm_version);
1607 1607 return;
1608 1608 }
1609 1609 switch (rtm->rtm_type) {
1610 1610 case RTM_NEWADDR:
1611 1611 case RTM_DELADDR:
1612 1612 /*
1613 1613 * Some logical interface has changed - have to scan
1614 1614 * everything to determine what actually changed.
1615 1615 */
1616 1616 if (debug & D_IFSCAN) {
1617 1617 logmsg(LOG_DEBUG, "process_rtsock: "
1618 1618 "message %d\n", rtm->rtm_type);
1619 1619 }
1620 1620 need_initifs = _B_TRUE;
1621 1621 break;
1622 1622 case RTM_IFINFO:
1623 1623 need_ifscan = _B_TRUE;
1624 1624 (void) memcpy(ifscan_msg[ifscan_index], rtm,
1625 1625 sizeof (msg));
1626 1626 ifscan_index++;
1627 1627 /* Handled below */
1628 1628 break;
1629 1629 default:
1630 1630 /* Not interesting */
1631 1631 break;
1632 1632 }
1633 1633 }
1634 1634 /*
1635 1635 * If we do full scan i.e initifs, we don't need to
1636 1636 * scan a particular interface as we should have
1637 1637 * done that as part of initifs.
1638 1638 */
1639 1639 if (need_initifs) {
1640 1640 initifs(_B_FALSE);
1641 1641 return;
1642 1642 }
1643 1643
1644 1644 if (!need_ifscan)
1645 1645 return;
1646 1646
1647 1647 for (i = 0; i < ifscan_index; i++) {
1648 1648 ifm = (struct if_msghdr *)ifscan_msg[i];
1649 1649 if (debug & D_IFSCAN)
1650 1650 logmsg(LOG_DEBUG, "process_rtsock: index %d\n",
1651 1651 ifm->ifm_index);
1652 1652
1653 1653 pi = phyint_lookup_on_index(ifm->ifm_index);
1654 1654 if (pi == NULL) {
1655 1655 /*
1656 1656 * A new physical interface. Do a full scan of the
1657 1657 * to catch any new logical interfaces.
1658 1658 */
1659 1659 initifs(_B_FALSE);
1660 1660 return;
1661 1661 }
1662 1662
1663 1663 if (ifm->ifm_flags != (uint_t)pi->pi_flags) {
1664 1664 if (debug & D_IFSCAN) {
1665 1665 logmsg(LOG_DEBUG, "process_rtsock: clr for "
1666 1666 "%s old flags 0x%llx new flags 0x%x\n",
1667 1667 pi->pi_name, pi->pi_flags, ifm->ifm_flags);
1668 1668 }
1669 1669 }
1670 1670
1671 1671
1672 1672 /*
1673 1673 * Mark the interfaces so that we can find phyints and prefixes
1674 1674 * which have disappeared from the kernel.
1675 1675 * if_process will set pr_in_use when it finds the
1676 1676 * interface in the kernel.
1677 1677 * Before re-examining the state of the interfaces,
1678 1678 * PI_PRESENT should be cleared from pi_kernel_state.
1679 1679 */
1680 1680 pi->pi_kernel_state &= ~PI_PRESENT;
1681 1681 for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) {
1682 1682 pr->pr_in_use = _B_FALSE;
1683 1683 }
1684 1684
1685 1685 if (ifsock < 0) {
1686 1686 ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
1687 1687 if (ifsock < 0) {
1688 1688 logperror("process_rtsock: socket");
1689 1689 return;
1690 1690 }
1691 1691 }
1692 1692 if_process(ifsock, pi->pi_name, _B_FALSE);
1693 1693 for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) {
1694 1694 if_process(ifsock, pr->pr_name, _B_FALSE);
1695 1695 }
1696 1696 /*
1697 1697 * If interface (still) exists in kernel, set
1698 1698 * pi_state to indicate that.
1699 1699 */
1700 1700 if (pi->pi_kernel_state & PI_PRESENT) {
1701 1701 pi->pi_state |= PI_PRESENT;
1702 1702 }
1703 1703 check_if_removed(pi);
1704 1704 if (show_ifs)
1705 1705 phyint_print_all();
1706 1706 }
1707 1707 }
1708 1708
1709 1709 static void
1710 1710 process_mibsock(int mibsock)
1711 1711 {
1712 1712 struct phyint *pi;
1713 1713 socklen_t fromlen;
1714 1714 struct sockaddr_un from;
1715 1715 ndpd_info_t ndpd_info;
1716 1716 ssize_t len;
1717 1717 int command;
1718 1718
1719 1719 fromlen = (socklen_t)sizeof (from);
1720 1720 len = recvfrom(mibsock, &command, sizeof (int), 0,
1721 1721 (struct sockaddr *)&from, &fromlen);
1722 1722
1723 1723 if (len < sizeof (int) || command != NDPD_SNMP_INFO_REQ) {
1724 1724 logperror("process_mibsock: bad command \n");
1725 1725 return;
1726 1726 }
1727 1727
1728 1728 ndpd_info.info_type = NDPD_SNMP_INFO_RESPONSE;
1729 1729 ndpd_info.info_version = NDPD_SNMP_INFO_VER;
1730 1730 ndpd_info.info_num_of_phyints = num_of_phyints;
1731 1731
1732 1732 (void) sendto(mibsock, &ndpd_info, sizeof (ndpd_info_t), 0,
1733 1733 (struct sockaddr *)&from, fromlen);
1734 1734
1735 1735 for (pi = phyints; pi != NULL; pi = pi->pi_next) {
1736 1736 int prefixes;
1737 1737 int routers;
1738 1738 struct prefix *prefix_list;
1739 1739 struct router *router_list;
1740 1740 ndpd_phyint_info_t phyint;
1741 1741 ndpd_prefix_info_t prefix;
1742 1742 ndpd_router_info_t router;
1743 1743 /*
1744 1744 * get number of prefixes
1745 1745 */
1746 1746 routers = 0;
1747 1747 prefixes = 0;
1748 1748 prefix_list = pi->pi_prefix_list;
1749 1749 while (prefix_list != NULL) {
1750 1750 prefixes++;
1751 1751 prefix_list = prefix_list->pr_next;
1752 1752 }
1753 1753
1754 1754 /*
1755 1755 * get number of routers
1756 1756 */
1757 1757 router_list = pi->pi_router_list;
1758 1758 while (router_list != NULL) {
1759 1759 routers++;
1760 1760 router_list = router_list->dr_next;
1761 1761 }
1762 1762
1763 1763 phyint.phyint_info_type = NDPD_PHYINT_INFO;
1764 1764 phyint.phyint_info_version = NDPD_PHYINT_INFO_VER;
1765 1765 phyint.phyint_index = pi->pi_index;
1766 1766 bcopy(pi->pi_config,
1767 1767 phyint.phyint_config, I_IFSIZE);
1768 1768 phyint.phyint_num_of_prefixes = prefixes;
1769 1769 phyint.phyint_num_of_routers = routers;
1770 1770 (void) sendto(mibsock, &phyint, sizeof (phyint), 0,
1771 1771 (struct sockaddr *)&from, fromlen);
1772 1772
1773 1773 /*
1774 1774 * Copy prefix information
1775 1775 */
1776 1776
1777 1777 prefix_list = pi->pi_prefix_list;
1778 1778 while (prefix_list != NULL) {
1779 1779 prefix.prefix_info_type = NDPD_PREFIX_INFO;
1780 1780 prefix.prefix_info_version = NDPD_PREFIX_INFO_VER;
1781 1781 prefix.prefix_prefix = prefix_list->pr_prefix;
1782 1782 prefix.prefix_len = prefix_list->pr_prefix_len;
1783 1783 prefix.prefix_flags = prefix_list->pr_flags;
1784 1784 prefix.prefix_phyint_index = pi->pi_index;
1785 1785 prefix.prefix_ValidLifetime =
1786 1786 prefix_list->pr_ValidLifetime;
1787 1787 prefix.prefix_PreferredLifetime =
1788 1788 prefix_list->pr_PreferredLifetime;
1789 1789 prefix.prefix_OnLinkLifetime =
1790 1790 prefix_list->pr_OnLinkLifetime;
1791 1791 prefix.prefix_OnLinkFlag =
1792 1792 prefix_list->pr_OnLinkFlag;
1793 1793 prefix.prefix_AutonomousFlag =
1794 1794 prefix_list->pr_AutonomousFlag;
1795 1795 (void) sendto(mibsock, &prefix, sizeof (prefix), 0,
1796 1796 (struct sockaddr *)&from, fromlen);
1797 1797 prefix_list = prefix_list->pr_next;
1798 1798 }
1799 1799 /*
1800 1800 * Copy router information
1801 1801 */
1802 1802 router_list = pi->pi_router_list;
1803 1803 while (router_list != NULL) {
1804 1804 router.router_info_type = NDPD_ROUTER_INFO;
1805 1805 router.router_info_version = NDPD_ROUTER_INFO_VER;
1806 1806 router.router_address = router_list->dr_address;
1807 1807 router.router_lifetime = router_list->dr_lifetime;
1808 1808 router.router_phyint_index = pi->pi_index;
1809 1809 (void) sendto(mibsock, &router, sizeof (router), 0,
1810 1810 (struct sockaddr *)&from, fromlen);
1811 1811 router_list = router_list->dr_next;
1812 1812 }
1813 1813 }
1814 1814 }
1815 1815
1816 1816 /*
1817 1817 * Look if the phyint or one of its prefixes have been removed from
1818 1818 * the kernel and take appropriate action.
1819 1819 * Uses pr_in_use and pi{,_kernel}_state.
1820 1820 */
1821 1821 static void
1822 1822 check_if_removed(struct phyint *pi)
1823 1823 {
1824 1824 struct prefix *pr, *next_pr;
1825 1825
1826 1826 /*
1827 1827 * Detect prefixes which are removed.
1828 1828 * Static prefixes are just removed from our tables.
1829 1829 * Non-static prefixes are recreated i.e. in.ndpd takes precedence
1830 1830 * over manually removing prefixes via ifconfig.
1831 1831 */
1832 1832 for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
1833 1833 next_pr = pr->pr_next;
1834 1834 if (!pr->pr_in_use) {
1835 1835 /* Clear everything except PR_STATIC */
1836 1836 pr->pr_kernel_state &= PR_STATIC;
1837 1837 if (pr->pr_state & PR_STATIC)
1838 1838 prefix_update_ipadm_addrobj(pr, _B_FALSE);
1839 1839 pr->pr_name[0] = '\0';
1840 1840 if (pr->pr_state & PR_STATIC) {
1841 1841 prefix_delete(pr);
1842 1842 } else if (!(pi->pi_kernel_state & PI_PRESENT)) {
1843 1843 /*
1844 1844 * Ensure that there are no future attempts to
1845 1845 * run prefix_update_k since the phyint is gone.
1846 1846 */
1847 1847 pr->pr_state = pr->pr_kernel_state;
1848 1848 } else if (pr->pr_state != pr->pr_kernel_state) {
1849 1849 logmsg(LOG_INFO, "Prefix manually removed "
1850 1850 "on %s; recreating\n", pi->pi_name);
1851 1851 prefix_update_k(pr);
1852 1852 }
1853 1853 }
1854 1854 }
1855 1855
1856 1856 /*
1857 1857 * Detect phyints that have been removed from the kernel, and tear
1858 1858 * down any prefixes we created that are associated with that phyint.
1859 1859 * (NOTE: IPMP depends on in.ndpd tearing down these prefixes so an
1860 1860 * administrator can easily place an IP interface with ADDRCONF'd
1861 1861 * addresses into an IPMP group.)
1862 1862 */
1863 1863 if (!(pi->pi_kernel_state & PI_PRESENT) &&
1864 1864 (pi->pi_state & PI_PRESENT)) {
1865 1865 logmsg(LOG_ERR, "Interface %s has been removed from kernel. "
1866 1866 "in.ndpd will no longer use it\n", pi->pi_name);
1867 1867
1868 1868 for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
1869 1869 next_pr = pr->pr_next;
1870 1870 if (pr->pr_state & PR_AUTO)
1871 1871 prefix_update_ipadm_addrobj(pr, _B_FALSE);
1872 1872 prefix_delete(pr);
1873 1873 }
1874 1874
1875 1875 /*
1876 1876 * Clear state so that should the phyint reappear we will
1877 1877 * start with initial advertisements or solicitations.
1878 1878 */
1879 1879 phyint_cleanup(pi);
1880 1880 }
1881 1881 }
1882 1882
1883 1883
1884 1884 /*
1885 1885 * Queuing mechanism for router advertisements that are sent by in.ndpd
1886 1886 * and that also need to be processed by in.ndpd.
1887 1887 * Uses "signal number" 255 to indicate to the main poll loop
1888 1888 * that there is something to dequeue and send to incomining_ra().
1889 1889 */
1890 1890 struct raq {
1891 1891 struct raq *raq_next;
1892 1892 struct phyint *raq_pi;
1893 1893 int raq_packetlen;
1894 1894 uchar_t *raq_packet;
1895 1895 };
1896 1896 static struct raq *raq_head = NULL;
1897 1897
1898 1898 /*
1899 1899 * Allocate a struct raq and memory for the packet.
1900 1900 * Send signal 255 to have poll dequeue.
1901 1901 */
1902 1902 static void
1903 1903 loopback_ra_enqueue(struct phyint *pi, struct nd_router_advert *ra, int len)
1904 1904 {
1905 1905 struct raq *raq;
1906 1906 struct raq **raqp;
1907 1907
1908 1908 if (no_loopback)
1909 1909 return;
1910 1910
1911 1911 if (debug & D_PKTOUT)
1912 1912 logmsg(LOG_DEBUG, "loopback_ra_enqueue for %s\n", pi->pi_name);
1913 1913
1914 1914 raq = calloc(sizeof (struct raq), 1);
1915 1915 if (raq == NULL) {
1916 1916 logmsg(LOG_ERR, "loopback_ra_enqueue: out of memory\n");
1917 1917 return;
1918 1918 }
1919 1919 raq->raq_packet = malloc(len);
1920 1920 if (raq->raq_packet == NULL) {
1921 1921 free(raq);
1922 1922 logmsg(LOG_ERR, "loopback_ra_enqueue: out of memory\n");
1923 1923 return;
1924 1924 }
1925 1925 bcopy(ra, raq->raq_packet, len);
1926 1926 raq->raq_packetlen = len;
1927 1927 raq->raq_pi = pi;
1928 1928
1929 1929 /* Tail insert */
1930 1930 raqp = &raq_head;
1931 1931 while (*raqp != NULL)
1932 1932 raqp = &((*raqp)->raq_next);
1933 1933 *raqp = raq;
1934 1934
|
↓ open down ↓ |
1934 lines elided |
↑ open up ↑ |
1935 1935 /* Signal for poll loop */
1936 1936 sig_handler(255);
1937 1937 }
1938 1938
1939 1939 /*
1940 1940 * Dequeue and process all queued advertisements.
1941 1941 */
1942 1942 static void
1943 1943 loopback_ra_dequeue(void)
1944 1944 {
1945 - struct sockaddr_in6 from = IN6ADDR_LOOPBACK_INIT;
1945 + struct sockaddr_in6 from = { 0, 0, 0, IN6ADDR_LOOPBACK_INIT };
1946 1946 struct raq *raq;
1947 1947
1948 1948 if (debug & D_PKTIN)
1949 1949 logmsg(LOG_DEBUG, "loopback_ra_dequeue()\n");
1950 1950
1951 1951 while ((raq = raq_head) != NULL) {
1952 1952 raq_head = raq->raq_next;
1953 1953 raq->raq_next = NULL;
1954 1954
1955 1955 if (debug & D_PKTIN) {
1956 1956 logmsg(LOG_DEBUG, "loopback_ra_dequeue for %s\n",
1957 1957 raq->raq_pi->pi_name);
1958 1958 }
1959 1959
1960 1960 incoming_ra(raq->raq_pi,
1961 1961 (struct nd_router_advert *)raq->raq_packet,
1962 1962 raq->raq_packetlen, &from, _B_TRUE);
1963 1963 free(raq->raq_packet);
1964 1964 free(raq);
1965 1965 }
1966 1966 }
1967 1967
1968 1968
1969 1969 static void
1970 1970 usage(char *cmd)
1971 1971 {
1972 1972 (void) fprintf(stderr,
1973 1973 "usage: %s [ -adt ] [-f <config file>]\n", cmd);
1974 1974 }
1975 1975
1976 1976 int
1977 1977 main(int argc, char *argv[])
1978 1978 {
1979 1979 int i;
1980 1980 struct phyint *pi;
1981 1981 int c;
1982 1982 char *config_file = PATH_NDPD_CONF;
1983 1983 boolean_t file_required = _B_FALSE;
1984 1984
1985 1985 argv0 = argv;
1986 1986 srandom(gethostid());
1987 1987 (void) umask(0022);
1988 1988
1989 1989 while ((c = getopt(argc, argv, "adD:ntIf:")) != EOF) {
1990 1990 switch (c) {
1991 1991 case 'a':
1992 1992 /*
1993 1993 * The StatelessAddrConf variable in ndpd.conf, if
1994 1994 * present, will override this setting.
1995 1995 */
1996 1996 ifdefaults[I_StatelessAddrConf].cf_value = 0;
1997 1997 break;
1998 1998 case 'd':
1999 1999 debug = D_ALL;
2000 2000 break;
2001 2001 case 'D':
2002 2002 i = strtol((char *)optarg, NULL, 0);
2003 2003 if (i == 0) {
2004 2004 (void) fprintf(stderr, "Bad debug flags: %s\n",
2005 2005 (char *)optarg);
2006 2006 exit(1);
2007 2007 }
2008 2008 debug |= i;
2009 2009 break;
2010 2010 case 'n':
2011 2011 no_loopback = 1;
2012 2012 break;
2013 2013 case 'I':
2014 2014 show_ifs = 1;
2015 2015 break;
2016 2016 case 't':
2017 2017 debug |= D_PKTIN | D_PKTOUT | D_PKTBAD;
2018 2018 break;
2019 2019 case 'f':
2020 2020 config_file = (char *)optarg;
2021 2021 file_required = _B_TRUE;
2022 2022 break;
2023 2023 case '?':
2024 2024 usage(argv[0]);
2025 2025 exit(1);
2026 2026 }
2027 2027 }
2028 2028
2029 2029 if (parse_config(config_file, file_required) == -1)
2030 2030 exit(2);
2031 2031
2032 2032 if (show_ifs)
2033 2033 phyint_print_all();
2034 2034
2035 2035 if (debug == 0)
2036 2036 initlog();
2037 2037
2038 2038 cmdsock = ndpd_setup_cmd_listener();
2039 2039 setup_eventpipe();
2040 2040 rtsock = setup_rtsock();
2041 2041 mibsock = setup_mibsock();
2042 2042 timer_init();
2043 2043 initifs(_B_TRUE);
2044 2044
2045 2045 check_daemonize();
2046 2046
2047 2047 for (;;) {
2048 2048 if (poll(pollfds, pollfd_num, -1) < 0) {
2049 2049 if (errno == EINTR)
2050 2050 continue;
2051 2051 logperror("main: poll");
2052 2052 exit(1);
2053 2053 }
2054 2054 for (i = 0; i < pollfd_num; i++) {
2055 2055 if (!(pollfds[i].revents & POLLIN))
2056 2056 continue;
2057 2057 if (pollfds[i].fd == eventpipe_read) {
2058 2058 in_signal(eventpipe_read);
2059 2059 break;
2060 2060 }
2061 2061 if (pollfds[i].fd == rtsock) {
2062 2062 process_rtsock(rtsock);
2063 2063 break;
2064 2064 }
2065 2065 if (pollfds[i].fd == mibsock) {
2066 2066 process_mibsock(mibsock);
2067 2067 break;
2068 2068 }
2069 2069 if (pollfds[i].fd == cmdsock) {
2070 2070 ndpd_cmd_handler(cmdsock);
2071 2071 break;
2072 2072 }
2073 2073 /*
2074 2074 * Run timer routine to advance clock if more than
2075 2075 * half a second since the clock was advanced.
2076 2076 * This limits CPU usage under severe packet
2077 2077 * arrival rates but it creates a slight inaccuracy
2078 2078 * in the timer mechanism.
2079 2079 */
2080 2080 conditional_run_timeouts(500U);
2081 2081 for (pi = phyints; pi != NULL; pi = pi->pi_next) {
2082 2082 if (pollfds[i].fd == pi->pi_sock) {
2083 2083 in_data(pi);
2084 2084 break;
2085 2085 }
2086 2086 }
2087 2087 }
2088 2088 }
2089 2089 /* NOTREACHED */
2090 2090 return (0);
2091 2091 }
2092 2092
2093 2093 /*
2094 2094 * LOGGER
2095 2095 */
2096 2096
2097 2097 static boolean_t logging = _B_FALSE;
2098 2098
2099 2099 static void
2100 2100 initlog(void)
2101 2101 {
2102 2102 logging = _B_TRUE;
2103 2103 openlog("in.ndpd", LOG_PID | LOG_CONS, LOG_DAEMON);
2104 2104 }
2105 2105
2106 2106 /* Print the date/time without a trailing carridge return */
2107 2107 static void
2108 2108 fprintdate(FILE *file)
2109 2109 {
2110 2110 char buf[BUFSIZ];
2111 2111 struct tm tms;
2112 2112 time_t now;
2113 2113
2114 2114 now = time(NULL);
2115 2115 (void) localtime_r(&now, &tms);
2116 2116 (void) strftime(buf, sizeof (buf), "%h %d %X", &tms);
2117 2117 (void) fprintf(file, "%s ", buf);
2118 2118 }
2119 2119
2120 2120 /* PRINTFLIKE2 */
2121 2121 void
2122 2122 logmsg(int level, const char *fmt, ...)
2123 2123 {
2124 2124 va_list ap;
2125 2125 va_start(ap, fmt);
2126 2126
2127 2127 if (logging) {
2128 2128 vsyslog(level, fmt, ap);
2129 2129 } else {
2130 2130 fprintdate(stderr);
2131 2131 (void) vfprintf(stderr, fmt, ap);
2132 2132 }
2133 2133 va_end(ap);
2134 2134 }
2135 2135
2136 2136 void
2137 2137 logperror(const char *str)
2138 2138 {
2139 2139 if (logging) {
2140 2140 syslog(LOG_ERR, "%s: %m\n", str);
2141 2141 } else {
2142 2142 fprintdate(stderr);
2143 2143 (void) fprintf(stderr, "%s: %s\n", str, strerror(errno));
2144 2144 }
2145 2145 }
2146 2146
2147 2147 void
2148 2148 logperror_pi(const struct phyint *pi, const char *str)
2149 2149 {
2150 2150 if (logging) {
2151 2151 syslog(LOG_ERR, "%s (interface %s): %m\n",
2152 2152 str, pi->pi_name);
2153 2153 } else {
2154 2154 fprintdate(stderr);
2155 2155 (void) fprintf(stderr, "%s (interface %s): %s\n",
2156 2156 str, pi->pi_name, strerror(errno));
2157 2157 }
2158 2158 }
2159 2159
2160 2160 void
2161 2161 logperror_pr(const struct prefix *pr, const char *str)
2162 2162 {
2163 2163 if (logging) {
2164 2164 syslog(LOG_ERR, "%s (prefix %s if %s): %m\n",
2165 2165 str, pr->pr_name, pr->pr_physical->pi_name);
2166 2166 } else {
2167 2167 fprintdate(stderr);
2168 2168 (void) fprintf(stderr, "%s (prefix %s if %s): %s\n",
2169 2169 str, pr->pr_name, pr->pr_physical->pi_name,
2170 2170 strerror(errno));
2171 2171 }
2172 2172 }
2173 2173
2174 2174 static int
2175 2175 ndpd_setup_cmd_listener(void)
2176 2176 {
2177 2177 int sock;
2178 2178 int ret;
2179 2179 struct sockaddr_un servaddr;
2180 2180
2181 2181 sock = socket(AF_UNIX, SOCK_STREAM, 0);
2182 2182 if (sock < 0) {
2183 2183 logperror("socket");
2184 2184 exit(1);
2185 2185 }
2186 2186
2187 2187 bzero(&servaddr, sizeof (servaddr));
2188 2188 servaddr.sun_family = AF_UNIX;
2189 2189 (void) strlcpy(servaddr.sun_path, IPADM_UDS_PATH,
2190 2190 sizeof (servaddr.sun_path));
2191 2191 (void) unlink(servaddr.sun_path);
2192 2192 ret = bind(sock, (struct sockaddr *)&servaddr, sizeof (servaddr));
2193 2193 if (ret < 0) {
2194 2194 logperror("bind");
2195 2195 exit(1);
2196 2196 }
2197 2197 if (listen(sock, 30) < 0) {
2198 2198 logperror("listen");
2199 2199 exit(1);
2200 2200 }
2201 2201 if (poll_add(sock) == -1) {
2202 2202 logmsg(LOG_ERR, "command socket could not be added to the "
2203 2203 "polling set\n");
2204 2204 exit(1);
2205 2205 }
2206 2206
2207 2207 return (sock);
2208 2208 }
2209 2209
2210 2210 /*
2211 2211 * Commands received over the command socket come here
2212 2212 */
2213 2213 static void
2214 2214 ndpd_cmd_handler(int sock)
2215 2215 {
2216 2216 int newfd;
2217 2217 struct sockaddr_storage peer;
2218 2218 socklen_t peerlen;
2219 2219 ipadm_ndpd_msg_t ndpd_msg;
2220 2220 int retval;
2221 2221
2222 2222 peerlen = sizeof (peer);
2223 2223 newfd = accept(sock, (struct sockaddr *)&peer, &peerlen);
2224 2224 if (newfd < 0) {
2225 2225 logperror("accept");
2226 2226 return;
2227 2227 }
2228 2228
2229 2229 retval = ipadm_ndpd_read(newfd, &ndpd_msg, sizeof (ndpd_msg));
2230 2230 if (retval != 0)
2231 2231 logperror("Could not read ndpd command");
2232 2232
2233 2233 retval = ndpd_process_cmd(newfd, &ndpd_msg);
2234 2234 if (retval != 0) {
2235 2235 logmsg(LOG_ERR, "ndpd command on interface %s failed with "
2236 2236 "error %s\n", ndpd_msg.inm_ifname, strerror(retval));
2237 2237 }
2238 2238 (void) close(newfd);
2239 2239 }
2240 2240
2241 2241 /*
2242 2242 * Process the commands received from the cmd listener socket.
2243 2243 */
2244 2244 static int
2245 2245 ndpd_process_cmd(int newfd, ipadm_ndpd_msg_t *msg)
2246 2246 {
2247 2247 int err;
2248 2248
2249 2249 if (!ipadm_check_auth()) {
2250 2250 logmsg(LOG_ERR, "User not authorized to send the command\n");
2251 2251 (void) ndpd_send_error(newfd, EPERM);
2252 2252 return (EPERM);
2253 2253 }
2254 2254 switch (msg->inm_cmd) {
2255 2255 case IPADM_DISABLE_AUTOCONF:
2256 2256 err = ndpd_set_autoconf(msg->inm_ifname, _B_FALSE);
2257 2257 break;
2258 2258
2259 2259 case IPADM_ENABLE_AUTOCONF:
2260 2260 err = ndpd_set_autoconf(msg->inm_ifname, _B_TRUE);
2261 2261 break;
2262 2262
2263 2263 case IPADM_CREATE_ADDRS:
2264 2264 err = ndpd_create_addrs(msg->inm_ifname, msg->inm_intfid,
2265 2265 msg->inm_intfidlen, msg->inm_stateless,
2266 2266 msg->inm_stateful, msg->inm_aobjname);
2267 2267 break;
2268 2268
2269 2269 case IPADM_DELETE_ADDRS:
2270 2270 err = ndpd_delete_addrs(msg->inm_ifname);
2271 2271 break;
2272 2272
2273 2273 default:
2274 2274 err = EINVAL;
2275 2275 break;
2276 2276 }
2277 2277
2278 2278 (void) ndpd_send_error(newfd, err);
2279 2279
2280 2280 return (err);
2281 2281 }
2282 2282
2283 2283 static int
2284 2284 ndpd_send_error(int fd, int error)
2285 2285 {
2286 2286 return (ipadm_ndpd_write(fd, &error, sizeof (error)));
2287 2287 }
2288 2288
2289 2289 /*
2290 2290 * Disables/Enables autoconfiguration of addresses on the
2291 2291 * given physical interface.
2292 2292 * This is provided to support the legacy method of configuring IPv6
2293 2293 * addresses. i.e. `ifconfig bge0 inet6 plumb` will plumb the interface
2294 2294 * and start stateless and stateful autoconfiguration. If this function is
2295 2295 * not called with enable=_B_FALSE, no autoconfiguration will be done until
2296 2296 * ndpd_create_addrs() is called with an Interface ID.
2297 2297 */
2298 2298 static int
2299 2299 ndpd_set_autoconf(const char *ifname, boolean_t enable)
2300 2300 {
2301 2301 struct phyint *pi;
2302 2302
2303 2303 pi = phyint_lookup((char *)ifname);
2304 2304 if (pi == NULL) {
2305 2305 /*
2306 2306 * If the physical interface was plumbed but no
2307 2307 * addresses were configured yet, phyint will not exist.
2308 2308 */
2309 2309 pi = phyint_create((char *)ifname);
2310 2310 if (pi == NULL) {
2311 2311 logmsg(LOG_ERR, "could not create phyint for "
2312 2312 "interface %s", ifname);
2313 2313 return (ENOMEM);
2314 2314 }
2315 2315 }
2316 2316 pi->pi_autoconf = enable;
2317 2317
2318 2318 if (debug & D_PHYINT) {
2319 2319 logmsg(LOG_DEBUG, "ndpd_set_autoconf: %s autoconf for "
2320 2320 "interface %s\n", (enable ? "enabled" : "disabled"),
2321 2321 pi->pi_name);
2322 2322 }
2323 2323 return (0);
2324 2324 }
2325 2325
2326 2326 /*
2327 2327 * Create auto-configured addresses on the given interface using
2328 2328 * the given token as the interface id during the next Router Advertisement.
2329 2329 * Currently, only one token per interface is supported.
2330 2330 */
2331 2331 static int
2332 2332 ndpd_create_addrs(const char *ifname, struct sockaddr_in6 intfid, int intfidlen,
2333 2333 boolean_t stateless, boolean_t stateful, char *addrobj)
2334 2334 {
2335 2335 struct phyint *pi;
2336 2336 struct lifreq lifr;
2337 2337 struct sockaddr_in6 *sin6;
2338 2338 int err;
2339 2339
2340 2340 pi = phyint_lookup((char *)ifname);
2341 2341 if (pi == NULL) {
2342 2342 /*
2343 2343 * If the physical interface was plumbed but no
2344 2344 * addresses were configured yet, phyint will not exist.
2345 2345 */
2346 2346 pi = phyint_create((char *)ifname);
2347 2347 if (pi == NULL) {
2348 2348 if (debug & D_PHYINT)
2349 2349 logmsg(LOG_ERR, "could not create phyint "
2350 2350 "for interface %s", ifname);
2351 2351 return (ENOMEM);
2352 2352 }
2353 2353 } else if (pi->pi_autoconf) {
2354 2354 logmsg(LOG_ERR, "autoconfiguration already in progress\n");
2355 2355 return (EEXIST);
2356 2356 }
2357 2357 check_autoconf_var_consistency(pi, stateless, stateful);
2358 2358
2359 2359 if (intfidlen == 0) {
2360 2360 pi->pi_default_token = _B_TRUE;
2361 2361 if (ifsock < 0) {
2362 2362 ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
2363 2363 if (ifsock < 0) {
2364 2364 err = errno;
2365 2365 logperror("ndpd_create_addrs: socket");
2366 2366 return (err);
2367 2367 }
2368 2368 }
2369 2369 (void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
2370 2370 sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
2371 2371 if (ioctl(ifsock, SIOCGLIFTOKEN, (char *)&lifr) < 0) {
2372 2372 err = errno;
2373 2373 logperror("SIOCGLIFTOKEN");
2374 2374 return (err);
2375 2375 }
2376 2376 pi->pi_token = sin6->sin6_addr;
2377 2377 pi->pi_token_length = lifr.lifr_addrlen;
2378 2378 } else {
2379 2379 pi->pi_default_token = _B_FALSE;
2380 2380 pi->pi_token = intfid.sin6_addr;
2381 2381 pi->pi_token_length = intfidlen;
2382 2382 }
2383 2383 pi->pi_stateless = stateless;
2384 2384 pi->pi_stateful = stateful;
2385 2385 (void) strlcpy(pi->pi_ipadm_aobjname, addrobj,
2386 2386 sizeof (pi->pi_ipadm_aobjname));
2387 2387
2388 2388 /* We can allow autoconfiguration now. */
2389 2389 pi->pi_autoconf = _B_TRUE;
2390 2390
2391 2391 /* Restart the solicitations. */
2392 2392 if (pi->pi_sol_state == DONE_SOLICIT)
2393 2393 pi->pi_sol_state = NO_SOLICIT;
2394 2394 if (pi->pi_sol_state == NO_SOLICIT)
2395 2395 check_to_solicit(pi, START_INIT_SOLICIT);
2396 2396 if (debug & D_PHYINT)
2397 2397 logmsg(LOG_DEBUG, "ndpd_create_addrs: "
2398 2398 "added token to interface %s\n", pi->pi_name);
2399 2399 return (0);
2400 2400 }
2401 2401
2402 2402 /*
2403 2403 * This function deletes all addresses on the given interface
2404 2404 * with the given Interface ID.
2405 2405 */
2406 2406 static int
2407 2407 ndpd_delete_addrs(const char *ifname)
2408 2408 {
2409 2409 struct phyint *pi;
2410 2410 struct prefix *pr, *next_pr;
2411 2411 struct lifreq lifr;
2412 2412 int err;
2413 2413
2414 2414 pi = phyint_lookup((char *)ifname);
2415 2415 if (pi == NULL) {
2416 2416 logmsg(LOG_ERR, "no phyint found for %s", ifname);
2417 2417 return (ENXIO);
2418 2418 }
2419 2419 if (IN6_IS_ADDR_UNSPECIFIED(&pi->pi_token)) {
2420 2420 logmsg(LOG_ERR, "token does not exist for %s", ifname);
2421 2421 return (EINVAL);
2422 2422 }
2423 2423
2424 2424 if (ifsock < 0) {
2425 2425 ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
2426 2426 if (ifsock < 0) {
2427 2427 err = errno;
2428 2428 logperror("ndpd_create_addrs: socket");
2429 2429 return (err);
2430 2430 }
2431 2431 }
2432 2432 /* Remove the prefixes for this phyint if they exist */
2433 2433 for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
2434 2434 next_pr = pr->pr_next;
2435 2435 if (pr->pr_name[0] == '\0') {
2436 2436 prefix_delete(pr);
2437 2437 continue;
2438 2438 }
2439 2439 /*
2440 2440 * Delete all the prefixes for the auto-configured
2441 2441 * addresses as well as the DHCPv6 addresses.
2442 2442 */
2443 2443 (void) strncpy(lifr.lifr_name, pr->pr_name,
2444 2444 sizeof (lifr.lifr_name));
2445 2445 if (ioctl(ifsock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
2446 2446 err = errno;
2447 2447 logperror("SIOCGLIFFLAGS");
2448 2448 return (err);
2449 2449 }
2450 2450 if ((lifr.lifr_flags & IFF_ADDRCONF) ||
2451 2451 (lifr.lifr_flags & IFF_DHCPRUNNING)) {
2452 2452 prefix_update_ipadm_addrobj(pr, _B_FALSE);
2453 2453 }
2454 2454 prefix_delete(pr);
2455 2455 }
2456 2456
2457 2457 /*
2458 2458 * If we had started dhcpagent, we need to release the leases
2459 2459 * if any are required.
2460 2460 */
2461 2461 if (pi->pi_stateful) {
2462 2462 (void) strncpy(lifr.lifr_name, pi->pi_name,
2463 2463 sizeof (lifr.lifr_name));
2464 2464 if (ioctl(ifsock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
2465 2465 err = errno;
2466 2466 logperror("SIOCGLIFFLAGS");
2467 2467 return (err);
2468 2468 }
2469 2469 if (lifr.lifr_flags & IFF_DHCPRUNNING)
2470 2470 release_dhcp(pi);
2471 2471 }
2472 2472
2473 2473 /*
2474 2474 * Reset the Interface ID on this phyint and stop autoconfigurations
2475 2475 * until a new interface ID is provided.
2476 2476 */
2477 2477 pi->pi_token = in6addr_any;
2478 2478 pi->pi_token_length = 0;
2479 2479 pi->pi_autoconf = _B_FALSE;
2480 2480 pi->pi_ipadm_aobjname[0] = '\0';
2481 2481
2482 2482 /* Reset the stateless and stateful settings to default. */
2483 2483 pi->pi_stateless = pi->pi_StatelessAddrConf;
2484 2484 pi->pi_stateful = pi->pi_StatefulAddrConf;
2485 2485
2486 2486 if (debug & D_PHYINT) {
2487 2487 logmsg(LOG_DEBUG, "ndpd_delete_addrs: "
2488 2488 "removed token from interface %s\n", pi->pi_name);
2489 2489 }
2490 2490 return (0);
2491 2491 }
2492 2492
2493 2493 void
2494 2494 check_autoconf_var_consistency(struct phyint *pi, boolean_t stateless,
2495 2495 boolean_t stateful)
2496 2496 {
2497 2497 /*
2498 2498 * If StatelessAddrConf and StatelessAddrConf are set in
2499 2499 * /etc/inet/ndpd.conf, check if the new values override those
2500 2500 * settings. If so, log a warning.
2501 2501 */
2502 2502 if ((pi->pi_StatelessAddrConf !=
2503 2503 ifdefaults[I_StatelessAddrConf].cf_value &&
2504 2504 stateless != pi->pi_StatelessAddrConf) ||
2505 2505 (pi->pi_StatefulAddrConf !=
2506 2506 ifdefaults[I_StatefulAddrConf].cf_value &&
2507 2507 stateful != pi->pi_StatefulAddrConf)) {
2508 2508 logmsg(LOG_ERR, "check_autoconf_var_consistency: "
2509 2509 "Overriding the StatelessAddrConf or StatefulAddrConf "
2510 2510 "settings in ndpd.conf with the new values for "
2511 2511 "interface %s\n", pi->pi_name);
2512 2512 }
2513 2513 }
2514 2514
2515 2515 /*
2516 2516 * If ipadm was used to start autoconfiguration and in.ndpd was restarted
2517 2517 * for some reason, in.ndpd has to resume autoconfiguration when it comes up.
2518 2518 * In this function, it scans the ipadm_addr_info() output to find a link-local
2519 2519 * on this interface with address type "addrconf" and extracts the interface id.
2520 2520 * It also stores the addrobj name to be used later when new addresses are
2521 2521 * created for the prefixes advertised by the router.
2522 2522 * If autoconfiguration was never started on this interface before in.ndpd
2523 2523 * was killed, then in.ndpd should refrain from configuring prefixes, even if
2524 2524 * there is a valid link-local on this interface, created by ipadm (identified
2525 2525 * if there is a valid addrobj name).
2526 2526 */
2527 2527 static int
2528 2528 phyint_check_ipadm_intfid(struct phyint *pi)
2529 2529 {
2530 2530 ipadm_status_t status;
2531 2531 ipadm_addr_info_t *addrinfo;
2532 2532 struct ifaddrs *ifap;
2533 2533 ipadm_addr_info_t *ainfop;
2534 2534 struct sockaddr_in6 *sin6;
2535 2535 ipadm_handle_t iph;
2536 2536
2537 2537 if (ipadm_open(&iph, 0) != IPADM_SUCCESS) {
2538 2538 logmsg(LOG_ERR, "could not open handle to libipadm\n");
2539 2539 return (-1);
2540 2540 }
2541 2541
2542 2542 status = ipadm_addr_info(iph, pi->pi_name, &addrinfo,
2543 2543 IPADM_OPT_ZEROADDR, LIFC_NOXMIT|LIFC_TEMPORARY);
2544 2544 if (status != IPADM_SUCCESS) {
2545 2545 ipadm_close(iph);
2546 2546 return (-1);
2547 2547 }
2548 2548 pi->pi_autoconf = _B_TRUE;
2549 2549 for (ainfop = addrinfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
2550 2550 ifap = &ainfop->ia_ifa;
2551 2551 if (ifap->ifa_addr->sa_family != AF_INET6 ||
2552 2552 ainfop->ia_state == IFA_DISABLED)
2553 2553 continue;
2554 2554 sin6 = (struct sockaddr_in6 *)ifap->ifa_addr;
2555 2555 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
2556 2556 if (ainfop->ia_atype == IPADM_ADDR_IPV6_ADDRCONF) {
2557 2557 pi->pi_token = sin6->sin6_addr;
2558 2558 pi->pi_token._S6_un._S6_u32[0] = 0;
2559 2559 pi->pi_token._S6_un._S6_u32[1] = 0;
2560 2560 pi->pi_autoconf = _B_TRUE;
2561 2561 (void) strlcpy(pi->pi_ipadm_aobjname,
2562 2562 ainfop->ia_aobjname,
2563 2563 sizeof (pi->pi_ipadm_aobjname));
2564 2564 break;
2565 2565 }
2566 2566 /*
2567 2567 * If IFF_NOLINKLOCAL is set, then the link-local
2568 2568 * was created using ipadm. Do not autoconfigure until
2569 2569 * ipadm is explicitly used for autoconfiguration.
2570 2570 */
2571 2571 if (ifap->ifa_flags & IFF_NOLINKLOCAL)
2572 2572 pi->pi_autoconf = _B_FALSE;
2573 2573 } else if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
2574 2574 strrchr(ifap->ifa_name, ':') == NULL) {
2575 2575 /* The interface was created using ipadm. */
2576 2576 pi->pi_autoconf = _B_FALSE;
2577 2577 }
2578 2578 }
2579 2579 ipadm_free_addr_info(addrinfo);
2580 2580 if (!pi->pi_autoconf) {
2581 2581 pi->pi_token = in6addr_any;
2582 2582 pi->pi_token_length = 0;
2583 2583 }
2584 2584 ipadm_close(iph);
2585 2585 return (0);
2586 2586 }
|
↓ open down ↓ |
631 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX