17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
58121d73fSseb * Common Development and Distribution License (the "License").
68121d73fSseb * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
20e11c3f44Smeem *
2164639aafSDarren Reed * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
22*44749cf0SAndy Fiddaman * Copyright 2024 Oxide Computer Company
237c478bd9Sstevel@tonic-gate */
247c478bd9Sstevel@tonic-gate
257c478bd9Sstevel@tonic-gate #include "defs.h"
267c478bd9Sstevel@tonic-gate #include "tables.h"
277c478bd9Sstevel@tonic-gate #include <fcntl.h>
283173664eSapersson #include <sys/un.h>
297c478bd9Sstevel@tonic-gate
307c478bd9Sstevel@tonic-gate static void initlog(void);
317c478bd9Sstevel@tonic-gate static void run_timeouts(void);
327c478bd9Sstevel@tonic-gate
337c478bd9Sstevel@tonic-gate static void advertise(struct sockaddr_in6 *sin6, struct phyint *pi,
347c478bd9Sstevel@tonic-gate boolean_t no_prefixes);
357c478bd9Sstevel@tonic-gate static void solicit(struct sockaddr_in6 *sin6, struct phyint *pi);
367c478bd9Sstevel@tonic-gate static void initifs(boolean_t first);
377c478bd9Sstevel@tonic-gate static void check_if_removed(struct phyint *pi);
387c478bd9Sstevel@tonic-gate static void loopback_ra_enqueue(struct phyint *pi,
397c478bd9Sstevel@tonic-gate struct nd_router_advert *ra, int len);
407c478bd9Sstevel@tonic-gate static void loopback_ra_dequeue(void);
417c478bd9Sstevel@tonic-gate static void check_daemonize(void);
427c478bd9Sstevel@tonic-gate
437c478bd9Sstevel@tonic-gate struct in6_addr all_nodes_mcast = { { 0xff, 0x2, 0x0, 0x0,
447c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
457c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
467c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x1 } };
477c478bd9Sstevel@tonic-gate
487c478bd9Sstevel@tonic-gate struct in6_addr all_routers_mcast = { { 0xff, 0x2, 0x0, 0x0,
497c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
507c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
517c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x2 } };
527c478bd9Sstevel@tonic-gate
537c478bd9Sstevel@tonic-gate static struct sockaddr_in6 v6allnodes = { AF_INET6, 0, 0,
547c478bd9Sstevel@tonic-gate { 0xff, 0x2, 0x0, 0x0,
557c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
567c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
577c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x1 } };
587c478bd9Sstevel@tonic-gate
597c478bd9Sstevel@tonic-gate static struct sockaddr_in6 v6allrouters = { AF_INET6, 0, 0,
607c478bd9Sstevel@tonic-gate { 0xff, 0x2, 0x0, 0x0,
617c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
627c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x0,
637c478bd9Sstevel@tonic-gate 0x0, 0x0, 0x0, 0x2 } };
647c478bd9Sstevel@tonic-gate
657c478bd9Sstevel@tonic-gate static char **argv0; /* Saved for re-exec on SIGHUP */
667c478bd9Sstevel@tonic-gate
677c478bd9Sstevel@tonic-gate static uint64_t packet[(IP_MAXPACKET + 1)/8];
687c478bd9Sstevel@tonic-gate
697c478bd9Sstevel@tonic-gate static int show_ifs = 0;
707c478bd9Sstevel@tonic-gate static boolean_t already_daemonized = _B_FALSE;
717c478bd9Sstevel@tonic-gate int debug = 0;
727c478bd9Sstevel@tonic-gate int no_loopback = 0; /* Do not send RA packets to ourselves */
737c478bd9Sstevel@tonic-gate
747c478bd9Sstevel@tonic-gate /*
757c478bd9Sstevel@tonic-gate * Size of routing socket message used by in.ndpd which includes the header,
767c478bd9Sstevel@tonic-gate * space for the RTA_DST, RTA_GATEWAY and RTA_NETMASK (each a sockaddr_in6)
777c478bd9Sstevel@tonic-gate * plus space for the RTA_IFP (a sockaddr_dl).
787c478bd9Sstevel@tonic-gate */
797c478bd9Sstevel@tonic-gate #define NDP_RTM_MSGLEN sizeof (struct rt_msghdr) + \
807c478bd9Sstevel@tonic-gate sizeof (struct sockaddr_in6) + \
817c478bd9Sstevel@tonic-gate sizeof (struct sockaddr_in6) + \
827c478bd9Sstevel@tonic-gate sizeof (struct sockaddr_in6) + \
837c478bd9Sstevel@tonic-gate sizeof (struct sockaddr_dl)
847c478bd9Sstevel@tonic-gate
857c478bd9Sstevel@tonic-gate /*
867c478bd9Sstevel@tonic-gate * These are referenced externally in tables.c in order to fill in the
877c478bd9Sstevel@tonic-gate * dynamic portions of the routing socket message and then to send the message
887c478bd9Sstevel@tonic-gate * itself.
897c478bd9Sstevel@tonic-gate */
907c478bd9Sstevel@tonic-gate int rtsock = -1; /* Routing socket */
917c478bd9Sstevel@tonic-gate struct rt_msghdr *rt_msg; /* Routing socket message */
927c478bd9Sstevel@tonic-gate struct sockaddr_in6 *rta_gateway; /* RTA_GATEWAY sockaddr */
937c478bd9Sstevel@tonic-gate struct sockaddr_dl *rta_ifp; /* RTA_IFP sockaddr */
946e91bba0SGirish Moodalbail
956e91bba0SGirish Moodalbail /*
966e91bba0SGirish Moodalbail * These sockets are used internally in this file.
976e91bba0SGirish Moodalbail */
986e91bba0SGirish Moodalbail static int mibsock = -1; /* mib request socket */
996e91bba0SGirish Moodalbail static int cmdsock = -1; /* command socket */
1006e91bba0SGirish Moodalbail
1016e91bba0SGirish Moodalbail static int ndpd_setup_cmd_listener(void);
1026e91bba0SGirish Moodalbail static void ndpd_cmd_handler(int);
1036e91bba0SGirish Moodalbail static int ndpd_process_cmd(int, ipadm_ndpd_msg_t *);
1046e91bba0SGirish Moodalbail static int ndpd_send_error(int, int);
1056e91bba0SGirish Moodalbail static int ndpd_set_autoconf(const char *, boolean_t);
1066e91bba0SGirish Moodalbail static int ndpd_create_addrs(const char *, struct sockaddr_in6, int,
1076e91bba0SGirish Moodalbail boolean_t, boolean_t, char *);
1086e91bba0SGirish Moodalbail static int ndpd_delete_addrs(const char *);
1096e91bba0SGirish Moodalbail static int phyint_check_ipadm_intfid(struct phyint *);
1107c478bd9Sstevel@tonic-gate
1117c478bd9Sstevel@tonic-gate /*
1127c478bd9Sstevel@tonic-gate * Return the current time in milliseconds truncated to
1137c478bd9Sstevel@tonic-gate * fit in an integer.
1147c478bd9Sstevel@tonic-gate */
1157c478bd9Sstevel@tonic-gate uint_t
getcurrenttime(void)1167c478bd9Sstevel@tonic-gate getcurrenttime(void)
1177c478bd9Sstevel@tonic-gate {
1187c478bd9Sstevel@tonic-gate struct timeval tp;
1197c478bd9Sstevel@tonic-gate
1207c478bd9Sstevel@tonic-gate if (gettimeofday(&tp, NULL) < 0) {
1217c478bd9Sstevel@tonic-gate logperror("getcurrenttime: gettimeofday failed");
1227c478bd9Sstevel@tonic-gate exit(1);
1237c478bd9Sstevel@tonic-gate }
1247c478bd9Sstevel@tonic-gate return (tp.tv_sec * 1000 + tp.tv_usec / 1000);
1257c478bd9Sstevel@tonic-gate }
1267c478bd9Sstevel@tonic-gate
1277c478bd9Sstevel@tonic-gate /*
1287c478bd9Sstevel@tonic-gate * Output a preformated packet from the packet[] buffer.
1297c478bd9Sstevel@tonic-gate */
1307c478bd9Sstevel@tonic-gate static void
sendpacket(struct sockaddr_in6 * sin6,int sock,int size,int flags)1317c478bd9Sstevel@tonic-gate sendpacket(struct sockaddr_in6 *sin6, int sock, int size, int flags)
1327c478bd9Sstevel@tonic-gate {
1337c478bd9Sstevel@tonic-gate int cc;
1347c478bd9Sstevel@tonic-gate char abuf[INET6_ADDRSTRLEN];
1357c478bd9Sstevel@tonic-gate
1367c478bd9Sstevel@tonic-gate cc = sendto(sock, (char *)packet, size, flags,
137e11c3f44Smeem (struct sockaddr *)sin6, sizeof (*sin6));
1387c478bd9Sstevel@tonic-gate if (cc < 0 || cc != size) {
1397c478bd9Sstevel@tonic-gate if (cc < 0) {
1407c478bd9Sstevel@tonic-gate logperror("sendpacket: sendto");
1417c478bd9Sstevel@tonic-gate }
1427c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "sendpacket: wrote %s %d chars, ret=%d\n",
1437c478bd9Sstevel@tonic-gate inet_ntop(sin6->sin6_family,
1447c478bd9Sstevel@tonic-gate (void *)&sin6->sin6_addr,
1457c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)),
1467c478bd9Sstevel@tonic-gate size, cc);
1477c478bd9Sstevel@tonic-gate }
1487c478bd9Sstevel@tonic-gate }
1497c478bd9Sstevel@tonic-gate
150e11c3f44Smeem /*
151e11c3f44Smeem * If possible, place an ND_OPT_SOURCE_LINKADDR option at `optp'.
152e11c3f44Smeem * Return the number of bytes placed in the option.
153e11c3f44Smeem */
154e11c3f44Smeem static uint_t
add_opt_lla(struct phyint * pi,struct nd_opt_lla * optp)155e11c3f44Smeem add_opt_lla(struct phyint *pi, struct nd_opt_lla *optp)
156e11c3f44Smeem {
157e11c3f44Smeem uint_t optlen;
158e11c3f44Smeem uint_t hwaddrlen;
159e11c3f44Smeem struct lifreq lifr;
160e11c3f44Smeem
161e11c3f44Smeem /* If this phyint doesn't have a link-layer address, bail */
162e11c3f44Smeem if (phyint_get_lla(pi, &lifr) == -1)
163e11c3f44Smeem return (0);
164e11c3f44Smeem
165e11c3f44Smeem hwaddrlen = lifr.lifr_nd.lnr_hdw_len;
166e11c3f44Smeem /* roundup to multiple of 8 and make padding zero */
167e11c3f44Smeem optlen = ((sizeof (struct nd_opt_hdr) + hwaddrlen + 7) / 8) * 8;
168e11c3f44Smeem bzero(optp, optlen);
169e11c3f44Smeem optp->nd_opt_lla_type = ND_OPT_SOURCE_LINKADDR;
170e11c3f44Smeem optp->nd_opt_lla_len = optlen / 8;
171e11c3f44Smeem bcopy(lifr.lifr_nd.lnr_hdw_addr, optp->nd_opt_lla_hdw_addr, hwaddrlen);
172e11c3f44Smeem
173e11c3f44Smeem return (optlen);
174e11c3f44Smeem }
175e11c3f44Smeem
1767c478bd9Sstevel@tonic-gate /* Send a Router Solicitation */
1777c478bd9Sstevel@tonic-gate static void
solicit(struct sockaddr_in6 * sin6,struct phyint * pi)1787c478bd9Sstevel@tonic-gate solicit(struct sockaddr_in6 *sin6, struct phyint *pi)
1797c478bd9Sstevel@tonic-gate {
1807c478bd9Sstevel@tonic-gate int packetlen = 0;
1817c478bd9Sstevel@tonic-gate struct nd_router_solicit *rs = (struct nd_router_solicit *)packet;
1827c478bd9Sstevel@tonic-gate char *pptr = (char *)packet;
1837c478bd9Sstevel@tonic-gate
1847c478bd9Sstevel@tonic-gate rs->nd_rs_type = ND_ROUTER_SOLICIT;
1857c478bd9Sstevel@tonic-gate rs->nd_rs_code = 0;
1867c478bd9Sstevel@tonic-gate rs->nd_rs_cksum = htons(0);
1877c478bd9Sstevel@tonic-gate rs->nd_rs_reserved = htonl(0);
1887c478bd9Sstevel@tonic-gate
1897c478bd9Sstevel@tonic-gate packetlen += sizeof (*rs);
1907c478bd9Sstevel@tonic-gate pptr += sizeof (*rs);
1917c478bd9Sstevel@tonic-gate
192e11c3f44Smeem /* add options */
193e11c3f44Smeem packetlen += add_opt_lla(pi, (struct nd_opt_lla *)pptr);
1947c478bd9Sstevel@tonic-gate
1957c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
1967c478bd9Sstevel@tonic-gate print_route_sol("Sending solicitation to ", pi, rs, packetlen,
1977c478bd9Sstevel@tonic-gate sin6);
1987c478bd9Sstevel@tonic-gate }
1997c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0);
2007c478bd9Sstevel@tonic-gate }
2017c478bd9Sstevel@tonic-gate
2027c478bd9Sstevel@tonic-gate /*
2037c478bd9Sstevel@tonic-gate * Send a (set of) Router Advertisements and feed them back to ourselves
2047c478bd9Sstevel@tonic-gate * for processing. Unless no_prefixes is set all prefixes are included.
2057c478bd9Sstevel@tonic-gate * If there are too many prefix options to fit in one packet multiple
2067c478bd9Sstevel@tonic-gate * packets will be sent - each containing a subset of the prefix options.
2077c478bd9Sstevel@tonic-gate */
2087c478bd9Sstevel@tonic-gate static void
advertise(struct sockaddr_in6 * sin6,struct phyint * pi,boolean_t no_prefixes)2097c478bd9Sstevel@tonic-gate advertise(struct sockaddr_in6 *sin6, struct phyint *pi, boolean_t no_prefixes)
2107c478bd9Sstevel@tonic-gate {
2117c478bd9Sstevel@tonic-gate struct nd_opt_prefix_info *po;
2127c478bd9Sstevel@tonic-gate char *pptr = (char *)packet;
2137c478bd9Sstevel@tonic-gate struct nd_router_advert *ra;
2147c478bd9Sstevel@tonic-gate struct adv_prefix *adv_pr;
2157c478bd9Sstevel@tonic-gate int packetlen = 0;
2167c478bd9Sstevel@tonic-gate
2177c478bd9Sstevel@tonic-gate ra = (struct nd_router_advert *)pptr;
2187c478bd9Sstevel@tonic-gate ra->nd_ra_type = ND_ROUTER_ADVERT;
2197c478bd9Sstevel@tonic-gate ra->nd_ra_code = 0;
2207c478bd9Sstevel@tonic-gate ra->nd_ra_cksum = htons(0);
2217c478bd9Sstevel@tonic-gate ra->nd_ra_curhoplimit = pi->pi_AdvCurHopLimit;
2227c478bd9Sstevel@tonic-gate ra->nd_ra_flags_reserved = 0;
2237c478bd9Sstevel@tonic-gate if (pi->pi_AdvManagedFlag)
2247c478bd9Sstevel@tonic-gate ra->nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED;
2257c478bd9Sstevel@tonic-gate if (pi->pi_AdvOtherConfigFlag)
2267c478bd9Sstevel@tonic-gate ra->nd_ra_flags_reserved |= ND_RA_FLAG_OTHER;
2277c478bd9Sstevel@tonic-gate
2287c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV)
2297c478bd9Sstevel@tonic-gate ra->nd_ra_router_lifetime = htons(0);
2307c478bd9Sstevel@tonic-gate else
2317c478bd9Sstevel@tonic-gate ra->nd_ra_router_lifetime = htons(pi->pi_AdvDefaultLifetime);
2327c478bd9Sstevel@tonic-gate ra->nd_ra_reachable = htonl(pi->pi_AdvReachableTime);
2337c478bd9Sstevel@tonic-gate ra->nd_ra_retransmit = htonl(pi->pi_AdvRetransTimer);
2347c478bd9Sstevel@tonic-gate
2357c478bd9Sstevel@tonic-gate packetlen = sizeof (*ra);
2367c478bd9Sstevel@tonic-gate pptr += sizeof (*ra);
2377c478bd9Sstevel@tonic-gate
2387c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV) {
2397c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
2407c478bd9Sstevel@tonic-gate print_route_adv("Sending advert (FINAL) to ", pi,
2417c478bd9Sstevel@tonic-gate ra, packetlen, sin6);
2427c478bd9Sstevel@tonic-gate }
2437c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0);
2447c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */
2457c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen);
2467c478bd9Sstevel@tonic-gate return;
2477c478bd9Sstevel@tonic-gate }
2487c478bd9Sstevel@tonic-gate
249e11c3f44Smeem /* add options */
250e11c3f44Smeem packetlen += add_opt_lla(pi, (struct nd_opt_lla *)pptr);
251e11c3f44Smeem pptr = (char *)packet + packetlen;
2527c478bd9Sstevel@tonic-gate
2537c478bd9Sstevel@tonic-gate if (pi->pi_AdvLinkMTU != 0) {
2547c478bd9Sstevel@tonic-gate struct nd_opt_mtu *mo = (struct nd_opt_mtu *)pptr;
2557c478bd9Sstevel@tonic-gate
2567c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_type = ND_OPT_MTU;
2577c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_len = sizeof (struct nd_opt_mtu) / 8;
2587c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_reserved = 0;
2597c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_mtu = htonl(pi->pi_AdvLinkMTU);
2607c478bd9Sstevel@tonic-gate
2617c478bd9Sstevel@tonic-gate packetlen += sizeof (struct nd_opt_mtu);
2627c478bd9Sstevel@tonic-gate pptr += sizeof (struct nd_opt_mtu);
2637c478bd9Sstevel@tonic-gate }
2647c478bd9Sstevel@tonic-gate
2657c478bd9Sstevel@tonic-gate if (no_prefixes) {
2667c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
2677c478bd9Sstevel@tonic-gate print_route_adv("Sending advert to ", pi,
2687c478bd9Sstevel@tonic-gate ra, packetlen, sin6);
2697c478bd9Sstevel@tonic-gate }
2707c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0);
2717c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */
2727c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen);
2737c478bd9Sstevel@tonic-gate return;
2747c478bd9Sstevel@tonic-gate }
2757c478bd9Sstevel@tonic-gate
2767c478bd9Sstevel@tonic-gate po = (struct nd_opt_prefix_info *)pptr;
2777c478bd9Sstevel@tonic-gate for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL;
2787c478bd9Sstevel@tonic-gate adv_pr = adv_pr->adv_pr_next) {
2797c478bd9Sstevel@tonic-gate if (!adv_pr->adv_pr_AdvOnLinkFlag &&
2807c478bd9Sstevel@tonic-gate !adv_pr->adv_pr_AdvAutonomousFlag) {
2817c478bd9Sstevel@tonic-gate continue;
2827c478bd9Sstevel@tonic-gate }
2837c478bd9Sstevel@tonic-gate
2847c478bd9Sstevel@tonic-gate /*
2857c478bd9Sstevel@tonic-gate * If the prefix doesn't fit in packet send
2867c478bd9Sstevel@tonic-gate * what we have so far and start with new packet.
2877c478bd9Sstevel@tonic-gate */
2887c478bd9Sstevel@tonic-gate if (packetlen + sizeof (*po) >
2897c478bd9Sstevel@tonic-gate pi->pi_LinkMTU - sizeof (struct ip6_hdr)) {
2907c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
2917c478bd9Sstevel@tonic-gate print_route_adv("Sending advert "
2927c478bd9Sstevel@tonic-gate "(FRAG) to ",
2937c478bd9Sstevel@tonic-gate pi, ra, packetlen, sin6);
2947c478bd9Sstevel@tonic-gate }
2957c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0);
2967c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */
2977c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen);
2987c478bd9Sstevel@tonic-gate packetlen = sizeof (*ra);
2997c478bd9Sstevel@tonic-gate pptr = (char *)packet + sizeof (*ra);
3007c478bd9Sstevel@tonic-gate po = (struct nd_opt_prefix_info *)pptr;
3017c478bd9Sstevel@tonic-gate }
3027c478bd9Sstevel@tonic-gate po->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
3037c478bd9Sstevel@tonic-gate po->nd_opt_pi_len = sizeof (*po)/8;
3047c478bd9Sstevel@tonic-gate po->nd_opt_pi_flags_reserved = 0;
3057c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvOnLinkFlag) {
3067c478bd9Sstevel@tonic-gate po->nd_opt_pi_flags_reserved |=
3077c478bd9Sstevel@tonic-gate ND_OPT_PI_FLAG_ONLINK;
3087c478bd9Sstevel@tonic-gate }
3097c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvAutonomousFlag) {
3107c478bd9Sstevel@tonic-gate po->nd_opt_pi_flags_reserved |=
3117c478bd9Sstevel@tonic-gate ND_OPT_PI_FLAG_AUTO;
3127c478bd9Sstevel@tonic-gate }
3137c478bd9Sstevel@tonic-gate po->nd_opt_pi_prefix_len = adv_pr->adv_pr_prefix_len;
3147c478bd9Sstevel@tonic-gate /*
3157c478bd9Sstevel@tonic-gate * If both Adv*Expiration and Adv*Lifetime are
3167c478bd9Sstevel@tonic-gate * set we prefer the former and make the lifetime
3177c478bd9Sstevel@tonic-gate * decrement in real time.
3187c478bd9Sstevel@tonic-gate */
3197c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvValidRealTime) {
3207c478bd9Sstevel@tonic-gate po->nd_opt_pi_valid_time =
3217c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvValidExpiration);
3227c478bd9Sstevel@tonic-gate } else {
3237c478bd9Sstevel@tonic-gate po->nd_opt_pi_valid_time =
3247c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvValidLifetime);
3257c478bd9Sstevel@tonic-gate }
3267c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvPreferredRealTime) {
3277c478bd9Sstevel@tonic-gate po->nd_opt_pi_preferred_time =
3287c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvPreferredExpiration);
3297c478bd9Sstevel@tonic-gate } else {
3307c478bd9Sstevel@tonic-gate po->nd_opt_pi_preferred_time =
3317c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvPreferredLifetime);
3327c478bd9Sstevel@tonic-gate }
3337c478bd9Sstevel@tonic-gate po->nd_opt_pi_reserved2 = htonl(0);
3347c478bd9Sstevel@tonic-gate po->nd_opt_pi_prefix = adv_pr->adv_pr_prefix;
3357c478bd9Sstevel@tonic-gate
3367c478bd9Sstevel@tonic-gate po++;
3377c478bd9Sstevel@tonic-gate packetlen += sizeof (*po);
3387c478bd9Sstevel@tonic-gate }
3397c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
3407c478bd9Sstevel@tonic-gate print_route_adv("Sending advert to ", pi,
3417c478bd9Sstevel@tonic-gate ra, packetlen, sin6);
3427c478bd9Sstevel@tonic-gate }
3437c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0);
3447c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */
3457c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen);
3467c478bd9Sstevel@tonic-gate }
3477c478bd9Sstevel@tonic-gate
3487c478bd9Sstevel@tonic-gate /* Poll support */
3497c478bd9Sstevel@tonic-gate static int pollfd_num = 0; /* Allocated and initialized */
3507c478bd9Sstevel@tonic-gate static struct pollfd *pollfds = NULL;
3517c478bd9Sstevel@tonic-gate
3527c478bd9Sstevel@tonic-gate /*
3537c478bd9Sstevel@tonic-gate * Add fd to the set being polled. Returns 0 if ok; -1 if failed.
3547c478bd9Sstevel@tonic-gate */
3557c478bd9Sstevel@tonic-gate int
poll_add(int fd)3567c478bd9Sstevel@tonic-gate poll_add(int fd)
3577c478bd9Sstevel@tonic-gate {
3587c478bd9Sstevel@tonic-gate int i;
3597c478bd9Sstevel@tonic-gate int new_num;
3607c478bd9Sstevel@tonic-gate struct pollfd *newfds;
3613173664eSapersson
3627c478bd9Sstevel@tonic-gate /* Check if already present */
3637c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) {
3647c478bd9Sstevel@tonic-gate if (pollfds[i].fd == fd)
3657c478bd9Sstevel@tonic-gate return (0);
3667c478bd9Sstevel@tonic-gate }
3677c478bd9Sstevel@tonic-gate /* Check for empty spot already present */
3687c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) {
3697c478bd9Sstevel@tonic-gate if (pollfds[i].fd == -1) {
3707c478bd9Sstevel@tonic-gate pollfds[i].fd = fd;
3717c478bd9Sstevel@tonic-gate return (0);
3727c478bd9Sstevel@tonic-gate }
3737c478bd9Sstevel@tonic-gate }
3747c478bd9Sstevel@tonic-gate
3757c478bd9Sstevel@tonic-gate /* Allocate space for 32 more fds and initialize to -1 */
3767c478bd9Sstevel@tonic-gate new_num = pollfd_num + 32;
3777c478bd9Sstevel@tonic-gate newfds = realloc(pollfds, new_num * sizeof (struct pollfd));
3787c478bd9Sstevel@tonic-gate if (newfds == NULL) {
3796e91bba0SGirish Moodalbail logperror("realloc");
3807c478bd9Sstevel@tonic-gate return (-1);
3817c478bd9Sstevel@tonic-gate }
3823173664eSapersson
3833173664eSapersson newfds[pollfd_num].fd = fd;
3843173664eSapersson newfds[pollfd_num++].events = POLLIN;
3853173664eSapersson
3867c478bd9Sstevel@tonic-gate for (i = pollfd_num; i < new_num; i++) {
3877c478bd9Sstevel@tonic-gate newfds[i].fd = -1;
3887c478bd9Sstevel@tonic-gate newfds[i].events = POLLIN;
3897c478bd9Sstevel@tonic-gate }
3907c478bd9Sstevel@tonic-gate pollfd_num = new_num;
3917c478bd9Sstevel@tonic-gate pollfds = newfds;
3923173664eSapersson return (0);
3937c478bd9Sstevel@tonic-gate }
3947c478bd9Sstevel@tonic-gate
3957c478bd9Sstevel@tonic-gate /*
3967c478bd9Sstevel@tonic-gate * Remove fd from the set being polled. Returns 0 if ok; -1 if failed.
3977c478bd9Sstevel@tonic-gate */
3987c478bd9Sstevel@tonic-gate int
poll_remove(int fd)3997c478bd9Sstevel@tonic-gate poll_remove(int fd)
4007c478bd9Sstevel@tonic-gate {
4017c478bd9Sstevel@tonic-gate int i;
4027c478bd9Sstevel@tonic-gate
4037c478bd9Sstevel@tonic-gate /* Check if already present */
4047c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) {
4057c478bd9Sstevel@tonic-gate if (pollfds[i].fd == fd) {
4067c478bd9Sstevel@tonic-gate pollfds[i].fd = -1;
4077c478bd9Sstevel@tonic-gate return (0);
4087c478bd9Sstevel@tonic-gate }
4097c478bd9Sstevel@tonic-gate }
4107c478bd9Sstevel@tonic-gate return (-1);
4117c478bd9Sstevel@tonic-gate }
4127c478bd9Sstevel@tonic-gate
4137c478bd9Sstevel@tonic-gate /*
4147c478bd9Sstevel@tonic-gate * Extract information about the ifname (either a physical interface and
4157c478bd9Sstevel@tonic-gate * the ":0" logical interface or just a logical interface).
4167c478bd9Sstevel@tonic-gate * If the interface (still) exists in kernel set pr_in_use
4177c478bd9Sstevel@tonic-gate * for caller to be able to detect interfaces that are removed.
4187c478bd9Sstevel@tonic-gate * Starts sending advertisements/solicitations when new physical interfaces
4197c478bd9Sstevel@tonic-gate * are detected.
4207c478bd9Sstevel@tonic-gate */
4217c478bd9Sstevel@tonic-gate static void
if_process(int s,char * ifname,boolean_t first)4227c478bd9Sstevel@tonic-gate if_process(int s, char *ifname, boolean_t first)
4237c478bd9Sstevel@tonic-gate {
4247c478bd9Sstevel@tonic-gate struct lifreq lifr;
4257c478bd9Sstevel@tonic-gate struct phyint *pi;
4267c478bd9Sstevel@tonic-gate struct prefix *pr;
4277c478bd9Sstevel@tonic-gate char *cp;
4287c478bd9Sstevel@tonic-gate char phyintname[LIFNAMSIZ + 1];
4297c478bd9Sstevel@tonic-gate
4307c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN)
4317c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "if_process(%s)\n", ifname);
4327c478bd9Sstevel@tonic-gate
4337c478bd9Sstevel@tonic-gate (void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
4347c478bd9Sstevel@tonic-gate lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0';
4357c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
4367c478bd9Sstevel@tonic-gate if (errno == ENXIO) {
4377c478bd9Sstevel@tonic-gate /*
4387c478bd9Sstevel@tonic-gate * Interface has disappeared
4397c478bd9Sstevel@tonic-gate */
4407c478bd9Sstevel@tonic-gate return;
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate logperror("if_process: ioctl (get interface flags)");
4437c478bd9Sstevel@tonic-gate return;
4447c478bd9Sstevel@tonic-gate }
4457c478bd9Sstevel@tonic-gate
4467c478bd9Sstevel@tonic-gate /*
4471cb875aeSCathy Zhou * Ignore loopback, point-to-multipoint and VRRP interfaces.
4481cb875aeSCathy Zhou * The IP addresses over VRRP interfaces cannot be auto-configured.
4497c478bd9Sstevel@tonic-gate * Point-to-point interfaces always have IFF_MULTICAST set.
4507c478bd9Sstevel@tonic-gate */
4517c478bd9Sstevel@tonic-gate if (!(lifr.lifr_flags & IFF_MULTICAST) ||
4521cb875aeSCathy Zhou (lifr.lifr_flags & (IFF_LOOPBACK|IFF_VRRP))) {
4537c478bd9Sstevel@tonic-gate return;
4547c478bd9Sstevel@tonic-gate }
4557c478bd9Sstevel@tonic-gate
4567c478bd9Sstevel@tonic-gate if (!(lifr.lifr_flags & IFF_IPV6))
4577c478bd9Sstevel@tonic-gate return;
4587c478bd9Sstevel@tonic-gate
4597c478bd9Sstevel@tonic-gate (void) strncpy(phyintname, ifname, sizeof (phyintname));
4607c478bd9Sstevel@tonic-gate phyintname[sizeof (phyintname) - 1] = '\0';
4617c478bd9Sstevel@tonic-gate if ((cp = strchr(phyintname, IF_SEPARATOR)) != NULL) {
4627c478bd9Sstevel@tonic-gate *cp = '\0';
4637c478bd9Sstevel@tonic-gate }
4647c478bd9Sstevel@tonic-gate
4657c478bd9Sstevel@tonic-gate pi = phyint_lookup(phyintname);
4667c478bd9Sstevel@tonic-gate if (pi == NULL) {
4677c478bd9Sstevel@tonic-gate pi = phyint_create(phyintname);
4687c478bd9Sstevel@tonic-gate if (pi == NULL) {
4697c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "if_process: out of memory\n");
4707c478bd9Sstevel@tonic-gate return;
4717c478bd9Sstevel@tonic-gate }
4726e91bba0SGirish Moodalbail /*
4736e91bba0SGirish Moodalbail * if in.ndpd is restarted, check with ipmgmtd if there is any
4746e91bba0SGirish Moodalbail * interface id to be configured for this interface.
4756e91bba0SGirish Moodalbail */
4766e91bba0SGirish Moodalbail if (first) {
4776e91bba0SGirish Moodalbail if (phyint_check_ipadm_intfid(pi) == -1)
4786e91bba0SGirish Moodalbail logmsg(LOG_ERR, "Could not get ipadm info\n");
4796e91bba0SGirish Moodalbail }
4806e91bba0SGirish Moodalbail } else {
4816e91bba0SGirish Moodalbail /*
4826e91bba0SGirish Moodalbail * if the phyint already exists, synchronize it with
4836e91bba0SGirish Moodalbail * the kernel state. For a newly created phyint, phyint_create
4846e91bba0SGirish Moodalbail * calls phyint_init_from_k().
4856e91bba0SGirish Moodalbail */
4866e91bba0SGirish Moodalbail (void) phyint_init_from_k(pi);
4877c478bd9Sstevel@tonic-gate }
4887c478bd9Sstevel@tonic-gate if (pi->pi_sock == -1 && !(pi->pi_kernel_state & PI_PRESENT)) {
4897c478bd9Sstevel@tonic-gate /* Interface is not yet present */
4907c478bd9Sstevel@tonic-gate if (debug & D_PHYINT) {
4917c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "if_process: interface not yet "
4927c478bd9Sstevel@tonic-gate "present %s\n", pi->pi_name);
4937c478bd9Sstevel@tonic-gate }
4947c478bd9Sstevel@tonic-gate return;
4957c478bd9Sstevel@tonic-gate }
4967c478bd9Sstevel@tonic-gate
4977c478bd9Sstevel@tonic-gate if (pi->pi_sock != -1) {
4987c478bd9Sstevel@tonic-gate if (poll_add(pi->pi_sock) == -1) {
4997c478bd9Sstevel@tonic-gate /*
5007c478bd9Sstevel@tonic-gate * reset state.
5017c478bd9Sstevel@tonic-gate */
5027c478bd9Sstevel@tonic-gate phyint_cleanup(pi);
5037c478bd9Sstevel@tonic-gate }
5047c478bd9Sstevel@tonic-gate }
5057c478bd9Sstevel@tonic-gate
5067c478bd9Sstevel@tonic-gate /*
5077c478bd9Sstevel@tonic-gate * Check if IFF_ROUTER has been turned off in kernel in which
5087c478bd9Sstevel@tonic-gate * case we have to turn off AdvSendAdvertisements.
5097c478bd9Sstevel@tonic-gate * The kernel will automatically turn off IFF_ROUTER if
5107c478bd9Sstevel@tonic-gate * ip6_forwarding is turned off.
5117c478bd9Sstevel@tonic-gate * Note that we do not switch back should IFF_ROUTER be turned on.
5127c478bd9Sstevel@tonic-gate */
5137c478bd9Sstevel@tonic-gate if (!first &&
5147c478bd9Sstevel@tonic-gate pi->pi_AdvSendAdvertisements && !(pi->pi_flags & IFF_ROUTER)) {
5157c478bd9Sstevel@tonic-gate logmsg(LOG_INFO, "No longer a router on %s\n", pi->pi_name);
5167c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_FINAL_ADV);
5177c478bd9Sstevel@tonic-gate
5187c478bd9Sstevel@tonic-gate pi->pi_AdvSendAdvertisements = 0;
5197c478bd9Sstevel@tonic-gate pi->pi_sol_state = NO_SOLICIT;
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate
5227c478bd9Sstevel@tonic-gate /*
5237c478bd9Sstevel@tonic-gate * Send advertisments and solicitation only if the interface is
5247c478bd9Sstevel@tonic-gate * present in the kernel.
5257c478bd9Sstevel@tonic-gate */
5267c478bd9Sstevel@tonic-gate if (pi->pi_kernel_state & PI_PRESENT) {
5277c478bd9Sstevel@tonic-gate
5287c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements) {
5297c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV)
5307c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_INIT_ADV);
5317c478bd9Sstevel@tonic-gate } else {
5327c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == NO_SOLICIT)
5337c478bd9Sstevel@tonic-gate check_to_solicit(pi, START_INIT_SOLICIT);
5347c478bd9Sstevel@tonic-gate }
5357c478bd9Sstevel@tonic-gate }
5367c478bd9Sstevel@tonic-gate
5377c478bd9Sstevel@tonic-gate /*
5387c478bd9Sstevel@tonic-gate * Track static kernel prefixes to prevent in.ndpd from clobbering
5397c478bd9Sstevel@tonic-gate * them by creating a struct prefix for each prefix detected in the
5407c478bd9Sstevel@tonic-gate * kernel.
5417c478bd9Sstevel@tonic-gate */
5427c478bd9Sstevel@tonic-gate pr = prefix_lookup_name(pi, ifname);
5437c478bd9Sstevel@tonic-gate if (pr == NULL) {
5447c478bd9Sstevel@tonic-gate pr = prefix_create_name(pi, ifname);
5457c478bd9Sstevel@tonic-gate if (pr == NULL) {
5467c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "if_process: out of memory\n");
5477c478bd9Sstevel@tonic-gate return;
5487c478bd9Sstevel@tonic-gate }
5497c478bd9Sstevel@tonic-gate if (prefix_init_from_k(pr) == -1) {
5507c478bd9Sstevel@tonic-gate prefix_delete(pr);
5517c478bd9Sstevel@tonic-gate return;
5527c478bd9Sstevel@tonic-gate }
5537c478bd9Sstevel@tonic-gate }
5547c478bd9Sstevel@tonic-gate /* Detect prefixes which are removed */
5557c478bd9Sstevel@tonic-gate if (pr->pr_kernel_state != 0)
5567c478bd9Sstevel@tonic-gate pr->pr_in_use = _B_TRUE;
55769bb4bb4Scarlsonj
55869bb4bb4Scarlsonj if ((lifr.lifr_flags & IFF_DUPLICATE) &&
559d04ccbb3Scarlsonj !(lifr.lifr_flags & IFF_DHCPRUNNING) &&
56069bb4bb4Scarlsonj (pr->pr_flags & IFF_TEMPORARY)) {
56169bb4bb4Scarlsonj in6_addr_t *token;
56269bb4bb4Scarlsonj int i;
56369bb4bb4Scarlsonj char abuf[INET6_ADDRSTRLEN];
56469bb4bb4Scarlsonj
56569bb4bb4Scarlsonj if (++pr->pr_attempts >= MAX_DAD_FAILURES) {
56669bb4bb4Scarlsonj logmsg(LOG_ERR, "%s: token %s is duplicate after %d "
56769bb4bb4Scarlsonj "attempts; disabling temporary addresses on %s",
56869bb4bb4Scarlsonj pr->pr_name, inet_ntop(AF_INET6,
56969bb4bb4Scarlsonj (void *)&pi->pi_tmp_token, abuf, sizeof (abuf)),
57069bb4bb4Scarlsonj pr->pr_attempts, pi->pi_name);
57169bb4bb4Scarlsonj pi->pi_TmpAddrsEnabled = 0;
57269bb4bb4Scarlsonj tmptoken_delete(pi);
57369bb4bb4Scarlsonj prefix_delete(pr);
57469bb4bb4Scarlsonj return;
57569bb4bb4Scarlsonj }
57669bb4bb4Scarlsonj logmsg(LOG_WARNING, "%s: token %s is duplicate; trying again",
57769bb4bb4Scarlsonj pr->pr_name, inet_ntop(AF_INET6, (void *)&pi->pi_tmp_token,
57869bb4bb4Scarlsonj abuf, sizeof (abuf)));
57969bb4bb4Scarlsonj if (!tmptoken_create(pi)) {
58069bb4bb4Scarlsonj prefix_delete(pr);
58169bb4bb4Scarlsonj return;
58269bb4bb4Scarlsonj }
58369bb4bb4Scarlsonj token = &pi->pi_tmp_token;
58469bb4bb4Scarlsonj for (i = 0; i < 16; i++) {
58569bb4bb4Scarlsonj /*
58669bb4bb4Scarlsonj * prefix_create ensures that pr_prefix has all-zero
58769bb4bb4Scarlsonj * bits after prefixlen.
58869bb4bb4Scarlsonj */
58969bb4bb4Scarlsonj pr->pr_address.s6_addr[i] = pr->pr_prefix.s6_addr[i] |
59069bb4bb4Scarlsonj token->s6_addr[i];
59169bb4bb4Scarlsonj }
59269bb4bb4Scarlsonj if (prefix_lookup_addr_match(pr) != NULL) {
59369bb4bb4Scarlsonj prefix_delete(pr);
59469bb4bb4Scarlsonj return;
59569bb4bb4Scarlsonj }
59669bb4bb4Scarlsonj pr->pr_CreateTime = getcurrenttime() / MILLISEC;
59769bb4bb4Scarlsonj /*
59869bb4bb4Scarlsonj * We've got a new token. Clearing PR_AUTO causes
59969bb4bb4Scarlsonj * prefix_update_k to bring the interface up and set the
60069bb4bb4Scarlsonj * address.
60169bb4bb4Scarlsonj */
60269bb4bb4Scarlsonj pr->pr_kernel_state &= ~PR_AUTO;
60369bb4bb4Scarlsonj prefix_update_k(pr);
60469bb4bb4Scarlsonj }
6057c478bd9Sstevel@tonic-gate }
6067c478bd9Sstevel@tonic-gate
6077c478bd9Sstevel@tonic-gate static int ifsock = -1;
6087c478bd9Sstevel@tonic-gate
6097c478bd9Sstevel@tonic-gate /*
6107c478bd9Sstevel@tonic-gate * Scan all interfaces to detect changes as well as new and deleted intefaces
6117c478bd9Sstevel@tonic-gate * 'first' is set for the initial call only. Do not effect anything.
6127c478bd9Sstevel@tonic-gate */
6137c478bd9Sstevel@tonic-gate static void
initifs(boolean_t first)6147c478bd9Sstevel@tonic-gate initifs(boolean_t first)
6157c478bd9Sstevel@tonic-gate {
6167c478bd9Sstevel@tonic-gate char *buf;
6177c478bd9Sstevel@tonic-gate int bufsize;
6187c478bd9Sstevel@tonic-gate int numifs;
6197c478bd9Sstevel@tonic-gate int n;
6207c478bd9Sstevel@tonic-gate struct lifnum lifn;
6217c478bd9Sstevel@tonic-gate struct lifconf lifc;
6227c478bd9Sstevel@tonic-gate struct lifreq *lifr;
6237c478bd9Sstevel@tonic-gate struct phyint *pi;
6247c478bd9Sstevel@tonic-gate struct phyint *next_pi;
6257c478bd9Sstevel@tonic-gate struct prefix *pr;
6267c478bd9Sstevel@tonic-gate
6277c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN)
6287c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Reading interface configuration\n");
6297c478bd9Sstevel@tonic-gate if (ifsock < 0) {
6307c478bd9Sstevel@tonic-gate ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
6317c478bd9Sstevel@tonic-gate if (ifsock < 0) {
6327c478bd9Sstevel@tonic-gate logperror("initifs: socket");
6337c478bd9Sstevel@tonic-gate return;
6347c478bd9Sstevel@tonic-gate }
6357c478bd9Sstevel@tonic-gate }
6367c478bd9Sstevel@tonic-gate lifn.lifn_family = AF_INET6;
6377c478bd9Sstevel@tonic-gate lifn.lifn_flags = LIFC_NOXMIT | LIFC_TEMPORARY;
6387c478bd9Sstevel@tonic-gate if (ioctl(ifsock, SIOCGLIFNUM, (char *)&lifn) < 0) {
6397c478bd9Sstevel@tonic-gate logperror("initifs: ioctl (get interface numbers)");
6407c478bd9Sstevel@tonic-gate return;
6417c478bd9Sstevel@tonic-gate }
6427c478bd9Sstevel@tonic-gate numifs = lifn.lifn_count;
6437c478bd9Sstevel@tonic-gate bufsize = numifs * sizeof (struct lifreq);
6447c478bd9Sstevel@tonic-gate
6457c478bd9Sstevel@tonic-gate buf = (char *)malloc(bufsize);
6467c478bd9Sstevel@tonic-gate if (buf == NULL) {
6477c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "initifs: out of memory\n");
6487c478bd9Sstevel@tonic-gate return;
6497c478bd9Sstevel@tonic-gate }
6507c478bd9Sstevel@tonic-gate
6517c478bd9Sstevel@tonic-gate /*
6527c478bd9Sstevel@tonic-gate * Mark the interfaces so that we can find phyints and prefixes
6537c478bd9Sstevel@tonic-gate * which have disappeared from the kernel.
6547c478bd9Sstevel@tonic-gate * if_process will set pr_in_use when it finds the interface
6557c478bd9Sstevel@tonic-gate * in the kernel.
6567c478bd9Sstevel@tonic-gate */
6577c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) {
6587c478bd9Sstevel@tonic-gate /*
6597c478bd9Sstevel@tonic-gate * Before re-examining the state of the interfaces,
6607c478bd9Sstevel@tonic-gate * PI_PRESENT should be cleared from pi_kernel_state.
6617c478bd9Sstevel@tonic-gate */
6627c478bd9Sstevel@tonic-gate pi->pi_kernel_state &= ~PI_PRESENT;
6637c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) {
6647c478bd9Sstevel@tonic-gate pr->pr_in_use = _B_FALSE;
6657c478bd9Sstevel@tonic-gate }
6667c478bd9Sstevel@tonic-gate }
6677c478bd9Sstevel@tonic-gate
6687c478bd9Sstevel@tonic-gate lifc.lifc_family = AF_INET6;
6697c478bd9Sstevel@tonic-gate lifc.lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY;
6707c478bd9Sstevel@tonic-gate lifc.lifc_len = bufsize;
6717c478bd9Sstevel@tonic-gate lifc.lifc_buf = buf;
6727c478bd9Sstevel@tonic-gate
6737c478bd9Sstevel@tonic-gate if (ioctl(ifsock, SIOCGLIFCONF, (char *)&lifc) < 0) {
6747c478bd9Sstevel@tonic-gate logperror("initifs: ioctl (get interface configuration)");
6757c478bd9Sstevel@tonic-gate free(buf);
6767c478bd9Sstevel@tonic-gate return;
6777c478bd9Sstevel@tonic-gate }
6787c478bd9Sstevel@tonic-gate
6797c478bd9Sstevel@tonic-gate lifr = (struct lifreq *)lifc.lifc_req;
6807c478bd9Sstevel@tonic-gate for (n = lifc.lifc_len / sizeof (struct lifreq); n > 0; n--, lifr++)
6817c478bd9Sstevel@tonic-gate if_process(ifsock, lifr->lifr_name, first);
6827c478bd9Sstevel@tonic-gate free(buf);
6837c478bd9Sstevel@tonic-gate
6847c478bd9Sstevel@tonic-gate /*
6857c478bd9Sstevel@tonic-gate * Detect phyints that have been removed from the kernel.
6867c478bd9Sstevel@tonic-gate * Since we can't recreate it here (would require ifconfig plumb
6877c478bd9Sstevel@tonic-gate * logic) we just terminate use of that phyint.
6887c478bd9Sstevel@tonic-gate */
6897c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) {
6907c478bd9Sstevel@tonic-gate next_pi = pi->pi_next;
6917c478bd9Sstevel@tonic-gate /*
6927c478bd9Sstevel@tonic-gate * If interface (still) exists in kernel, set
6937c478bd9Sstevel@tonic-gate * pi_state to indicate that.
6947c478bd9Sstevel@tonic-gate */
6957c478bd9Sstevel@tonic-gate if (pi->pi_kernel_state & PI_PRESENT) {
6967c478bd9Sstevel@tonic-gate pi->pi_state |= PI_PRESENT;
6977c478bd9Sstevel@tonic-gate }
6987c478bd9Sstevel@tonic-gate
6997c478bd9Sstevel@tonic-gate check_if_removed(pi);
7007c478bd9Sstevel@tonic-gate }
7017c478bd9Sstevel@tonic-gate if (show_ifs)
7027c478bd9Sstevel@tonic-gate phyint_print_all();
7037c478bd9Sstevel@tonic-gate }
7047c478bd9Sstevel@tonic-gate
7057c478bd9Sstevel@tonic-gate
7067c478bd9Sstevel@tonic-gate /*
7077c478bd9Sstevel@tonic-gate * Router advertisement state machine. Used for everything but timer
7087c478bd9Sstevel@tonic-gate * events which use advertise_event directly.
7097c478bd9Sstevel@tonic-gate */
7107c478bd9Sstevel@tonic-gate void
check_to_advertise(struct phyint * pi,enum adv_events event)7117c478bd9Sstevel@tonic-gate check_to_advertise(struct phyint *pi, enum adv_events event)
7127c478bd9Sstevel@tonic-gate {
7137c478bd9Sstevel@tonic-gate uint_t delay;
7147c478bd9Sstevel@tonic-gate enum adv_states old_state = pi->pi_adv_state;
7157c478bd9Sstevel@tonic-gate
7167c478bd9Sstevel@tonic-gate if (debug & D_STATE) {
7177c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_advertise(%s, %d) state %d\n",
7187c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state);
7197c478bd9Sstevel@tonic-gate }
7207c478bd9Sstevel@tonic-gate delay = advertise_event(pi, event, 0);
7217c478bd9Sstevel@tonic-gate if (delay != TIMER_INFINITY) {
7227c478bd9Sstevel@tonic-gate /* Make sure the global next event is updated */
7237c478bd9Sstevel@tonic-gate timer_schedule(delay);
7247c478bd9Sstevel@tonic-gate }
7257c478bd9Sstevel@tonic-gate
7267c478bd9Sstevel@tonic-gate if (debug & D_STATE) {
7277c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_advertise(%s, %d) state %d -> %d\n",
7287c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state,
7297c478bd9Sstevel@tonic-gate (int)pi->pi_adv_state);
7307c478bd9Sstevel@tonic-gate }
7317c478bd9Sstevel@tonic-gate }
7327c478bd9Sstevel@tonic-gate
7337c478bd9Sstevel@tonic-gate /*
7347c478bd9Sstevel@tonic-gate * Router advertisement state machine.
7357c478bd9Sstevel@tonic-gate * Return the number of milliseconds until next timeout (TIMER_INFINITY
7367c478bd9Sstevel@tonic-gate * if never).
7377c478bd9Sstevel@tonic-gate * For the ADV_TIMER event the caller passes in the number of milliseconds
7387c478bd9Sstevel@tonic-gate * since the last timer event in the 'elapsed' parameter.
7397c478bd9Sstevel@tonic-gate */
7407c478bd9Sstevel@tonic-gate uint_t
advertise_event(struct phyint * pi,enum adv_events event,uint_t elapsed)7417c478bd9Sstevel@tonic-gate advertise_event(struct phyint *pi, enum adv_events event, uint_t elapsed)
7427c478bd9Sstevel@tonic-gate {
7437c478bd9Sstevel@tonic-gate uint_t delay;
7447c478bd9Sstevel@tonic-gate
7457c478bd9Sstevel@tonic-gate if (debug & D_STATE) {
7467c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "advertise_event(%s, %d, %d) state %d\n",
7477c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, elapsed, (int)pi->pi_adv_state);
7487c478bd9Sstevel@tonic-gate }
7497c478bd9Sstevel@tonic-gate check_daemonize();
7507c478bd9Sstevel@tonic-gate if (!pi->pi_AdvSendAdvertisements)
7517c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
7527c478bd9Sstevel@tonic-gate if (pi->pi_flags & IFF_NORTEXCH) {
7537c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
7547c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Suppress sending RA packet on %s "
7557c478bd9Sstevel@tonic-gate "(no route exchange on interface)\n",
7567c478bd9Sstevel@tonic-gate pi->pi_name);
7577c478bd9Sstevel@tonic-gate }
7587c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
7597c478bd9Sstevel@tonic-gate }
7607c478bd9Sstevel@tonic-gate
7617c478bd9Sstevel@tonic-gate switch (event) {
7627c478bd9Sstevel@tonic-gate case ADV_OFF:
7637c478bd9Sstevel@tonic-gate pi->pi_adv_state = NO_ADV;
7647c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
7657c478bd9Sstevel@tonic-gate
7667c478bd9Sstevel@tonic-gate case START_INIT_ADV:
7677c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == INIT_ADV)
7687c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left);
7697c478bd9Sstevel@tonic-gate pi->pi_adv_count = ND_MAX_INITIAL_RTR_ADVERTISEMENTS;
7707c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 0;
7717c478bd9Sstevel@tonic-gate pi->pi_adv_state = INIT_ADV;
7727c478bd9Sstevel@tonic-gate break; /* send advertisement */
7737c478bd9Sstevel@tonic-gate
7747c478bd9Sstevel@tonic-gate case START_FINAL_ADV:
7757c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV)
7767c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
7777c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV)
7787c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left);
7797c478bd9Sstevel@tonic-gate pi->pi_adv_count = ND_MAX_FINAL_RTR_ADVERTISEMENTS;
7807c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 0;
7817c478bd9Sstevel@tonic-gate pi->pi_adv_state = FINAL_ADV;
7827c478bd9Sstevel@tonic-gate break; /* send advertisement */
7837c478bd9Sstevel@tonic-gate
7847c478bd9Sstevel@tonic-gate case RECEIVED_SOLICIT:
7857c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV)
7867c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
7877c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == SOLICIT_ADV) {
7887c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_left != 0)
7897c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left);
7907c478bd9Sstevel@tonic-gate break;
7917c478bd9Sstevel@tonic-gate }
7927c478bd9Sstevel@tonic-gate delay = GET_RANDOM(0, ND_MAX_RA_DELAY_TIME);
7937c478bd9Sstevel@tonic-gate if (delay < pi->pi_adv_time_left)
7947c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = delay;
7957c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_since_sent < ND_MIN_DELAY_BETWEEN_RAS) {
7967c478bd9Sstevel@tonic-gate /*
7977c478bd9Sstevel@tonic-gate * Send an advertisement (ND_MIN_DELAY_BETWEEN_RAS
7987c478bd9Sstevel@tonic-gate * plus random delay) after the previous
7997c478bd9Sstevel@tonic-gate * advertisement was sent.
8007c478bd9Sstevel@tonic-gate */
8017c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = delay +
8027c478bd9Sstevel@tonic-gate ND_MIN_DELAY_BETWEEN_RAS -
8037c478bd9Sstevel@tonic-gate pi->pi_adv_time_since_sent;
8047c478bd9Sstevel@tonic-gate }
8057c478bd9Sstevel@tonic-gate pi->pi_adv_state = SOLICIT_ADV;
8067c478bd9Sstevel@tonic-gate break;
8077c478bd9Sstevel@tonic-gate
8087c478bd9Sstevel@tonic-gate case ADV_TIMER:
8097c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV)
8107c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
8117c478bd9Sstevel@tonic-gate /* Decrease time left */
8127c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_left >= elapsed)
8137c478bd9Sstevel@tonic-gate pi->pi_adv_time_left -= elapsed;
8147c478bd9Sstevel@tonic-gate else
8157c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 0;
8167c478bd9Sstevel@tonic-gate
8177c478bd9Sstevel@tonic-gate /* Increase time since last advertisement was sent */
8187c478bd9Sstevel@tonic-gate pi->pi_adv_time_since_sent += elapsed;
8197c478bd9Sstevel@tonic-gate break;
8207c478bd9Sstevel@tonic-gate default:
8217c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "advertise_event: Unknown event %d\n",
8227c478bd9Sstevel@tonic-gate (int)event);
8237c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
8247c478bd9Sstevel@tonic-gate }
8257c478bd9Sstevel@tonic-gate
8267c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_left != 0)
8277c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left);
8287c478bd9Sstevel@tonic-gate
8297c478bd9Sstevel@tonic-gate /* Send advertisement and calculate next time to send */
8307c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV) {
8317c478bd9Sstevel@tonic-gate /* Omit the prefixes */
8327c478bd9Sstevel@tonic-gate advertise(&v6allnodes, pi, _B_TRUE);
8337c478bd9Sstevel@tonic-gate } else {
8347c478bd9Sstevel@tonic-gate advertise(&v6allnodes, pi, _B_FALSE);
8357c478bd9Sstevel@tonic-gate }
8367c478bd9Sstevel@tonic-gate pi->pi_adv_time_since_sent = 0;
8377c478bd9Sstevel@tonic-gate
8387c478bd9Sstevel@tonic-gate switch (pi->pi_adv_state) {
8397c478bd9Sstevel@tonic-gate case SOLICIT_ADV:
8407c478bd9Sstevel@tonic-gate /*
8417c478bd9Sstevel@tonic-gate * The solicited advertisement has been sent.
8427c478bd9Sstevel@tonic-gate * Revert to periodic advertisements.
8437c478bd9Sstevel@tonic-gate */
8447c478bd9Sstevel@tonic-gate pi->pi_adv_state = REG_ADV;
8457c478bd9Sstevel@tonic-gate /* FALLTHRU */
8467c478bd9Sstevel@tonic-gate case REG_ADV:
8477c478bd9Sstevel@tonic-gate pi->pi_adv_time_left =
8487c478bd9Sstevel@tonic-gate GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval,
8497c478bd9Sstevel@tonic-gate 1000 * pi->pi_MaxRtrAdvInterval);
8507c478bd9Sstevel@tonic-gate break;
8517c478bd9Sstevel@tonic-gate
8527c478bd9Sstevel@tonic-gate case INIT_ADV:
8537c478bd9Sstevel@tonic-gate if (--pi->pi_adv_count > 0) {
8547c478bd9Sstevel@tonic-gate delay = GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval,
8557c478bd9Sstevel@tonic-gate 1000 * pi->pi_MaxRtrAdvInterval);
8567c478bd9Sstevel@tonic-gate if (delay > ND_MAX_INITIAL_RTR_ADVERT_INTERVAL)
8577c478bd9Sstevel@tonic-gate delay = ND_MAX_INITIAL_RTR_ADVERT_INTERVAL;
8587c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = delay;
8597c478bd9Sstevel@tonic-gate } else {
8607c478bd9Sstevel@tonic-gate pi->pi_adv_time_left =
8617c478bd9Sstevel@tonic-gate GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval,
8627c478bd9Sstevel@tonic-gate 1000 * pi->pi_MaxRtrAdvInterval);
8637c478bd9Sstevel@tonic-gate pi->pi_adv_state = REG_ADV;
8647c478bd9Sstevel@tonic-gate }
8657c478bd9Sstevel@tonic-gate break;
8667c478bd9Sstevel@tonic-gate
8677c478bd9Sstevel@tonic-gate case FINAL_ADV:
8687c478bd9Sstevel@tonic-gate if (--pi->pi_adv_count > 0) {
8697c478bd9Sstevel@tonic-gate pi->pi_adv_time_left =
8707c478bd9Sstevel@tonic-gate ND_MAX_INITIAL_RTR_ADVERT_INTERVAL;
8717c478bd9Sstevel@tonic-gate } else {
8727c478bd9Sstevel@tonic-gate pi->pi_adv_state = NO_ADV;
8737c478bd9Sstevel@tonic-gate }
8747c478bd9Sstevel@tonic-gate break;
8757c478bd9Sstevel@tonic-gate }
8767c478bd9Sstevel@tonic-gate if (pi->pi_adv_state != NO_ADV)
8777c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left);
8787c478bd9Sstevel@tonic-gate else
8797c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
8807c478bd9Sstevel@tonic-gate }
8817c478bd9Sstevel@tonic-gate
8827c478bd9Sstevel@tonic-gate /*
8837c478bd9Sstevel@tonic-gate * Router solicitation state machine. Used for everything but timer
8847c478bd9Sstevel@tonic-gate * events which use solicit_event directly.
8857c478bd9Sstevel@tonic-gate */
8867c478bd9Sstevel@tonic-gate void
check_to_solicit(struct phyint * pi,enum solicit_events event)8877c478bd9Sstevel@tonic-gate check_to_solicit(struct phyint *pi, enum solicit_events event)
8887c478bd9Sstevel@tonic-gate {
8897c478bd9Sstevel@tonic-gate uint_t delay;
8907c478bd9Sstevel@tonic-gate enum solicit_states old_state = pi->pi_sol_state;
8917c478bd9Sstevel@tonic-gate
8927c478bd9Sstevel@tonic-gate if (debug & D_STATE) {
8937c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_solicit(%s, %d) state %d\n",
8947c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state);
8957c478bd9Sstevel@tonic-gate }
8967c478bd9Sstevel@tonic-gate delay = solicit_event(pi, event, 0);
8977c478bd9Sstevel@tonic-gate if (delay != TIMER_INFINITY) {
8987c478bd9Sstevel@tonic-gate /* Make sure the global next event is updated */
8997c478bd9Sstevel@tonic-gate timer_schedule(delay);
9007c478bd9Sstevel@tonic-gate }
9017c478bd9Sstevel@tonic-gate
9027c478bd9Sstevel@tonic-gate if (debug & D_STATE) {
9037c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_solicit(%s, %d) state %d -> %d\n",
9047c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state,
9057c478bd9Sstevel@tonic-gate (int)pi->pi_sol_state);
9067c478bd9Sstevel@tonic-gate }
9077c478bd9Sstevel@tonic-gate }
9087c478bd9Sstevel@tonic-gate
9097c478bd9Sstevel@tonic-gate static void
daemonize_ndpd(void)9107c478bd9Sstevel@tonic-gate daemonize_ndpd(void)
9117c478bd9Sstevel@tonic-gate {
9127c478bd9Sstevel@tonic-gate struct itimerval it;
9137c478bd9Sstevel@tonic-gate boolean_t timerval = _B_TRUE;
9147c478bd9Sstevel@tonic-gate
9157c478bd9Sstevel@tonic-gate /*
9167c478bd9Sstevel@tonic-gate * Need to get current timer settings so they can be restored
9177c478bd9Sstevel@tonic-gate * after the fork(), as the it_value and it_interval values for
9187c478bd9Sstevel@tonic-gate * the ITIMER_REAL timer are reset to 0 in the child process.
9197c478bd9Sstevel@tonic-gate */
9207c478bd9Sstevel@tonic-gate if (getitimer(ITIMER_REAL, &it) < 0) {
9217c478bd9Sstevel@tonic-gate if (debug & D_TIMER)
9227c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG,
9237c478bd9Sstevel@tonic-gate "daemonize_ndpd: failed to get itimerval\n");
9247c478bd9Sstevel@tonic-gate timerval = _B_FALSE;
9257c478bd9Sstevel@tonic-gate }
9267c478bd9Sstevel@tonic-gate
9277c478bd9Sstevel@tonic-gate /* Daemonize. */
928176dc728SDavid Höppner if (daemon(0, 0) == -1) {
9297c478bd9Sstevel@tonic-gate logperror("fork");
9307c478bd9Sstevel@tonic-gate exit(1);
9317c478bd9Sstevel@tonic-gate }
9327c478bd9Sstevel@tonic-gate
9337c478bd9Sstevel@tonic-gate already_daemonized = _B_TRUE;
9347c478bd9Sstevel@tonic-gate
9357c478bd9Sstevel@tonic-gate /*
9367c478bd9Sstevel@tonic-gate * Restore timer values, if we were able to save them; if not,
9377c478bd9Sstevel@tonic-gate * check and set the right value by calling run_timeouts().
9387c478bd9Sstevel@tonic-gate */
9397c478bd9Sstevel@tonic-gate if (timerval) {
9407c478bd9Sstevel@tonic-gate if (setitimer(ITIMER_REAL, &it, NULL) < 0) {
9417c478bd9Sstevel@tonic-gate logperror("daemonize_ndpd: setitimer");
9427c478bd9Sstevel@tonic-gate exit(2);
9437c478bd9Sstevel@tonic-gate }
9447c478bd9Sstevel@tonic-gate } else {
9457c478bd9Sstevel@tonic-gate run_timeouts();
9467c478bd9Sstevel@tonic-gate }
9477c478bd9Sstevel@tonic-gate }
9487c478bd9Sstevel@tonic-gate
9497c478bd9Sstevel@tonic-gate /*
9507c478bd9Sstevel@tonic-gate * Check to see if the time is right to daemonize. The right time is when:
9517c478bd9Sstevel@tonic-gate *
9527c478bd9Sstevel@tonic-gate * 1. We haven't already daemonized.
9537c478bd9Sstevel@tonic-gate * 2. We are not in debug mode.
9547c478bd9Sstevel@tonic-gate * 3. All interfaces are marked IFF_NOXMIT.
9557c478bd9Sstevel@tonic-gate * 4. All non-router interfaces have their prefixes set up and we're
9567c478bd9Sstevel@tonic-gate * done sending router solicitations on those interfaces without
9577c478bd9Sstevel@tonic-gate * prefixes.
9587c478bd9Sstevel@tonic-gate */
9597c478bd9Sstevel@tonic-gate static void
check_daemonize(void)9607c478bd9Sstevel@tonic-gate check_daemonize(void)
9617c478bd9Sstevel@tonic-gate {
9627c478bd9Sstevel@tonic-gate struct phyint *pi;
9637c478bd9Sstevel@tonic-gate
9647c478bd9Sstevel@tonic-gate if (already_daemonized || debug != 0)
9657c478bd9Sstevel@tonic-gate return;
9667c478bd9Sstevel@tonic-gate
9677c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) {
9687c478bd9Sstevel@tonic-gate if (!(pi->pi_flags & IFF_NOXMIT))
9697c478bd9Sstevel@tonic-gate break;
9707c478bd9Sstevel@tonic-gate }
9717c478bd9Sstevel@tonic-gate
9727c478bd9Sstevel@tonic-gate /*
9737c478bd9Sstevel@tonic-gate * If we can't transmit on any of the interfaces there is no reason
9747c478bd9Sstevel@tonic-gate * to hold up progress.
9757c478bd9Sstevel@tonic-gate */
9767c478bd9Sstevel@tonic-gate if (pi == NULL) {
9777c478bd9Sstevel@tonic-gate daemonize_ndpd();
9787c478bd9Sstevel@tonic-gate return;
9797c478bd9Sstevel@tonic-gate }
9807c478bd9Sstevel@tonic-gate
9817c478bd9Sstevel@tonic-gate /* Check all interfaces. If any are still soliciting, just return. */
9827c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) {
9837c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements ||
9847c478bd9Sstevel@tonic-gate !(pi->pi_kernel_state & PI_PRESENT))
9857c478bd9Sstevel@tonic-gate continue;
9867c478bd9Sstevel@tonic-gate
9877c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == INIT_SOLICIT)
9887c478bd9Sstevel@tonic-gate return;
9897c478bd9Sstevel@tonic-gate }
9907c478bd9Sstevel@tonic-gate
9917c478bd9Sstevel@tonic-gate daemonize_ndpd();
9927c478bd9Sstevel@tonic-gate }
9937c478bd9Sstevel@tonic-gate
9947c478bd9Sstevel@tonic-gate /*
9957c478bd9Sstevel@tonic-gate * Router solicitation state machine.
9967c478bd9Sstevel@tonic-gate * Return the number of milliseconds until next timeout (TIMER_INFINITY
9977c478bd9Sstevel@tonic-gate * if never).
9987c478bd9Sstevel@tonic-gate * For the SOL_TIMER event the caller passes in the number of milliseconds
9997c478bd9Sstevel@tonic-gate * since the last timer event in the 'elapsed' parameter.
10007c478bd9Sstevel@tonic-gate */
10017c478bd9Sstevel@tonic-gate uint_t
solicit_event(struct phyint * pi,enum solicit_events event,uint_t elapsed)10027c478bd9Sstevel@tonic-gate solicit_event(struct phyint *pi, enum solicit_events event, uint_t elapsed)
10037c478bd9Sstevel@tonic-gate {
10047c478bd9Sstevel@tonic-gate if (debug & D_STATE) {
10057c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "solicit_event(%s, %d, %d) state %d\n",
10067c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, elapsed, (int)pi->pi_sol_state);
10077c478bd9Sstevel@tonic-gate }
10087c478bd9Sstevel@tonic-gate
10097c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements)
10107c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10117c478bd9Sstevel@tonic-gate if (pi->pi_flags & IFF_NORTEXCH) {
10127c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) {
10137c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Suppress sending RS packet on %s "
10147c478bd9Sstevel@tonic-gate "(no route exchange on interface)\n",
10157c478bd9Sstevel@tonic-gate pi->pi_name);
10167c478bd9Sstevel@tonic-gate }
10177c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10187c478bd9Sstevel@tonic-gate }
10197c478bd9Sstevel@tonic-gate
10207c478bd9Sstevel@tonic-gate switch (event) {
10217c478bd9Sstevel@tonic-gate case SOLICIT_OFF:
10227c478bd9Sstevel@tonic-gate pi->pi_sol_state = NO_SOLICIT;
10237c478bd9Sstevel@tonic-gate check_daemonize();
10247c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10257c478bd9Sstevel@tonic-gate
10267c478bd9Sstevel@tonic-gate case SOLICIT_DONE:
10277c478bd9Sstevel@tonic-gate pi->pi_sol_state = DONE_SOLICIT;
10287c478bd9Sstevel@tonic-gate check_daemonize();
10297c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10307c478bd9Sstevel@tonic-gate
1031d04ccbb3Scarlsonj case RESTART_INIT_SOLICIT:
1032d04ccbb3Scarlsonj /*
1033d04ccbb3Scarlsonj * This event allows us to start solicitation over again
1034d04ccbb3Scarlsonj * without losing the RA flags. We start solicitation over
1035d04ccbb3Scarlsonj * when we are missing an interface prefix for a newly-
1036d04ccbb3Scarlsonj * encountered DHCP interface.
1037d04ccbb3Scarlsonj */
1038d04ccbb3Scarlsonj if (pi->pi_sol_state == INIT_SOLICIT)
1039d04ccbb3Scarlsonj return (pi->pi_sol_time_left);
1040d04ccbb3Scarlsonj pi->pi_sol_count = ND_MAX_RTR_SOLICITATIONS;
1041d04ccbb3Scarlsonj pi->pi_sol_time_left =
1042d04ccbb3Scarlsonj GET_RANDOM(0, ND_MAX_RTR_SOLICITATION_DELAY);
1043d04ccbb3Scarlsonj pi->pi_sol_state = INIT_SOLICIT;
1044d04ccbb3Scarlsonj break;
1045d04ccbb3Scarlsonj
10467c478bd9Sstevel@tonic-gate case START_INIT_SOLICIT:
10477c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == INIT_SOLICIT)
10487c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left);
1049d04ccbb3Scarlsonj pi->pi_ra_flags = 0;
10507c478bd9Sstevel@tonic-gate pi->pi_sol_count = ND_MAX_RTR_SOLICITATIONS;
10517c478bd9Sstevel@tonic-gate pi->pi_sol_time_left =
10527c478bd9Sstevel@tonic-gate GET_RANDOM(0, ND_MAX_RTR_SOLICITATION_DELAY);
10537c478bd9Sstevel@tonic-gate pi->pi_sol_state = INIT_SOLICIT;
10547c478bd9Sstevel@tonic-gate break;
10557c478bd9Sstevel@tonic-gate
10567c478bd9Sstevel@tonic-gate case SOL_TIMER:
10577c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == NO_SOLICIT)
10587c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10597c478bd9Sstevel@tonic-gate /* Decrease time left */
10607c478bd9Sstevel@tonic-gate if (pi->pi_sol_time_left >= elapsed)
10617c478bd9Sstevel@tonic-gate pi->pi_sol_time_left -= elapsed;
10627c478bd9Sstevel@tonic-gate else
10637c478bd9Sstevel@tonic-gate pi->pi_sol_time_left = 0;
10647c478bd9Sstevel@tonic-gate break;
10657c478bd9Sstevel@tonic-gate default:
10667c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "solicit_event: Unknown event %d\n",
10677c478bd9Sstevel@tonic-gate (int)event);
10687c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10697c478bd9Sstevel@tonic-gate }
10707c478bd9Sstevel@tonic-gate
10717c478bd9Sstevel@tonic-gate if (pi->pi_sol_time_left != 0)
10727c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left);
10737c478bd9Sstevel@tonic-gate
10747c478bd9Sstevel@tonic-gate /* Send solicitation and calculate next time */
10757c478bd9Sstevel@tonic-gate switch (pi->pi_sol_state) {
10767c478bd9Sstevel@tonic-gate case INIT_SOLICIT:
10777c478bd9Sstevel@tonic-gate solicit(&v6allrouters, pi);
10787c478bd9Sstevel@tonic-gate if (--pi->pi_sol_count == 0) {
1079cfb9c9abScarlsonj if (debug & D_STATE) {
1080cfb9c9abScarlsonj logmsg(LOG_DEBUG, "solicit_event: no routers "
1081cfb9c9abScarlsonj "found on %s; assuming default flags\n",
1082cfb9c9abScarlsonj pi->pi_name);
1083cfb9c9abScarlsonj }
10846e91bba0SGirish Moodalbail if (pi->pi_autoconf && pi->pi_StatefulAddrConf) {
1085d04ccbb3Scarlsonj pi->pi_ra_flags |= ND_RA_FLAG_MANAGED |
1086d04ccbb3Scarlsonj ND_RA_FLAG_OTHER;
1087d04ccbb3Scarlsonj start_dhcp(pi);
1088d04ccbb3Scarlsonj }
10897c478bd9Sstevel@tonic-gate pi->pi_sol_state = DONE_SOLICIT;
10907c478bd9Sstevel@tonic-gate check_daemonize();
10917c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10927c478bd9Sstevel@tonic-gate }
10937c478bd9Sstevel@tonic-gate pi->pi_sol_time_left = ND_RTR_SOLICITATION_INTERVAL;
10947c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left);
10957c478bd9Sstevel@tonic-gate case NO_SOLICIT:
10967c478bd9Sstevel@tonic-gate case DONE_SOLICIT:
10977c478bd9Sstevel@tonic-gate return (TIMER_INFINITY);
10987c478bd9Sstevel@tonic-gate default:
10997c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left);
11007c478bd9Sstevel@tonic-gate }
11017c478bd9Sstevel@tonic-gate }
11027c478bd9Sstevel@tonic-gate
11037c478bd9Sstevel@tonic-gate /*
11047c478bd9Sstevel@tonic-gate * Timer mechanism using relative time (in milliseconds) from the
11057c478bd9Sstevel@tonic-gate * previous timer event. Timers exceeding TIMER_INFINITY milliseconds
11067c478bd9Sstevel@tonic-gate * will fire after TIMER_INFINITY milliseconds.
11077c478bd9Sstevel@tonic-gate */
11087c478bd9Sstevel@tonic-gate static uint_t timer_previous; /* When last SIGALRM occurred */
11097c478bd9Sstevel@tonic-gate static uint_t timer_next; /* Currently scheduled timeout */
11107c478bd9Sstevel@tonic-gate
11117c478bd9Sstevel@tonic-gate static void
timer_init(void)11127c478bd9Sstevel@tonic-gate timer_init(void)
11137c478bd9Sstevel@tonic-gate {
11147c478bd9Sstevel@tonic-gate timer_previous = getcurrenttime();
11157c478bd9Sstevel@tonic-gate timer_next = TIMER_INFINITY;
11167c478bd9Sstevel@tonic-gate run_timeouts();
11177c478bd9Sstevel@tonic-gate }
11187c478bd9Sstevel@tonic-gate
11197c478bd9Sstevel@tonic-gate /*
11207c478bd9Sstevel@tonic-gate * Make sure the next SIGALRM occurs delay milliseconds from the current
11217c478bd9Sstevel@tonic-gate * time if not earlier.
11227c478bd9Sstevel@tonic-gate * Handles getcurrenttime (32 bit integer holding milliseconds) wraparound
11237c478bd9Sstevel@tonic-gate * by treating differences greater than 0x80000000 as negative.
11247c478bd9Sstevel@tonic-gate */
11257c478bd9Sstevel@tonic-gate void
timer_schedule(uint_t delay)11267c478bd9Sstevel@tonic-gate timer_schedule(uint_t delay)
11277c478bd9Sstevel@tonic-gate {
11287c478bd9Sstevel@tonic-gate uint_t now;
11297c478bd9Sstevel@tonic-gate struct itimerval itimerval;
11307c478bd9Sstevel@tonic-gate
11317c478bd9Sstevel@tonic-gate now = getcurrenttime();
11327c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
11337c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "timer_schedule(%u): now %u next %u\n",
11347c478bd9Sstevel@tonic-gate delay, now, timer_next);
11357c478bd9Sstevel@tonic-gate }
11367c478bd9Sstevel@tonic-gate /* Will this timer occur before the currently scheduled SIGALRM? */
11377c478bd9Sstevel@tonic-gate if (delay >= timer_next - now) {
11387c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
11397c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "timer_schedule(%u): no action - "
11407c478bd9Sstevel@tonic-gate "next in %u ms\n",
11417c478bd9Sstevel@tonic-gate delay, timer_next - now);
11427c478bd9Sstevel@tonic-gate }
11437c478bd9Sstevel@tonic-gate return;
11447c478bd9Sstevel@tonic-gate }
11457c478bd9Sstevel@tonic-gate if (delay == 0) {
11467c478bd9Sstevel@tonic-gate /* Minimum allowed delay */
11477c478bd9Sstevel@tonic-gate delay = 1;
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate timer_next = now + delay;
11507c478bd9Sstevel@tonic-gate
11517c478bd9Sstevel@tonic-gate itimerval.it_value.tv_sec = delay / 1000;
11527c478bd9Sstevel@tonic-gate itimerval.it_value.tv_usec = (delay % 1000) * 1000;
11537c478bd9Sstevel@tonic-gate itimerval.it_interval.tv_sec = 0;
11547c478bd9Sstevel@tonic-gate itimerval.it_interval.tv_usec = 0;
11557c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
11567c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "timer_schedule(%u): sec %lu usec %lu\n",
11577c478bd9Sstevel@tonic-gate delay,
11587c478bd9Sstevel@tonic-gate itimerval.it_value.tv_sec, itimerval.it_value.tv_usec);
11597c478bd9Sstevel@tonic-gate }
11607c478bd9Sstevel@tonic-gate if (setitimer(ITIMER_REAL, &itimerval, NULL) < 0) {
11617c478bd9Sstevel@tonic-gate logperror("timer_schedule: setitimer");
11627c478bd9Sstevel@tonic-gate exit(2);
11637c478bd9Sstevel@tonic-gate }
11647c478bd9Sstevel@tonic-gate }
11657c478bd9Sstevel@tonic-gate
11667c478bd9Sstevel@tonic-gate /*
11677c478bd9Sstevel@tonic-gate * Conditional running of timer. If more than 'minimal_time' millseconds
11687c478bd9Sstevel@tonic-gate * since the timer routines were last run we run them.
11697c478bd9Sstevel@tonic-gate * Used when packets arrive.
11707c478bd9Sstevel@tonic-gate */
11717c478bd9Sstevel@tonic-gate static void
conditional_run_timeouts(uint_t minimal_time)11727c478bd9Sstevel@tonic-gate conditional_run_timeouts(uint_t minimal_time)
11737c478bd9Sstevel@tonic-gate {
11747c478bd9Sstevel@tonic-gate uint_t now;
11757c478bd9Sstevel@tonic-gate uint_t elapsed;
11767c478bd9Sstevel@tonic-gate
11777c478bd9Sstevel@tonic-gate now = getcurrenttime();
11787c478bd9Sstevel@tonic-gate elapsed = now - timer_previous;
11797c478bd9Sstevel@tonic-gate if (elapsed > minimal_time) {
11807c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
11817c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "conditional_run_timeouts: "
11827c478bd9Sstevel@tonic-gate "elapsed %d\n", elapsed);
11837c478bd9Sstevel@tonic-gate }
11847c478bd9Sstevel@tonic-gate run_timeouts();
11857c478bd9Sstevel@tonic-gate }
11867c478bd9Sstevel@tonic-gate }
11877c478bd9Sstevel@tonic-gate
11887c478bd9Sstevel@tonic-gate /*
11897c478bd9Sstevel@tonic-gate * Timer has fired.
11907c478bd9Sstevel@tonic-gate * Determine when the next timer event will occur by asking all
11917c478bd9Sstevel@tonic-gate * the timer routines.
11927c478bd9Sstevel@tonic-gate * Should not be called from a timer routine but in some cases this is
11937c478bd9Sstevel@tonic-gate * done because the code doesn't know that e.g. it was called from
11947c478bd9Sstevel@tonic-gate * ifconfig_timer(). In this case the nested run_timeouts will just return but
11957c478bd9Sstevel@tonic-gate * the running run_timeouts will ensure to call all the timer functions by
11967c478bd9Sstevel@tonic-gate * looping once more.
11977c478bd9Sstevel@tonic-gate */
11987c478bd9Sstevel@tonic-gate static void
run_timeouts(void)11997c478bd9Sstevel@tonic-gate run_timeouts(void)
12007c478bd9Sstevel@tonic-gate {
12017c478bd9Sstevel@tonic-gate uint_t now;
12027c478bd9Sstevel@tonic-gate uint_t elapsed;
12037c478bd9Sstevel@tonic-gate uint_t next;
12047c478bd9Sstevel@tonic-gate uint_t nexti;
12057c478bd9Sstevel@tonic-gate struct phyint *pi;
12067c478bd9Sstevel@tonic-gate struct phyint *next_pi;
12077c478bd9Sstevel@tonic-gate struct prefix *pr;
12087c478bd9Sstevel@tonic-gate struct prefix *next_pr;
12097c478bd9Sstevel@tonic-gate struct adv_prefix *adv_pr;
12107c478bd9Sstevel@tonic-gate struct adv_prefix *next_adv_pr;
12117c478bd9Sstevel@tonic-gate struct router *dr;
12127c478bd9Sstevel@tonic-gate struct router *next_dr;
12137c478bd9Sstevel@tonic-gate static boolean_t timeout_running;
12147c478bd9Sstevel@tonic-gate static boolean_t do_retry;
12157c478bd9Sstevel@tonic-gate
12167c478bd9Sstevel@tonic-gate if (timeout_running) {
12177c478bd9Sstevel@tonic-gate if (debug & D_TIMER)
12187c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: nested call\n");
12197c478bd9Sstevel@tonic-gate do_retry = _B_TRUE;
12207c478bd9Sstevel@tonic-gate return;
12217c478bd9Sstevel@tonic-gate }
12227c478bd9Sstevel@tonic-gate timeout_running = _B_TRUE;
12237c478bd9Sstevel@tonic-gate retry:
12247c478bd9Sstevel@tonic-gate /* How much time since the last time we were called? */
12257c478bd9Sstevel@tonic-gate now = getcurrenttime();
12267c478bd9Sstevel@tonic-gate elapsed = now - timer_previous;
12277c478bd9Sstevel@tonic-gate timer_previous = now;
12287c478bd9Sstevel@tonic-gate
12297c478bd9Sstevel@tonic-gate if (debug & D_TIMER)
12307c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: elapsed %d\n", elapsed);
12317c478bd9Sstevel@tonic-gate
12327c478bd9Sstevel@tonic-gate next = TIMER_INFINITY;
12337c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) {
12347c478bd9Sstevel@tonic-gate next_pi = pi->pi_next;
12357c478bd9Sstevel@tonic-gate nexti = phyint_timer(pi, elapsed);
12367c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next)
12377c478bd9Sstevel@tonic-gate next = nexti;
12387c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
12397c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (pi %s): %d -> %u ms\n",
12407c478bd9Sstevel@tonic-gate pi->pi_name, nexti, next);
12417c478bd9Sstevel@tonic-gate }
12427c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
12437c478bd9Sstevel@tonic-gate next_pr = pr->pr_next;
12447c478bd9Sstevel@tonic-gate nexti = prefix_timer(pr, elapsed);
12457c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next)
12467c478bd9Sstevel@tonic-gate next = nexti;
12477c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
12487c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (pr %s): "
12497c478bd9Sstevel@tonic-gate "%d -> %u ms\n", pr->pr_name, nexti, next);
12507c478bd9Sstevel@tonic-gate }
12517c478bd9Sstevel@tonic-gate }
12527c478bd9Sstevel@tonic-gate for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL;
12537c478bd9Sstevel@tonic-gate adv_pr = next_adv_pr) {
12547c478bd9Sstevel@tonic-gate next_adv_pr = adv_pr->adv_pr_next;
12557c478bd9Sstevel@tonic-gate nexti = adv_prefix_timer(adv_pr, elapsed);
12567c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next)
12577c478bd9Sstevel@tonic-gate next = nexti;
12587c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
12597c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts "
12607c478bd9Sstevel@tonic-gate "(adv pr on %s): %d -> %u ms\n",
12617c478bd9Sstevel@tonic-gate adv_pr->adv_pr_physical->pi_name,
12627c478bd9Sstevel@tonic-gate nexti, next);
12637c478bd9Sstevel@tonic-gate }
12647c478bd9Sstevel@tonic-gate }
12657c478bd9Sstevel@tonic-gate for (dr = pi->pi_router_list; dr != NULL; dr = next_dr) {
12667c478bd9Sstevel@tonic-gate next_dr = dr->dr_next;
12677c478bd9Sstevel@tonic-gate nexti = router_timer(dr, elapsed);
12687c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next)
12697c478bd9Sstevel@tonic-gate next = nexti;
12707c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
12717c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (dr): "
12727c478bd9Sstevel@tonic-gate "%d -> %u ms\n", nexti, next);
12737c478bd9Sstevel@tonic-gate }
12747c478bd9Sstevel@tonic-gate }
12757c478bd9Sstevel@tonic-gate if (pi->pi_TmpAddrsEnabled) {
12767c478bd9Sstevel@tonic-gate nexti = tmptoken_timer(pi, elapsed);
12777c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next)
12787c478bd9Sstevel@tonic-gate next = nexti;
12797c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
12807c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (tmp on %s): "
12817c478bd9Sstevel@tonic-gate "%d -> %u ms\n", pi->pi_name, nexti, next);
12827c478bd9Sstevel@tonic-gate }
12837c478bd9Sstevel@tonic-gate }
12847c478bd9Sstevel@tonic-gate }
12857c478bd9Sstevel@tonic-gate /*
12867c478bd9Sstevel@tonic-gate * Make sure the timer functions are run at least once
12877c478bd9Sstevel@tonic-gate * an hour.
12887c478bd9Sstevel@tonic-gate */
12897c478bd9Sstevel@tonic-gate if (next == TIMER_INFINITY)
12907c478bd9Sstevel@tonic-gate next = 3600 * 1000; /* 1 hour */
12917c478bd9Sstevel@tonic-gate
12927c478bd9Sstevel@tonic-gate if (debug & D_TIMER)
12937c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: %u ms\n", next);
12947c478bd9Sstevel@tonic-gate timer_schedule(next);
12957c478bd9Sstevel@tonic-gate if (do_retry) {
12967c478bd9Sstevel@tonic-gate if (debug & D_TIMER)
12977c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: retry\n");
12987c478bd9Sstevel@tonic-gate do_retry = _B_FALSE;
12997c478bd9Sstevel@tonic-gate goto retry;
13007c478bd9Sstevel@tonic-gate }
13017c478bd9Sstevel@tonic-gate timeout_running = _B_FALSE;
13027c478bd9Sstevel@tonic-gate }
13037c478bd9Sstevel@tonic-gate
13047c478bd9Sstevel@tonic-gate static int eventpipe_read = -1; /* Used for synchronous signal delivery */
13057c478bd9Sstevel@tonic-gate static int eventpipe_write = -1;
13067c478bd9Sstevel@tonic-gate
13077c478bd9Sstevel@tonic-gate /*
13087c478bd9Sstevel@tonic-gate * Ensure that signals are processed synchronously with the rest of
13097c478bd9Sstevel@tonic-gate * the code by just writing a one character signal number on the pipe.
13107c478bd9Sstevel@tonic-gate * The poll loop will pick this up and process the signal event.
13117c478bd9Sstevel@tonic-gate */
13127c478bd9Sstevel@tonic-gate static void
sig_handler(int signo)13137c478bd9Sstevel@tonic-gate sig_handler(int signo)
13147c478bd9Sstevel@tonic-gate {
13157c478bd9Sstevel@tonic-gate uchar_t buf = (uchar_t)signo;
13167c478bd9Sstevel@tonic-gate
13177c478bd9Sstevel@tonic-gate if (eventpipe_write == -1) {
13187c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "sig_handler: no pipe\n");
13197c478bd9Sstevel@tonic-gate return;
13207c478bd9Sstevel@tonic-gate }
13217c478bd9Sstevel@tonic-gate if (write(eventpipe_write, &buf, sizeof (buf)) < 0)
13227c478bd9Sstevel@tonic-gate logperror("sig_handler: write");
13237c478bd9Sstevel@tonic-gate }
13247c478bd9Sstevel@tonic-gate
13257c478bd9Sstevel@tonic-gate /*
13267c478bd9Sstevel@tonic-gate * Pick up a signal "byte" from the pipe and process it.
13277c478bd9Sstevel@tonic-gate */
13287c478bd9Sstevel@tonic-gate static void
in_signal(int fd)13297c478bd9Sstevel@tonic-gate in_signal(int fd)
13307c478bd9Sstevel@tonic-gate {
13317c478bd9Sstevel@tonic-gate uchar_t buf;
13327c478bd9Sstevel@tonic-gate struct phyint *pi;
13337c478bd9Sstevel@tonic-gate struct phyint *next_pi;
13347c478bd9Sstevel@tonic-gate
13357c478bd9Sstevel@tonic-gate switch (read(fd, &buf, sizeof (buf))) {
13367c478bd9Sstevel@tonic-gate case -1:
13377c478bd9Sstevel@tonic-gate logperror("in_signal: read");
13387c478bd9Sstevel@tonic-gate exit(1);
13397c478bd9Sstevel@tonic-gate /* NOTREACHED */
13407c478bd9Sstevel@tonic-gate case 1:
13417c478bd9Sstevel@tonic-gate break;
13427c478bd9Sstevel@tonic-gate case 0:
13437c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "in_signal: read eof\n");
13447c478bd9Sstevel@tonic-gate exit(1);
13457c478bd9Sstevel@tonic-gate /* NOTREACHED */
13467c478bd9Sstevel@tonic-gate default:
13477c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "in_signal: read > 1\n");
13487c478bd9Sstevel@tonic-gate exit(1);
13497c478bd9Sstevel@tonic-gate }
13507c478bd9Sstevel@tonic-gate
13517c478bd9Sstevel@tonic-gate if (debug & D_TIMER)
13527c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "in_signal() got %d\n", buf);
13537c478bd9Sstevel@tonic-gate
13547c478bd9Sstevel@tonic-gate switch (buf) {
13557c478bd9Sstevel@tonic-gate case SIGALRM:
13567c478bd9Sstevel@tonic-gate if (debug & D_TIMER) {
13577c478bd9Sstevel@tonic-gate uint_t now = getcurrenttime();
13587c478bd9Sstevel@tonic-gate
13597c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "in_signal(SIGALRM) delta %u\n",
13607c478bd9Sstevel@tonic-gate now - timer_next);
13617c478bd9Sstevel@tonic-gate }
13627c478bd9Sstevel@tonic-gate timer_next = TIMER_INFINITY;
13637c478bd9Sstevel@tonic-gate run_timeouts();
13647c478bd9Sstevel@tonic-gate break;
13657c478bd9Sstevel@tonic-gate case SIGHUP:
13667c478bd9Sstevel@tonic-gate /* Re-read config file by exec'ing ourselves */
13677c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) {
13687c478bd9Sstevel@tonic-gate next_pi = pi->pi_next;
13697c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements)
13707c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_FINAL_ADV);
13717c478bd9Sstevel@tonic-gate
13726e91bba0SGirish Moodalbail /*
13736e91bba0SGirish Moodalbail * Remove all the configured addresses.
13746e91bba0SGirish Moodalbail * Remove the addrobj names created with ipmgmtd.
13756e91bba0SGirish Moodalbail * Release the dhcpv6 addresses if any.
13766e91bba0SGirish Moodalbail * Cleanup the phyints.
13776e91bba0SGirish Moodalbail */
13787c478bd9Sstevel@tonic-gate phyint_delete(pi);
13797c478bd9Sstevel@tonic-gate }
13807c478bd9Sstevel@tonic-gate
13817c478bd9Sstevel@tonic-gate /*
13827c478bd9Sstevel@tonic-gate * Prevent fd leaks. Everything gets re-opened at start-up
13837c478bd9Sstevel@tonic-gate * time. 0, 1, and 2 are closed and re-opened as
13847c478bd9Sstevel@tonic-gate * /dev/null, so we'll leave those open.
13857c478bd9Sstevel@tonic-gate */
13867c478bd9Sstevel@tonic-gate closefrom(3);
13877c478bd9Sstevel@tonic-gate
13887c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "SIGHUP: restart and reread config file\n");
13897c478bd9Sstevel@tonic-gate (void) execv(argv0[0], argv0);
13907c478bd9Sstevel@tonic-gate _exit(0177);
13917c478bd9Sstevel@tonic-gate /* NOTREACHED */
13927c478bd9Sstevel@tonic-gate case SIGUSR1:
13937c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Printing configuration:\n");
13947c478bd9Sstevel@tonic-gate phyint_print_all();
13957c478bd9Sstevel@tonic-gate break;
13967c478bd9Sstevel@tonic-gate case SIGINT:
13977c478bd9Sstevel@tonic-gate case SIGTERM:
13987c478bd9Sstevel@tonic-gate case SIGQUIT:
13997c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) {
14007c478bd9Sstevel@tonic-gate next_pi = pi->pi_next;
14017c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements)
14027c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_FINAL_ADV);
14037c478bd9Sstevel@tonic-gate
14047c478bd9Sstevel@tonic-gate phyint_delete(pi);
14057c478bd9Sstevel@tonic-gate }
14063173664eSapersson (void) unlink(NDPD_SNMP_SOCKET);
14077c478bd9Sstevel@tonic-gate exit(0);
14087c478bd9Sstevel@tonic-gate /* NOTREACHED */
14097c478bd9Sstevel@tonic-gate case 255:
14107c478bd9Sstevel@tonic-gate /*
14116e91bba0SGirish Moodalbail * Special "signal" from loopback_ra_enqueue.
14127c478bd9Sstevel@tonic-gate * Handle any queued loopback router advertisements.
14137c478bd9Sstevel@tonic-gate */
14147c478bd9Sstevel@tonic-gate loopback_ra_dequeue();
14157c478bd9Sstevel@tonic-gate break;
14167c478bd9Sstevel@tonic-gate default:
14177c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "in_signal: unknown signal: %d\n", buf);
14187c478bd9Sstevel@tonic-gate }
14197c478bd9Sstevel@tonic-gate }
14207c478bd9Sstevel@tonic-gate
14217c478bd9Sstevel@tonic-gate /*
14227c478bd9Sstevel@tonic-gate * Create pipe for signal delivery and set up signal handlers.
14237c478bd9Sstevel@tonic-gate */
14247c478bd9Sstevel@tonic-gate static void
setup_eventpipe(void)14257c478bd9Sstevel@tonic-gate setup_eventpipe(void)
14267c478bd9Sstevel@tonic-gate {
14277c478bd9Sstevel@tonic-gate int fds[2];
14287c478bd9Sstevel@tonic-gate struct sigaction act;
14297c478bd9Sstevel@tonic-gate
14307c478bd9Sstevel@tonic-gate if ((pipe(fds)) < 0) {
14317c478bd9Sstevel@tonic-gate logperror("setup_eventpipe: pipe");
14327c478bd9Sstevel@tonic-gate exit(1);
14337c478bd9Sstevel@tonic-gate }
14347c478bd9Sstevel@tonic-gate eventpipe_read = fds[0];
14357c478bd9Sstevel@tonic-gate eventpipe_write = fds[1];
14367c478bd9Sstevel@tonic-gate if (poll_add(eventpipe_read) == -1) {
14377c478bd9Sstevel@tonic-gate exit(1);
14387c478bd9Sstevel@tonic-gate }
14397c478bd9Sstevel@tonic-gate act.sa_handler = sig_handler;
14407c478bd9Sstevel@tonic-gate act.sa_flags = SA_RESTART;
14417c478bd9Sstevel@tonic-gate (void) sigaction(SIGALRM, &act, NULL);
14427c478bd9Sstevel@tonic-gate
14437c478bd9Sstevel@tonic-gate (void) sigset(SIGHUP, sig_handler);
14447c478bd9Sstevel@tonic-gate (void) sigset(SIGUSR1, sig_handler);
14457c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, sig_handler);
14467c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, sig_handler);
14477c478bd9Sstevel@tonic-gate (void) sigset(SIGQUIT, sig_handler);
14487c478bd9Sstevel@tonic-gate }
14497c478bd9Sstevel@tonic-gate
14507c478bd9Sstevel@tonic-gate /*
14517c478bd9Sstevel@tonic-gate * Create a routing socket for receiving RTM_IFINFO messages and initialize
14527c478bd9Sstevel@tonic-gate * the routing socket message header and as much of the sockaddrs as possible.
14537c478bd9Sstevel@tonic-gate */
14547c478bd9Sstevel@tonic-gate static int
setup_rtsock(void)14557c478bd9Sstevel@tonic-gate setup_rtsock(void)
14567c478bd9Sstevel@tonic-gate {
14577c478bd9Sstevel@tonic-gate int s;
14587c478bd9Sstevel@tonic-gate int ret;
14597c478bd9Sstevel@tonic-gate char *cp;
14607c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6;
14617c478bd9Sstevel@tonic-gate
14627c478bd9Sstevel@tonic-gate s = socket(PF_ROUTE, SOCK_RAW, AF_INET6);
14637c478bd9Sstevel@tonic-gate if (s == -1) {
14647c478bd9Sstevel@tonic-gate logperror("socket(PF_ROUTE)");
14657c478bd9Sstevel@tonic-gate exit(1);
14667c478bd9Sstevel@tonic-gate }
14677c478bd9Sstevel@tonic-gate ret = fcntl(s, F_SETFL, O_NDELAY|O_NONBLOCK);
14687c478bd9Sstevel@tonic-gate if (ret < 0) {
14697c478bd9Sstevel@tonic-gate logperror("fcntl(O_NDELAY)");
14707c478bd9Sstevel@tonic-gate exit(1);
14717c478bd9Sstevel@tonic-gate }
14727c478bd9Sstevel@tonic-gate if (poll_add(s) == -1) {
14737c478bd9Sstevel@tonic-gate exit(1);
14747c478bd9Sstevel@tonic-gate }
14757c478bd9Sstevel@tonic-gate
14767c478bd9Sstevel@tonic-gate /*
14777c478bd9Sstevel@tonic-gate * Allocate storage for the routing socket message.
14787c478bd9Sstevel@tonic-gate */
14797c478bd9Sstevel@tonic-gate rt_msg = (struct rt_msghdr *)malloc(NDP_RTM_MSGLEN);
14807c478bd9Sstevel@tonic-gate if (rt_msg == NULL) {
14817c478bd9Sstevel@tonic-gate logperror("malloc");
14827c478bd9Sstevel@tonic-gate exit(1);
14837c478bd9Sstevel@tonic-gate }
14847c478bd9Sstevel@tonic-gate
14857c478bd9Sstevel@tonic-gate /*
14867c478bd9Sstevel@tonic-gate * Initialize the routing socket message by zero-filling it and then
14877c478bd9Sstevel@tonic-gate * setting the fields where are constant through the lifetime of the
14887c478bd9Sstevel@tonic-gate * process.
14897c478bd9Sstevel@tonic-gate */
14907c478bd9Sstevel@tonic-gate bzero(rt_msg, NDP_RTM_MSGLEN);
14917c478bd9Sstevel@tonic-gate rt_msg->rtm_msglen = NDP_RTM_MSGLEN;
14927c478bd9Sstevel@tonic-gate rt_msg->rtm_version = RTM_VERSION;
14937c478bd9Sstevel@tonic-gate rt_msg->rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK | RTA_IFP;
14947c478bd9Sstevel@tonic-gate rt_msg->rtm_pid = getpid();
14957c478bd9Sstevel@tonic-gate if (rt_msg->rtm_pid < 0) {
14967c478bd9Sstevel@tonic-gate logperror("getpid");
14977c478bd9Sstevel@tonic-gate exit(1);
14987c478bd9Sstevel@tonic-gate }
14997c478bd9Sstevel@tonic-gate
15007c478bd9Sstevel@tonic-gate /*
15017c478bd9Sstevel@tonic-gate * The RTA_DST sockaddr does not change during the lifetime of the
15027c478bd9Sstevel@tonic-gate * process so it can be completely initialized at this time.
15037c478bd9Sstevel@tonic-gate */
15047c478bd9Sstevel@tonic-gate cp = (char *)rt_msg + sizeof (struct rt_msghdr);
15057c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)cp;
15067c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6;
15077c478bd9Sstevel@tonic-gate sin6->sin6_addr = in6addr_any;
15087c478bd9Sstevel@tonic-gate
15097c478bd9Sstevel@tonic-gate /*
15107c478bd9Sstevel@tonic-gate * Initialize the constant portion of the RTA_GATEWAY sockaddr.
15117c478bd9Sstevel@tonic-gate */
15127c478bd9Sstevel@tonic-gate cp += sizeof (struct sockaddr_in6);
15137c478bd9Sstevel@tonic-gate rta_gateway = (struct sockaddr_in6 *)cp;
15147c478bd9Sstevel@tonic-gate rta_gateway->sin6_family = AF_INET6;
15157c478bd9Sstevel@tonic-gate
15167c478bd9Sstevel@tonic-gate /*
15177c478bd9Sstevel@tonic-gate * The RTA_NETMASK sockaddr does not change during the lifetime of the
15187c478bd9Sstevel@tonic-gate * process so it can be completely initialized at this time.
15197c478bd9Sstevel@tonic-gate */
15207c478bd9Sstevel@tonic-gate cp += sizeof (struct sockaddr_in6);
15217c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)cp;
15227c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6;
15237c478bd9Sstevel@tonic-gate sin6->sin6_addr = in6addr_any;
15247c478bd9Sstevel@tonic-gate
15257c478bd9Sstevel@tonic-gate /*
15267c478bd9Sstevel@tonic-gate * Initialize the constant portion of the RTA_IFP sockaddr.
15277c478bd9Sstevel@tonic-gate */
15287c478bd9Sstevel@tonic-gate cp += sizeof (struct sockaddr_in6);
15297c478bd9Sstevel@tonic-gate rta_ifp = (struct sockaddr_dl *)cp;
15307c478bd9Sstevel@tonic-gate rta_ifp->sdl_family = AF_LINK;
15317c478bd9Sstevel@tonic-gate
15327c478bd9Sstevel@tonic-gate return (s);
15337c478bd9Sstevel@tonic-gate }
15347c478bd9Sstevel@tonic-gate
15353173664eSapersson static int
setup_mibsock(void)15363173664eSapersson setup_mibsock(void)
15373173664eSapersson {
15383173664eSapersson int sock;
15393173664eSapersson int ret;
15403173664eSapersson int len;
15413173664eSapersson struct sockaddr_un laddr;
15423173664eSapersson
15433173664eSapersson sock = socket(AF_UNIX, SOCK_DGRAM, 0);
15443173664eSapersson if (sock == -1) {
15453173664eSapersson logperror("setup_mibsock: socket(AF_UNIX)");
15463173664eSapersson exit(1);
15473173664eSapersson }
15483173664eSapersson
15493173664eSapersson bzero(&laddr, sizeof (laddr));
15503173664eSapersson laddr.sun_family = AF_UNIX;
15513173664eSapersson
15523173664eSapersson (void) strncpy(laddr.sun_path, NDPD_SNMP_SOCKET,
15533173664eSapersson sizeof (laddr.sun_path));
15543173664eSapersson len = sizeof (struct sockaddr_un);
15553173664eSapersson
15563173664eSapersson (void) unlink(NDPD_SNMP_SOCKET);
15573173664eSapersson ret = bind(sock, (struct sockaddr *)&laddr, len);
15583173664eSapersson if (ret < 0) {
15593173664eSapersson logperror("setup_mibsock: bind\n");
15603173664eSapersson exit(1);
15613173664eSapersson }
15623173664eSapersson
15633173664eSapersson ret = fcntl(sock, F_SETFL, O_NONBLOCK);
15643173664eSapersson if (ret < 0) {
15653173664eSapersson logperror("fcntl(O_NONBLOCK)");
15663173664eSapersson exit(1);
15673173664eSapersson }
15683173664eSapersson if (poll_add(sock) == -1) {
15693173664eSapersson exit(1);
15703173664eSapersson }
15713173664eSapersson return (sock);
15723173664eSapersson }
15733173664eSapersson
15747c478bd9Sstevel@tonic-gate /*
15757c478bd9Sstevel@tonic-gate * Retrieve one routing socket message. If RTM_IFINFO indicates
15767c478bd9Sstevel@tonic-gate * new phyint do a full scan of the interfaces. If RTM_IFINFO
157769bb4bb4Scarlsonj * indicates an existing phyint, only scan that phyint and associated
15787c478bd9Sstevel@tonic-gate * prefixes.
15797c478bd9Sstevel@tonic-gate */
15807c478bd9Sstevel@tonic-gate static void
process_rtsock(int rtsock)15817c478bd9Sstevel@tonic-gate process_rtsock(int rtsock)
15827c478bd9Sstevel@tonic-gate {
15837c478bd9Sstevel@tonic-gate int n;
15847c478bd9Sstevel@tonic-gate #define MSG_SIZE 2048/8
15857c478bd9Sstevel@tonic-gate int64_t msg[MSG_SIZE];
15867c478bd9Sstevel@tonic-gate struct rt_msghdr *rtm;
15877c478bd9Sstevel@tonic-gate struct if_msghdr *ifm;
15887c478bd9Sstevel@tonic-gate struct phyint *pi;
15897c478bd9Sstevel@tonic-gate struct prefix *pr;
15907c478bd9Sstevel@tonic-gate boolean_t need_initifs = _B_FALSE;
15917c478bd9Sstevel@tonic-gate boolean_t need_ifscan = _B_FALSE;
15927c478bd9Sstevel@tonic-gate int64_t ifscan_msg[10][MSG_SIZE];
15937c478bd9Sstevel@tonic-gate int ifscan_index = 0;
15947c478bd9Sstevel@tonic-gate int i;
15957c478bd9Sstevel@tonic-gate
15967c478bd9Sstevel@tonic-gate /* Empty the rtsock and coealesce all the work that we have */
15977c478bd9Sstevel@tonic-gate while (ifscan_index < 10) {
15987c478bd9Sstevel@tonic-gate n = read(rtsock, msg, sizeof (msg));
15997c478bd9Sstevel@tonic-gate if (n <= 0) {
16007c478bd9Sstevel@tonic-gate /* No more messages */
16017c478bd9Sstevel@tonic-gate break;
16027c478bd9Sstevel@tonic-gate }
16037c478bd9Sstevel@tonic-gate rtm = (struct rt_msghdr *)msg;
16047c478bd9Sstevel@tonic-gate if (rtm->rtm_version != RTM_VERSION) {
16057c478bd9Sstevel@tonic-gate logmsg(LOG_ERR,
16067c478bd9Sstevel@tonic-gate "process_rtsock: version %d not understood\n",
16077c478bd9Sstevel@tonic-gate rtm->rtm_version);
16087c478bd9Sstevel@tonic-gate return;
16097c478bd9Sstevel@tonic-gate }
16107c478bd9Sstevel@tonic-gate switch (rtm->rtm_type) {
16117c478bd9Sstevel@tonic-gate case RTM_NEWADDR:
16127c478bd9Sstevel@tonic-gate case RTM_DELADDR:
16137c478bd9Sstevel@tonic-gate /*
16147c478bd9Sstevel@tonic-gate * Some logical interface has changed - have to scan
16157c478bd9Sstevel@tonic-gate * everything to determine what actually changed.
16167c478bd9Sstevel@tonic-gate */
16177c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) {
16187c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "process_rtsock: "
16197c478bd9Sstevel@tonic-gate "message %d\n", rtm->rtm_type);
16207c478bd9Sstevel@tonic-gate }
16217c478bd9Sstevel@tonic-gate need_initifs = _B_TRUE;
16227c478bd9Sstevel@tonic-gate break;
16237c478bd9Sstevel@tonic-gate case RTM_IFINFO:
16247c478bd9Sstevel@tonic-gate need_ifscan = _B_TRUE;
16257c478bd9Sstevel@tonic-gate (void) memcpy(ifscan_msg[ifscan_index], rtm,
16267c478bd9Sstevel@tonic-gate sizeof (msg));
16277c478bd9Sstevel@tonic-gate ifscan_index++;
16287c478bd9Sstevel@tonic-gate /* Handled below */
16297c478bd9Sstevel@tonic-gate break;
16307c478bd9Sstevel@tonic-gate default:
16317c478bd9Sstevel@tonic-gate /* Not interesting */
16327c478bd9Sstevel@tonic-gate break;
16337c478bd9Sstevel@tonic-gate }
16347c478bd9Sstevel@tonic-gate }
16357c478bd9Sstevel@tonic-gate /*
16367c478bd9Sstevel@tonic-gate * If we do full scan i.e initifs, we don't need to
16377c478bd9Sstevel@tonic-gate * scan a particular interface as we should have
16387c478bd9Sstevel@tonic-gate * done that as part of initifs.
16397c478bd9Sstevel@tonic-gate */
16407c478bd9Sstevel@tonic-gate if (need_initifs) {
16417c478bd9Sstevel@tonic-gate initifs(_B_FALSE);
16427c478bd9Sstevel@tonic-gate return;
16437c478bd9Sstevel@tonic-gate }
16447c478bd9Sstevel@tonic-gate
16457c478bd9Sstevel@tonic-gate if (!need_ifscan)
16467c478bd9Sstevel@tonic-gate return;
16477c478bd9Sstevel@tonic-gate
16487c478bd9Sstevel@tonic-gate for (i = 0; i < ifscan_index; i++) {
16497c478bd9Sstevel@tonic-gate ifm = (struct if_msghdr *)ifscan_msg[i];
16507c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN)
16517c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "process_rtsock: index %d\n",
16527c478bd9Sstevel@tonic-gate ifm->ifm_index);
16537c478bd9Sstevel@tonic-gate
16547c478bd9Sstevel@tonic-gate pi = phyint_lookup_on_index(ifm->ifm_index);
16557c478bd9Sstevel@tonic-gate if (pi == NULL) {
16567c478bd9Sstevel@tonic-gate /*
16577c478bd9Sstevel@tonic-gate * A new physical interface. Do a full scan of the
16587c478bd9Sstevel@tonic-gate * to catch any new logical interfaces.
16597c478bd9Sstevel@tonic-gate */
16607c478bd9Sstevel@tonic-gate initifs(_B_FALSE);
16617c478bd9Sstevel@tonic-gate return;
16627c478bd9Sstevel@tonic-gate }
16637c478bd9Sstevel@tonic-gate
1664e11c3f44Smeem if (ifm->ifm_flags != (uint_t)pi->pi_flags) {
16657c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) {
16667c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "process_rtsock: clr for "
1667e11c3f44Smeem "%s old flags 0x%llx new flags 0x%x\n",
16687c478bd9Sstevel@tonic-gate pi->pi_name, pi->pi_flags, ifm->ifm_flags);
16697c478bd9Sstevel@tonic-gate }
16707c478bd9Sstevel@tonic-gate }
16717c478bd9Sstevel@tonic-gate
16727c478bd9Sstevel@tonic-gate
16737c478bd9Sstevel@tonic-gate /*
16747c478bd9Sstevel@tonic-gate * Mark the interfaces so that we can find phyints and prefixes
16757c478bd9Sstevel@tonic-gate * which have disappeared from the kernel.
16767c478bd9Sstevel@tonic-gate * if_process will set pr_in_use when it finds the
16777c478bd9Sstevel@tonic-gate * interface in the kernel.
16787c478bd9Sstevel@tonic-gate * Before re-examining the state of the interfaces,
16797c478bd9Sstevel@tonic-gate * PI_PRESENT should be cleared from pi_kernel_state.
16807c478bd9Sstevel@tonic-gate */
16817c478bd9Sstevel@tonic-gate pi->pi_kernel_state &= ~PI_PRESENT;
16827c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) {
16837c478bd9Sstevel@tonic-gate pr->pr_in_use = _B_FALSE;
16847c478bd9Sstevel@tonic-gate }
16857c478bd9Sstevel@tonic-gate
16867c478bd9Sstevel@tonic-gate if (ifsock < 0) {
16877c478bd9Sstevel@tonic-gate ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
16887c478bd9Sstevel@tonic-gate if (ifsock < 0) {
16897c478bd9Sstevel@tonic-gate logperror("process_rtsock: socket");
16907c478bd9Sstevel@tonic-gate return;
16917c478bd9Sstevel@tonic-gate }
16927c478bd9Sstevel@tonic-gate }
16937c478bd9Sstevel@tonic-gate if_process(ifsock, pi->pi_name, _B_FALSE);
16947c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) {
16957c478bd9Sstevel@tonic-gate if_process(ifsock, pr->pr_name, _B_FALSE);
16967c478bd9Sstevel@tonic-gate }
16977c478bd9Sstevel@tonic-gate /*
16987c478bd9Sstevel@tonic-gate * If interface (still) exists in kernel, set
16997c478bd9Sstevel@tonic-gate * pi_state to indicate that.
17007c478bd9Sstevel@tonic-gate */
17017c478bd9Sstevel@tonic-gate if (pi->pi_kernel_state & PI_PRESENT) {
17027c478bd9Sstevel@tonic-gate pi->pi_state |= PI_PRESENT;
17037c478bd9Sstevel@tonic-gate }
17047c478bd9Sstevel@tonic-gate check_if_removed(pi);
17057c478bd9Sstevel@tonic-gate if (show_ifs)
17067c478bd9Sstevel@tonic-gate phyint_print_all();
17077c478bd9Sstevel@tonic-gate }
17087c478bd9Sstevel@tonic-gate }
17097c478bd9Sstevel@tonic-gate
17103173664eSapersson static void
process_mibsock(int mibsock)17113173664eSapersson process_mibsock(int mibsock)
17123173664eSapersson {
17133173664eSapersson struct phyint *pi;
17143173664eSapersson socklen_t fromlen;
17153173664eSapersson struct sockaddr_un from;
17163173664eSapersson ndpd_info_t ndpd_info;
17173173664eSapersson ssize_t len;
17183173664eSapersson int command;
17193173664eSapersson
17203173664eSapersson fromlen = (socklen_t)sizeof (from);
17213173664eSapersson len = recvfrom(mibsock, &command, sizeof (int), 0,
17223173664eSapersson (struct sockaddr *)&from, &fromlen);
17233173664eSapersson
17243173664eSapersson if (len < sizeof (int) || command != NDPD_SNMP_INFO_REQ) {
17253173664eSapersson logperror("process_mibsock: bad command \n");
17263173664eSapersson return;
17273173664eSapersson }
17283173664eSapersson
17293173664eSapersson ndpd_info.info_type = NDPD_SNMP_INFO_RESPONSE;
17303173664eSapersson ndpd_info.info_version = NDPD_SNMP_INFO_VER;
17313173664eSapersson ndpd_info.info_num_of_phyints = num_of_phyints;
17323173664eSapersson
17333173664eSapersson (void) sendto(mibsock, &ndpd_info, sizeof (ndpd_info_t), 0,
17343173664eSapersson (struct sockaddr *)&from, fromlen);
17353173664eSapersson
17363173664eSapersson for (pi = phyints; pi != NULL; pi = pi->pi_next) {
17373173664eSapersson int prefixes;
17383173664eSapersson int routers;
17393173664eSapersson struct prefix *prefix_list;
17403173664eSapersson struct router *router_list;
17413173664eSapersson ndpd_phyint_info_t phyint;
17423173664eSapersson ndpd_prefix_info_t prefix;
17433173664eSapersson ndpd_router_info_t router;
17443173664eSapersson /*
17453173664eSapersson * get number of prefixes
17463173664eSapersson */
17473173664eSapersson routers = 0;
17483173664eSapersson prefixes = 0;
17493173664eSapersson prefix_list = pi->pi_prefix_list;
17503173664eSapersson while (prefix_list != NULL) {
17513173664eSapersson prefixes++;
17523173664eSapersson prefix_list = prefix_list->pr_next;
17533173664eSapersson }
17543173664eSapersson
17553173664eSapersson /*
17563173664eSapersson * get number of routers
17573173664eSapersson */
17583173664eSapersson router_list = pi->pi_router_list;
17593173664eSapersson while (router_list != NULL) {
17603173664eSapersson routers++;
17613173664eSapersson router_list = router_list->dr_next;
17623173664eSapersson }
17633173664eSapersson
17643173664eSapersson phyint.phyint_info_type = NDPD_PHYINT_INFO;
17653173664eSapersson phyint.phyint_info_version = NDPD_PHYINT_INFO_VER;
17663173664eSapersson phyint.phyint_index = pi->pi_index;
17673173664eSapersson bcopy(pi->pi_config,
17683173664eSapersson phyint.phyint_config, I_IFSIZE);
17693173664eSapersson phyint.phyint_num_of_prefixes = prefixes;
17703173664eSapersson phyint.phyint_num_of_routers = routers;
17713173664eSapersson (void) sendto(mibsock, &phyint, sizeof (phyint), 0,
17723173664eSapersson (struct sockaddr *)&from, fromlen);
17733173664eSapersson
17743173664eSapersson /*
17753173664eSapersson * Copy prefix information
17763173664eSapersson */
17773173664eSapersson
17783173664eSapersson prefix_list = pi->pi_prefix_list;
17793173664eSapersson while (prefix_list != NULL) {
17803173664eSapersson prefix.prefix_info_type = NDPD_PREFIX_INFO;
17813173664eSapersson prefix.prefix_info_version = NDPD_PREFIX_INFO_VER;
17823173664eSapersson prefix.prefix_prefix = prefix_list->pr_prefix;
17833173664eSapersson prefix.prefix_len = prefix_list->pr_prefix_len;
17843173664eSapersson prefix.prefix_flags = prefix_list->pr_flags;
17853173664eSapersson prefix.prefix_phyint_index = pi->pi_index;
17863173664eSapersson prefix.prefix_ValidLifetime =
17873173664eSapersson prefix_list->pr_ValidLifetime;
17883173664eSapersson prefix.prefix_PreferredLifetime =
17893173664eSapersson prefix_list->pr_PreferredLifetime;
17903173664eSapersson prefix.prefix_OnLinkLifetime =
17913173664eSapersson prefix_list->pr_OnLinkLifetime;
17923173664eSapersson prefix.prefix_OnLinkFlag =
17933173664eSapersson prefix_list->pr_OnLinkFlag;
17943173664eSapersson prefix.prefix_AutonomousFlag =
17953173664eSapersson prefix_list->pr_AutonomousFlag;
17963173664eSapersson (void) sendto(mibsock, &prefix, sizeof (prefix), 0,
17973173664eSapersson (struct sockaddr *)&from, fromlen);
17983173664eSapersson prefix_list = prefix_list->pr_next;
17993173664eSapersson }
18003173664eSapersson /*
18013173664eSapersson * Copy router information
18023173664eSapersson */
18033173664eSapersson router_list = pi->pi_router_list;
18043173664eSapersson while (router_list != NULL) {
18053173664eSapersson router.router_info_type = NDPD_ROUTER_INFO;
18063173664eSapersson router.router_info_version = NDPD_ROUTER_INFO_VER;
18073173664eSapersson router.router_address = router_list->dr_address;
18083173664eSapersson router.router_lifetime = router_list->dr_lifetime;
18093173664eSapersson router.router_phyint_index = pi->pi_index;
18103173664eSapersson (void) sendto(mibsock, &router, sizeof (router), 0,
18113173664eSapersson (struct sockaddr *)&from, fromlen);
18123173664eSapersson router_list = router_list->dr_next;
18133173664eSapersson }
18143173664eSapersson }
18153173664eSapersson }
18163173664eSapersson
18177c478bd9Sstevel@tonic-gate /*
18187c478bd9Sstevel@tonic-gate * Look if the phyint or one of its prefixes have been removed from
18197c478bd9Sstevel@tonic-gate * the kernel and take appropriate action.
1820e11c3f44Smeem * Uses pr_in_use and pi{,_kernel}_state.
18217c478bd9Sstevel@tonic-gate */
18227c478bd9Sstevel@tonic-gate static void
check_if_removed(struct phyint * pi)18237c478bd9Sstevel@tonic-gate check_if_removed(struct phyint *pi)
18247c478bd9Sstevel@tonic-gate {
1825e11c3f44Smeem struct prefix *pr, *next_pr;
18267c478bd9Sstevel@tonic-gate
18277c478bd9Sstevel@tonic-gate /*
18287c478bd9Sstevel@tonic-gate * Detect prefixes which are removed.
1829e11c3f44Smeem * Static prefixes are just removed from our tables.
1830e11c3f44Smeem * Non-static prefixes are recreated i.e. in.ndpd takes precedence
1831e11c3f44Smeem * over manually removing prefixes via ifconfig.
18327c478bd9Sstevel@tonic-gate */
18337c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
18347c478bd9Sstevel@tonic-gate next_pr = pr->pr_next;
18357c478bd9Sstevel@tonic-gate if (!pr->pr_in_use) {
1836e11c3f44Smeem /* Clear everything except PR_STATIC */
18377c478bd9Sstevel@tonic-gate pr->pr_kernel_state &= PR_STATIC;
18386e91bba0SGirish Moodalbail if (pr->pr_state & PR_STATIC)
18396e91bba0SGirish Moodalbail prefix_update_ipadm_addrobj(pr, _B_FALSE);
1840e11c3f44Smeem pr->pr_name[0] = '\0';
1841e11c3f44Smeem if (pr->pr_state & PR_STATIC) {
18427c478bd9Sstevel@tonic-gate prefix_delete(pr);
1843e11c3f44Smeem } else if (!(pi->pi_kernel_state & PI_PRESENT)) {
1844e11c3f44Smeem /*
1845e11c3f44Smeem * Ensure that there are no future attempts to
1846e11c3f44Smeem * run prefix_update_k since the phyint is gone.
1847e11c3f44Smeem */
1848e11c3f44Smeem pr->pr_state = pr->pr_kernel_state;
1849e11c3f44Smeem } else if (pr->pr_state != pr->pr_kernel_state) {
18507c478bd9Sstevel@tonic-gate logmsg(LOG_INFO, "Prefix manually removed "
1851e11c3f44Smeem "on %s; recreating\n", pi->pi_name);
18527c478bd9Sstevel@tonic-gate prefix_update_k(pr);
18537c478bd9Sstevel@tonic-gate }
18547c478bd9Sstevel@tonic-gate }
18557c478bd9Sstevel@tonic-gate }
1856e11c3f44Smeem
1857e11c3f44Smeem /*
1858e11c3f44Smeem * Detect phyints that have been removed from the kernel, and tear
1859e11c3f44Smeem * down any prefixes we created that are associated with that phyint.
1860e11c3f44Smeem * (NOTE: IPMP depends on in.ndpd tearing down these prefixes so an
1861e11c3f44Smeem * administrator can easily place an IP interface with ADDRCONF'd
1862e11c3f44Smeem * addresses into an IPMP group.)
1863e11c3f44Smeem */
1864e11c3f44Smeem if (!(pi->pi_kernel_state & PI_PRESENT) &&
1865e11c3f44Smeem (pi->pi_state & PI_PRESENT)) {
1866e11c3f44Smeem logmsg(LOG_ERR, "Interface %s has been removed from kernel. "
1867e11c3f44Smeem "in.ndpd will no longer use it\n", pi->pi_name);
1868e11c3f44Smeem
1869e11c3f44Smeem for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
1870e11c3f44Smeem next_pr = pr->pr_next;
1871e11c3f44Smeem if (pr->pr_state & PR_AUTO)
18726e91bba0SGirish Moodalbail prefix_update_ipadm_addrobj(pr, _B_FALSE);
1873e6301a35SToomas Soome prefix_delete(pr);
1874e11c3f44Smeem }
1875e11c3f44Smeem
1876e11c3f44Smeem /*
1877e11c3f44Smeem * Clear state so that should the phyint reappear we will
1878e11c3f44Smeem * start with initial advertisements or solicitations.
1879e11c3f44Smeem */
1880e11c3f44Smeem phyint_cleanup(pi);
1881e11c3f44Smeem }
18827c478bd9Sstevel@tonic-gate }
18837c478bd9Sstevel@tonic-gate
18847c478bd9Sstevel@tonic-gate
18857c478bd9Sstevel@tonic-gate /*
18867c478bd9Sstevel@tonic-gate * Queuing mechanism for router advertisements that are sent by in.ndpd
18877c478bd9Sstevel@tonic-gate * and that also need to be processed by in.ndpd.
18887c478bd9Sstevel@tonic-gate * Uses "signal number" 255 to indicate to the main poll loop
18897c478bd9Sstevel@tonic-gate * that there is something to dequeue and send to incomining_ra().
18907c478bd9Sstevel@tonic-gate */
18917c478bd9Sstevel@tonic-gate struct raq {
18927c478bd9Sstevel@tonic-gate struct raq *raq_next;
18937c478bd9Sstevel@tonic-gate struct phyint *raq_pi;
18947c478bd9Sstevel@tonic-gate int raq_packetlen;
18957c478bd9Sstevel@tonic-gate uchar_t *raq_packet;
18967c478bd9Sstevel@tonic-gate };
18977c478bd9Sstevel@tonic-gate static struct raq *raq_head = NULL;
18987c478bd9Sstevel@tonic-gate
18997c478bd9Sstevel@tonic-gate /*
19007c478bd9Sstevel@tonic-gate * Allocate a struct raq and memory for the packet.
19017c478bd9Sstevel@tonic-gate * Send signal 255 to have poll dequeue.
19027c478bd9Sstevel@tonic-gate */
19037c478bd9Sstevel@tonic-gate static void
loopback_ra_enqueue(struct phyint * pi,struct nd_router_advert * ra,int len)19047c478bd9Sstevel@tonic-gate loopback_ra_enqueue(struct phyint *pi, struct nd_router_advert *ra, int len)
19057c478bd9Sstevel@tonic-gate {
19067c478bd9Sstevel@tonic-gate struct raq *raq;
19077c478bd9Sstevel@tonic-gate struct raq **raqp;
19087c478bd9Sstevel@tonic-gate
19097c478bd9Sstevel@tonic-gate if (no_loopback)
19107c478bd9Sstevel@tonic-gate return;
19117c478bd9Sstevel@tonic-gate
19127c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT)
19137c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "loopback_ra_enqueue for %s\n", pi->pi_name);
19147c478bd9Sstevel@tonic-gate
19157c478bd9Sstevel@tonic-gate raq = calloc(sizeof (struct raq), 1);
19167c478bd9Sstevel@tonic-gate if (raq == NULL) {
19177c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "loopback_ra_enqueue: out of memory\n");
19187c478bd9Sstevel@tonic-gate return;
19197c478bd9Sstevel@tonic-gate }
19207c478bd9Sstevel@tonic-gate raq->raq_packet = malloc(len);
19217c478bd9Sstevel@tonic-gate if (raq->raq_packet == NULL) {
19227c478bd9Sstevel@tonic-gate free(raq);
19237c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "loopback_ra_enqueue: out of memory\n");
19247c478bd9Sstevel@tonic-gate return;
19257c478bd9Sstevel@tonic-gate }
19267c478bd9Sstevel@tonic-gate bcopy(ra, raq->raq_packet, len);
19277c478bd9Sstevel@tonic-gate raq->raq_packetlen = len;
19287c478bd9Sstevel@tonic-gate raq->raq_pi = pi;
19297c478bd9Sstevel@tonic-gate
19307c478bd9Sstevel@tonic-gate /* Tail insert */
19317c478bd9Sstevel@tonic-gate raqp = &raq_head;
19327c478bd9Sstevel@tonic-gate while (*raqp != NULL)
19337c478bd9Sstevel@tonic-gate raqp = &((*raqp)->raq_next);
19347c478bd9Sstevel@tonic-gate *raqp = raq;
19357c478bd9Sstevel@tonic-gate
19367c478bd9Sstevel@tonic-gate /* Signal for poll loop */
19377c478bd9Sstevel@tonic-gate sig_handler(255);
19387c478bd9Sstevel@tonic-gate }
19397c478bd9Sstevel@tonic-gate
19407c478bd9Sstevel@tonic-gate /*
19417c478bd9Sstevel@tonic-gate * Dequeue and process all queued advertisements.
19427c478bd9Sstevel@tonic-gate */
19437c478bd9Sstevel@tonic-gate static void
loopback_ra_dequeue(void)19447c478bd9Sstevel@tonic-gate loopback_ra_dequeue(void)
19457c478bd9Sstevel@tonic-gate {
19467c478bd9Sstevel@tonic-gate struct sockaddr_in6 from = IN6ADDR_LOOPBACK_INIT;
19477c478bd9Sstevel@tonic-gate struct raq *raq;
19487c478bd9Sstevel@tonic-gate
19497c478bd9Sstevel@tonic-gate if (debug & D_PKTIN)
19507c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "loopback_ra_dequeue()\n");
19517c478bd9Sstevel@tonic-gate
19527c478bd9Sstevel@tonic-gate while ((raq = raq_head) != NULL) {
19537c478bd9Sstevel@tonic-gate raq_head = raq->raq_next;
19547c478bd9Sstevel@tonic-gate raq->raq_next = NULL;
19557c478bd9Sstevel@tonic-gate
19567c478bd9Sstevel@tonic-gate if (debug & D_PKTIN) {
19577c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "loopback_ra_dequeue for %s\n",
19587c478bd9Sstevel@tonic-gate raq->raq_pi->pi_name);
19597c478bd9Sstevel@tonic-gate }
19607c478bd9Sstevel@tonic-gate
19617c478bd9Sstevel@tonic-gate incoming_ra(raq->raq_pi,
19627c478bd9Sstevel@tonic-gate (struct nd_router_advert *)raq->raq_packet,
19637c478bd9Sstevel@tonic-gate raq->raq_packetlen, &from, _B_TRUE);
19647c478bd9Sstevel@tonic-gate free(raq->raq_packet);
19657c478bd9Sstevel@tonic-gate free(raq);
19667c478bd9Sstevel@tonic-gate }
19677c478bd9Sstevel@tonic-gate }
19687c478bd9Sstevel@tonic-gate
19697c478bd9Sstevel@tonic-gate
19707c478bd9Sstevel@tonic-gate static void
usage(char * cmd)19717c478bd9Sstevel@tonic-gate usage(char *cmd)
19727c478bd9Sstevel@tonic-gate {
19737c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
19747c478bd9Sstevel@tonic-gate "usage: %s [ -adt ] [-f <config file>]\n", cmd);
19757c478bd9Sstevel@tonic-gate }
19767c478bd9Sstevel@tonic-gate
19777c478bd9Sstevel@tonic-gate int
main(int argc,char * argv[])19787c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
19797c478bd9Sstevel@tonic-gate {
19807c478bd9Sstevel@tonic-gate int i;
19817c478bd9Sstevel@tonic-gate struct phyint *pi;
19827c478bd9Sstevel@tonic-gate int c;
19837c478bd9Sstevel@tonic-gate char *config_file = PATH_NDPD_CONF;
19847c478bd9Sstevel@tonic-gate boolean_t file_required = _B_FALSE;
19857c478bd9Sstevel@tonic-gate
19867c478bd9Sstevel@tonic-gate argv0 = argv;
19877c478bd9Sstevel@tonic-gate srandom(gethostid());
19887c478bd9Sstevel@tonic-gate (void) umask(0022);
19897c478bd9Sstevel@tonic-gate
19907c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "adD:ntIf:")) != EOF) {
19917c478bd9Sstevel@tonic-gate switch (c) {
19927c478bd9Sstevel@tonic-gate case 'a':
19937c478bd9Sstevel@tonic-gate /*
19947c478bd9Sstevel@tonic-gate * The StatelessAddrConf variable in ndpd.conf, if
19957c478bd9Sstevel@tonic-gate * present, will override this setting.
19967c478bd9Sstevel@tonic-gate */
19977c478bd9Sstevel@tonic-gate ifdefaults[I_StatelessAddrConf].cf_value = 0;
19987c478bd9Sstevel@tonic-gate break;
19997c478bd9Sstevel@tonic-gate case 'd':
20007c478bd9Sstevel@tonic-gate debug = D_ALL;
20017c478bd9Sstevel@tonic-gate break;
20027c478bd9Sstevel@tonic-gate case 'D':
20037c478bd9Sstevel@tonic-gate i = strtol((char *)optarg, NULL, 0);
20047c478bd9Sstevel@tonic-gate if (i == 0) {
20057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "Bad debug flags: %s\n",
20067c478bd9Sstevel@tonic-gate (char *)optarg);
20077c478bd9Sstevel@tonic-gate exit(1);
20087c478bd9Sstevel@tonic-gate }
20097c478bd9Sstevel@tonic-gate debug |= i;
20107c478bd9Sstevel@tonic-gate break;
20117c478bd9Sstevel@tonic-gate case 'n':
20127c478bd9Sstevel@tonic-gate no_loopback = 1;
20137c478bd9Sstevel@tonic-gate break;
20147c478bd9Sstevel@tonic-gate case 'I':
20157c478bd9Sstevel@tonic-gate show_ifs = 1;
20167c478bd9Sstevel@tonic-gate break;
20177c478bd9Sstevel@tonic-gate case 't':
20187c478bd9Sstevel@tonic-gate debug |= D_PKTIN | D_PKTOUT | D_PKTBAD;
20197c478bd9Sstevel@tonic-gate break;
20207c478bd9Sstevel@tonic-gate case 'f':
20217c478bd9Sstevel@tonic-gate config_file = (char *)optarg;
20227c478bd9Sstevel@tonic-gate file_required = _B_TRUE;
20237c478bd9Sstevel@tonic-gate break;
20247c478bd9Sstevel@tonic-gate case '?':
20257c478bd9Sstevel@tonic-gate usage(argv[0]);
20267c478bd9Sstevel@tonic-gate exit(1);
20277c478bd9Sstevel@tonic-gate }
20287c478bd9Sstevel@tonic-gate }
20297c478bd9Sstevel@tonic-gate
20307c478bd9Sstevel@tonic-gate if (parse_config(config_file, file_required) == -1)
20317c478bd9Sstevel@tonic-gate exit(2);
20327c478bd9Sstevel@tonic-gate
20337c478bd9Sstevel@tonic-gate if (show_ifs)
20347c478bd9Sstevel@tonic-gate phyint_print_all();
20357c478bd9Sstevel@tonic-gate
20366e91bba0SGirish Moodalbail if (debug == 0)
20377c478bd9Sstevel@tonic-gate initlog();
20387c478bd9Sstevel@tonic-gate
20396e91bba0SGirish Moodalbail cmdsock = ndpd_setup_cmd_listener();
20407c478bd9Sstevel@tonic-gate setup_eventpipe();
20417c478bd9Sstevel@tonic-gate rtsock = setup_rtsock();
20423173664eSapersson mibsock = setup_mibsock();
20437c478bd9Sstevel@tonic-gate timer_init();
20447c478bd9Sstevel@tonic-gate initifs(_B_TRUE);
20457c478bd9Sstevel@tonic-gate
20467c478bd9Sstevel@tonic-gate check_daemonize();
20477c478bd9Sstevel@tonic-gate
20487c478bd9Sstevel@tonic-gate for (;;) {
20497c478bd9Sstevel@tonic-gate if (poll(pollfds, pollfd_num, -1) < 0) {
20507c478bd9Sstevel@tonic-gate if (errno == EINTR)
20517c478bd9Sstevel@tonic-gate continue;
20527c478bd9Sstevel@tonic-gate logperror("main: poll");
20537c478bd9Sstevel@tonic-gate exit(1);
20547c478bd9Sstevel@tonic-gate }
20557c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) {
20567c478bd9Sstevel@tonic-gate if (!(pollfds[i].revents & POLLIN))
20577c478bd9Sstevel@tonic-gate continue;
20587c478bd9Sstevel@tonic-gate if (pollfds[i].fd == eventpipe_read) {
20597c478bd9Sstevel@tonic-gate in_signal(eventpipe_read);
20607c478bd9Sstevel@tonic-gate break;
20617c478bd9Sstevel@tonic-gate }
20627c478bd9Sstevel@tonic-gate if (pollfds[i].fd == rtsock) {
20637c478bd9Sstevel@tonic-gate process_rtsock(rtsock);
20647c478bd9Sstevel@tonic-gate break;
20657c478bd9Sstevel@tonic-gate }
20663173664eSapersson if (pollfds[i].fd == mibsock) {
20673173664eSapersson process_mibsock(mibsock);
20683173664eSapersson break;
20693173664eSapersson }
20706e91bba0SGirish Moodalbail if (pollfds[i].fd == cmdsock) {
20716e91bba0SGirish Moodalbail ndpd_cmd_handler(cmdsock);
20726e91bba0SGirish Moodalbail break;
20736e91bba0SGirish Moodalbail }
20747c478bd9Sstevel@tonic-gate /*
20757c478bd9Sstevel@tonic-gate * Run timer routine to advance clock if more than
20767c478bd9Sstevel@tonic-gate * half a second since the clock was advanced.
20777c478bd9Sstevel@tonic-gate * This limits CPU usage under severe packet
20787c478bd9Sstevel@tonic-gate * arrival rates but it creates a slight inaccuracy
20797c478bd9Sstevel@tonic-gate * in the timer mechanism.
20807c478bd9Sstevel@tonic-gate */
20817c478bd9Sstevel@tonic-gate conditional_run_timeouts(500U);
20827c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) {
20837c478bd9Sstevel@tonic-gate if (pollfds[i].fd == pi->pi_sock) {
20847c478bd9Sstevel@tonic-gate in_data(pi);
20857c478bd9Sstevel@tonic-gate break;
20867c478bd9Sstevel@tonic-gate }
20877c478bd9Sstevel@tonic-gate }
20887c478bd9Sstevel@tonic-gate }
20897c478bd9Sstevel@tonic-gate }
20907c478bd9Sstevel@tonic-gate /* NOTREACHED */
20917c478bd9Sstevel@tonic-gate return (0);
20927c478bd9Sstevel@tonic-gate }
20937c478bd9Sstevel@tonic-gate
20947c478bd9Sstevel@tonic-gate /*
20957c478bd9Sstevel@tonic-gate * LOGGER
20967c478bd9Sstevel@tonic-gate */
20977c478bd9Sstevel@tonic-gate
20987c478bd9Sstevel@tonic-gate static boolean_t logging = _B_FALSE;
20997c478bd9Sstevel@tonic-gate
21007c478bd9Sstevel@tonic-gate static void
initlog(void)21017c478bd9Sstevel@tonic-gate initlog(void)
21027c478bd9Sstevel@tonic-gate {
21037c478bd9Sstevel@tonic-gate logging = _B_TRUE;
21047c478bd9Sstevel@tonic-gate openlog("in.ndpd", LOG_PID | LOG_CONS, LOG_DAEMON);
21057c478bd9Sstevel@tonic-gate }
21067c478bd9Sstevel@tonic-gate
21077c478bd9Sstevel@tonic-gate /* Print the date/time without a trailing carridge return */
21087c478bd9Sstevel@tonic-gate static void
fprintdate(FILE * file)21097c478bd9Sstevel@tonic-gate fprintdate(FILE *file)
21107c478bd9Sstevel@tonic-gate {
21117c478bd9Sstevel@tonic-gate char buf[BUFSIZ];
21127c478bd9Sstevel@tonic-gate struct tm tms;
21137c478bd9Sstevel@tonic-gate time_t now;
21147c478bd9Sstevel@tonic-gate
21157c478bd9Sstevel@tonic-gate now = time(NULL);
21167c478bd9Sstevel@tonic-gate (void) localtime_r(&now, &tms);
21177c478bd9Sstevel@tonic-gate (void) strftime(buf, sizeof (buf), "%h %d %X", &tms);
21187c478bd9Sstevel@tonic-gate (void) fprintf(file, "%s ", buf);
21197c478bd9Sstevel@tonic-gate }
21207c478bd9Sstevel@tonic-gate
212169bb4bb4Scarlsonj /* PRINTFLIKE2 */
21227c478bd9Sstevel@tonic-gate void
logmsg(int level,const char * fmt,...)2123b0f490f4Smh logmsg(int level, const char *fmt, ...)
21247c478bd9Sstevel@tonic-gate {
21257c478bd9Sstevel@tonic-gate va_list ap;
21267c478bd9Sstevel@tonic-gate va_start(ap, fmt);
21277c478bd9Sstevel@tonic-gate
21287c478bd9Sstevel@tonic-gate if (logging) {
21297c478bd9Sstevel@tonic-gate vsyslog(level, fmt, ap);
21307c478bd9Sstevel@tonic-gate } else {
21317c478bd9Sstevel@tonic-gate fprintdate(stderr);
21327c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, ap);
21337c478bd9Sstevel@tonic-gate }
21347c478bd9Sstevel@tonic-gate va_end(ap);
21357c478bd9Sstevel@tonic-gate }
21367c478bd9Sstevel@tonic-gate
21377c478bd9Sstevel@tonic-gate void
logperror(const char * str)2138b0f490f4Smh logperror(const char *str)
21397c478bd9Sstevel@tonic-gate {
21407c478bd9Sstevel@tonic-gate if (logging) {
21417c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "%s: %m\n", str);
21427c478bd9Sstevel@tonic-gate } else {
21437c478bd9Sstevel@tonic-gate fprintdate(stderr);
21447c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s\n", str, strerror(errno));
21457c478bd9Sstevel@tonic-gate }
21467c478bd9Sstevel@tonic-gate }
21477c478bd9Sstevel@tonic-gate
21487c478bd9Sstevel@tonic-gate void
logperror_pi(const struct phyint * pi,const char * str)2149b0f490f4Smh logperror_pi(const struct phyint *pi, const char *str)
21507c478bd9Sstevel@tonic-gate {
21517c478bd9Sstevel@tonic-gate if (logging) {
21527c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "%s (interface %s): %m\n",
21537c478bd9Sstevel@tonic-gate str, pi->pi_name);
21547c478bd9Sstevel@tonic-gate } else {
21557c478bd9Sstevel@tonic-gate fprintdate(stderr);
21567c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s (interface %s): %s\n",
21577c478bd9Sstevel@tonic-gate str, pi->pi_name, strerror(errno));
21587c478bd9Sstevel@tonic-gate }
21597c478bd9Sstevel@tonic-gate }
21607c478bd9Sstevel@tonic-gate
21617c478bd9Sstevel@tonic-gate void
logperror_pr(const struct prefix * pr,const char * str)2162b0f490f4Smh logperror_pr(const struct prefix *pr, const char *str)
21637c478bd9Sstevel@tonic-gate {
21647c478bd9Sstevel@tonic-gate if (logging) {
21657c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "%s (prefix %s if %s): %m\n",
21667c478bd9Sstevel@tonic-gate str, pr->pr_name, pr->pr_physical->pi_name);
21677c478bd9Sstevel@tonic-gate } else {
21687c478bd9Sstevel@tonic-gate fprintdate(stderr);
21697c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s (prefix %s if %s): %s\n",
21707c478bd9Sstevel@tonic-gate str, pr->pr_name, pr->pr_physical->pi_name,
21717c478bd9Sstevel@tonic-gate strerror(errno));
21727c478bd9Sstevel@tonic-gate }
21737c478bd9Sstevel@tonic-gate }
21746e91bba0SGirish Moodalbail
21756e91bba0SGirish Moodalbail static int
ndpd_setup_cmd_listener(void)21766e91bba0SGirish Moodalbail ndpd_setup_cmd_listener(void)
21776e91bba0SGirish Moodalbail {
21786e91bba0SGirish Moodalbail int sock;
21796e91bba0SGirish Moodalbail int ret;
21806e91bba0SGirish Moodalbail struct sockaddr_un servaddr;
21816e91bba0SGirish Moodalbail
21826e91bba0SGirish Moodalbail sock = socket(AF_UNIX, SOCK_STREAM, 0);
21836e91bba0SGirish Moodalbail if (sock < 0) {
21846e91bba0SGirish Moodalbail logperror("socket");
21856e91bba0SGirish Moodalbail exit(1);
21866e91bba0SGirish Moodalbail }
21876e91bba0SGirish Moodalbail
21886e91bba0SGirish Moodalbail bzero(&servaddr, sizeof (servaddr));
21896e91bba0SGirish Moodalbail servaddr.sun_family = AF_UNIX;
21906e91bba0SGirish Moodalbail (void) strlcpy(servaddr.sun_path, IPADM_UDS_PATH,
21916e91bba0SGirish Moodalbail sizeof (servaddr.sun_path));
21926e91bba0SGirish Moodalbail (void) unlink(servaddr.sun_path);
21936e91bba0SGirish Moodalbail ret = bind(sock, (struct sockaddr *)&servaddr, sizeof (servaddr));
21946e91bba0SGirish Moodalbail if (ret < 0) {
21956e91bba0SGirish Moodalbail logperror("bind");
21966e91bba0SGirish Moodalbail exit(1);
21976e91bba0SGirish Moodalbail }
21986e91bba0SGirish Moodalbail if (listen(sock, 30) < 0) {
21996e91bba0SGirish Moodalbail logperror("listen");
22006e91bba0SGirish Moodalbail exit(1);
22016e91bba0SGirish Moodalbail }
22026e91bba0SGirish Moodalbail if (poll_add(sock) == -1) {
22036e91bba0SGirish Moodalbail logmsg(LOG_ERR, "command socket could not be added to the "
22046e91bba0SGirish Moodalbail "polling set\n");
22056e91bba0SGirish Moodalbail exit(1);
22066e91bba0SGirish Moodalbail }
22076e91bba0SGirish Moodalbail
22086e91bba0SGirish Moodalbail return (sock);
22096e91bba0SGirish Moodalbail }
22106e91bba0SGirish Moodalbail
22116e91bba0SGirish Moodalbail /*
22126e91bba0SGirish Moodalbail * Commands received over the command socket come here
22136e91bba0SGirish Moodalbail */
22146e91bba0SGirish Moodalbail static void
ndpd_cmd_handler(int sock)22156e91bba0SGirish Moodalbail ndpd_cmd_handler(int sock)
22166e91bba0SGirish Moodalbail {
22176e91bba0SGirish Moodalbail int newfd;
22186e91bba0SGirish Moodalbail struct sockaddr_storage peer;
22196e91bba0SGirish Moodalbail socklen_t peerlen;
22206e91bba0SGirish Moodalbail ipadm_ndpd_msg_t ndpd_msg;
22216e91bba0SGirish Moodalbail int retval;
22226e91bba0SGirish Moodalbail
22236e91bba0SGirish Moodalbail peerlen = sizeof (peer);
22246e91bba0SGirish Moodalbail newfd = accept(sock, (struct sockaddr *)&peer, &peerlen);
22256e91bba0SGirish Moodalbail if (newfd < 0) {
22266e91bba0SGirish Moodalbail logperror("accept");
22276e91bba0SGirish Moodalbail return;
22286e91bba0SGirish Moodalbail }
22296e91bba0SGirish Moodalbail
22306e91bba0SGirish Moodalbail retval = ipadm_ndpd_read(newfd, &ndpd_msg, sizeof (ndpd_msg));
22316e91bba0SGirish Moodalbail if (retval != 0)
22326e91bba0SGirish Moodalbail logperror("Could not read ndpd command");
22336e91bba0SGirish Moodalbail
22346e91bba0SGirish Moodalbail retval = ndpd_process_cmd(newfd, &ndpd_msg);
22356e91bba0SGirish Moodalbail if (retval != 0) {
22366e91bba0SGirish Moodalbail logmsg(LOG_ERR, "ndpd command on interface %s failed with "
22376e91bba0SGirish Moodalbail "error %s\n", ndpd_msg.inm_ifname, strerror(retval));
22386e91bba0SGirish Moodalbail }
22396e91bba0SGirish Moodalbail (void) close(newfd);
22406e91bba0SGirish Moodalbail }
22416e91bba0SGirish Moodalbail
22426e91bba0SGirish Moodalbail /*
22436e91bba0SGirish Moodalbail * Process the commands received from the cmd listener socket.
22446e91bba0SGirish Moodalbail */
22456e91bba0SGirish Moodalbail static int
ndpd_process_cmd(int newfd,ipadm_ndpd_msg_t * msg)22466e91bba0SGirish Moodalbail ndpd_process_cmd(int newfd, ipadm_ndpd_msg_t *msg)
22476e91bba0SGirish Moodalbail {
22486e91bba0SGirish Moodalbail int err;
22496e91bba0SGirish Moodalbail
22506e91bba0SGirish Moodalbail if (!ipadm_check_auth()) {
22516e91bba0SGirish Moodalbail logmsg(LOG_ERR, "User not authorized to send the command\n");
22526e91bba0SGirish Moodalbail (void) ndpd_send_error(newfd, EPERM);
22536e91bba0SGirish Moodalbail return (EPERM);
22546e91bba0SGirish Moodalbail }
22556e91bba0SGirish Moodalbail switch (msg->inm_cmd) {
22566e91bba0SGirish Moodalbail case IPADM_DISABLE_AUTOCONF:
22576e91bba0SGirish Moodalbail err = ndpd_set_autoconf(msg->inm_ifname, _B_FALSE);
22586e91bba0SGirish Moodalbail break;
22596e91bba0SGirish Moodalbail
22606e91bba0SGirish Moodalbail case IPADM_ENABLE_AUTOCONF:
22616e91bba0SGirish Moodalbail err = ndpd_set_autoconf(msg->inm_ifname, _B_TRUE);
22626e91bba0SGirish Moodalbail break;
22636e91bba0SGirish Moodalbail
22646e91bba0SGirish Moodalbail case IPADM_CREATE_ADDRS:
22656e91bba0SGirish Moodalbail err = ndpd_create_addrs(msg->inm_ifname, msg->inm_intfid,
22666e91bba0SGirish Moodalbail msg->inm_intfidlen, msg->inm_stateless,
22676e91bba0SGirish Moodalbail msg->inm_stateful, msg->inm_aobjname);
22686e91bba0SGirish Moodalbail break;
22696e91bba0SGirish Moodalbail
22706e91bba0SGirish Moodalbail case IPADM_DELETE_ADDRS:
22716e91bba0SGirish Moodalbail err = ndpd_delete_addrs(msg->inm_ifname);
22726e91bba0SGirish Moodalbail break;
22736e91bba0SGirish Moodalbail
22746e91bba0SGirish Moodalbail default:
22756e91bba0SGirish Moodalbail err = EINVAL;
22766e91bba0SGirish Moodalbail break;
22776e91bba0SGirish Moodalbail }
22786e91bba0SGirish Moodalbail
22796e91bba0SGirish Moodalbail (void) ndpd_send_error(newfd, err);
22806e91bba0SGirish Moodalbail
22816e91bba0SGirish Moodalbail return (err);
22826e91bba0SGirish Moodalbail }
22836e91bba0SGirish Moodalbail
22846e91bba0SGirish Moodalbail static int
ndpd_send_error(int fd,int error)22856e91bba0SGirish Moodalbail ndpd_send_error(int fd, int error)
22866e91bba0SGirish Moodalbail {
22876e91bba0SGirish Moodalbail return (ipadm_ndpd_write(fd, &error, sizeof (error)));
22886e91bba0SGirish Moodalbail }
22896e91bba0SGirish Moodalbail
22906e91bba0SGirish Moodalbail /*
22916e91bba0SGirish Moodalbail * Disables/Enables autoconfiguration of addresses on the
22926e91bba0SGirish Moodalbail * given physical interface.
22936e91bba0SGirish Moodalbail * This is provided to support the legacy method of configuring IPv6
22946e91bba0SGirish Moodalbail * addresses. i.e. `ifconfig bge0 inet6 plumb` will plumb the interface
22956e91bba0SGirish Moodalbail * and start stateless and stateful autoconfiguration. If this function is
22966e91bba0SGirish Moodalbail * not called with enable=_B_FALSE, no autoconfiguration will be done until
22976e91bba0SGirish Moodalbail * ndpd_create_addrs() is called with an Interface ID.
22986e91bba0SGirish Moodalbail */
22996e91bba0SGirish Moodalbail static int
ndpd_set_autoconf(const char * ifname,boolean_t enable)23006e91bba0SGirish Moodalbail ndpd_set_autoconf(const char *ifname, boolean_t enable)
23016e91bba0SGirish Moodalbail {
23026e91bba0SGirish Moodalbail struct phyint *pi;
23036e91bba0SGirish Moodalbail
23046e91bba0SGirish Moodalbail pi = phyint_lookup((char *)ifname);
23056e91bba0SGirish Moodalbail if (pi == NULL) {
23066e91bba0SGirish Moodalbail /*
23076e91bba0SGirish Moodalbail * If the physical interface was plumbed but no
23086e91bba0SGirish Moodalbail * addresses were configured yet, phyint will not exist.
23096e91bba0SGirish Moodalbail */
23106e91bba0SGirish Moodalbail pi = phyint_create((char *)ifname);
23116e91bba0SGirish Moodalbail if (pi == NULL) {
23126e91bba0SGirish Moodalbail logmsg(LOG_ERR, "could not create phyint for "
23136e91bba0SGirish Moodalbail "interface %s", ifname);
23146e91bba0SGirish Moodalbail return (ENOMEM);
23156e91bba0SGirish Moodalbail }
23166e91bba0SGirish Moodalbail }
23176e91bba0SGirish Moodalbail pi->pi_autoconf = enable;
23186e91bba0SGirish Moodalbail
23196e91bba0SGirish Moodalbail if (debug & D_PHYINT) {
23206e91bba0SGirish Moodalbail logmsg(LOG_DEBUG, "ndpd_set_autoconf: %s autoconf for "
23216e91bba0SGirish Moodalbail "interface %s\n", (enable ? "enabled" : "disabled"),
23226e91bba0SGirish Moodalbail pi->pi_name);
23236e91bba0SGirish Moodalbail }
23246e91bba0SGirish Moodalbail return (0);
23256e91bba0SGirish Moodalbail }
23266e91bba0SGirish Moodalbail
23276e91bba0SGirish Moodalbail /*
23286e91bba0SGirish Moodalbail * Create auto-configured addresses on the given interface using
23296e91bba0SGirish Moodalbail * the given token as the interface id during the next Router Advertisement.
23306e91bba0SGirish Moodalbail * Currently, only one token per interface is supported.
23316e91bba0SGirish Moodalbail */
23326e91bba0SGirish Moodalbail static int
ndpd_create_addrs(const char * ifname,struct sockaddr_in6 intfid,int intfidlen,boolean_t stateless,boolean_t stateful,char * addrobj)23336e91bba0SGirish Moodalbail ndpd_create_addrs(const char *ifname, struct sockaddr_in6 intfid, int intfidlen,
23346e91bba0SGirish Moodalbail boolean_t stateless, boolean_t stateful, char *addrobj)
23356e91bba0SGirish Moodalbail {
23366e91bba0SGirish Moodalbail struct phyint *pi;
23376e91bba0SGirish Moodalbail struct lifreq lifr;
23386e91bba0SGirish Moodalbail struct sockaddr_in6 *sin6;
23396e91bba0SGirish Moodalbail int err;
23406e91bba0SGirish Moodalbail
23416e91bba0SGirish Moodalbail pi = phyint_lookup((char *)ifname);
23426e91bba0SGirish Moodalbail if (pi == NULL) {
23436e91bba0SGirish Moodalbail /*
23446e91bba0SGirish Moodalbail * If the physical interface was plumbed but no
23456e91bba0SGirish Moodalbail * addresses were configured yet, phyint will not exist.
23466e91bba0SGirish Moodalbail */
23476e91bba0SGirish Moodalbail pi = phyint_create((char *)ifname);
23486e91bba0SGirish Moodalbail if (pi == NULL) {
23496e91bba0SGirish Moodalbail if (debug & D_PHYINT)
23506e91bba0SGirish Moodalbail logmsg(LOG_ERR, "could not create phyint "
23516e91bba0SGirish Moodalbail "for interface %s", ifname);
23526e91bba0SGirish Moodalbail return (ENOMEM);
23536e91bba0SGirish Moodalbail }
23546e91bba0SGirish Moodalbail } else if (pi->pi_autoconf) {
23556e91bba0SGirish Moodalbail logmsg(LOG_ERR, "autoconfiguration already in progress\n");
23566e91bba0SGirish Moodalbail return (EEXIST);
23576e91bba0SGirish Moodalbail }
23586e91bba0SGirish Moodalbail check_autoconf_var_consistency(pi, stateless, stateful);
23596e91bba0SGirish Moodalbail
23606e91bba0SGirish Moodalbail if (intfidlen == 0) {
23616e91bba0SGirish Moodalbail pi->pi_default_token = _B_TRUE;
23626e91bba0SGirish Moodalbail if (ifsock < 0) {
23636e91bba0SGirish Moodalbail ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
23646e91bba0SGirish Moodalbail if (ifsock < 0) {
23656e91bba0SGirish Moodalbail err = errno;
23666e91bba0SGirish Moodalbail logperror("ndpd_create_addrs: socket");
23676e91bba0SGirish Moodalbail return (err);
23686e91bba0SGirish Moodalbail }
23696e91bba0SGirish Moodalbail }
23706e91bba0SGirish Moodalbail (void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
23716e91bba0SGirish Moodalbail sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
23726e91bba0SGirish Moodalbail if (ioctl(ifsock, SIOCGLIFTOKEN, (char *)&lifr) < 0) {
23736e91bba0SGirish Moodalbail err = errno;
23746e91bba0SGirish Moodalbail logperror("SIOCGLIFTOKEN");
23756e91bba0SGirish Moodalbail return (err);
23766e91bba0SGirish Moodalbail }
23776e91bba0SGirish Moodalbail pi->pi_token = sin6->sin6_addr;
23786e91bba0SGirish Moodalbail pi->pi_token_length = lifr.lifr_addrlen;
23796e91bba0SGirish Moodalbail } else {
23806e91bba0SGirish Moodalbail pi->pi_default_token = _B_FALSE;
23816e91bba0SGirish Moodalbail pi->pi_token = intfid.sin6_addr;
23826e91bba0SGirish Moodalbail pi->pi_token_length = intfidlen;
23836e91bba0SGirish Moodalbail }
23846e91bba0SGirish Moodalbail pi->pi_stateless = stateless;
23856e91bba0SGirish Moodalbail pi->pi_stateful = stateful;
23866e91bba0SGirish Moodalbail (void) strlcpy(pi->pi_ipadm_aobjname, addrobj,
23876e91bba0SGirish Moodalbail sizeof (pi->pi_ipadm_aobjname));
23886e91bba0SGirish Moodalbail
23896e91bba0SGirish Moodalbail /* We can allow autoconfiguration now. */
23906e91bba0SGirish Moodalbail pi->pi_autoconf = _B_TRUE;
23916e91bba0SGirish Moodalbail
23926e91bba0SGirish Moodalbail /* Restart the solicitations. */
23936e91bba0SGirish Moodalbail if (pi->pi_sol_state == DONE_SOLICIT)
23946e91bba0SGirish Moodalbail pi->pi_sol_state = NO_SOLICIT;
23956e91bba0SGirish Moodalbail if (pi->pi_sol_state == NO_SOLICIT)
23966e91bba0SGirish Moodalbail check_to_solicit(pi, START_INIT_SOLICIT);
23976e91bba0SGirish Moodalbail if (debug & D_PHYINT)
23986e91bba0SGirish Moodalbail logmsg(LOG_DEBUG, "ndpd_create_addrs: "
23996e91bba0SGirish Moodalbail "added token to interface %s\n", pi->pi_name);
24006e91bba0SGirish Moodalbail return (0);
24016e91bba0SGirish Moodalbail }
24026e91bba0SGirish Moodalbail
24036e91bba0SGirish Moodalbail /*
24046e91bba0SGirish Moodalbail * This function deletes all addresses on the given interface
24056e91bba0SGirish Moodalbail * with the given Interface ID.
24066e91bba0SGirish Moodalbail */
24076e91bba0SGirish Moodalbail static int
ndpd_delete_addrs(const char * ifname)24086e91bba0SGirish Moodalbail ndpd_delete_addrs(const char *ifname)
24096e91bba0SGirish Moodalbail {
24106e91bba0SGirish Moodalbail struct phyint *pi;
24116e91bba0SGirish Moodalbail struct prefix *pr, *next_pr;
24126e91bba0SGirish Moodalbail struct lifreq lifr;
24136e91bba0SGirish Moodalbail int err;
24146e91bba0SGirish Moodalbail
24156e91bba0SGirish Moodalbail pi = phyint_lookup((char *)ifname);
24166e91bba0SGirish Moodalbail if (pi == NULL) {
24176e91bba0SGirish Moodalbail logmsg(LOG_ERR, "no phyint found for %s", ifname);
24186e91bba0SGirish Moodalbail return (ENXIO);
24196e91bba0SGirish Moodalbail }
24206e91bba0SGirish Moodalbail if (IN6_IS_ADDR_UNSPECIFIED(&pi->pi_token)) {
24216e91bba0SGirish Moodalbail logmsg(LOG_ERR, "token does not exist for %s", ifname);
24222514b110SRyan Goodfellow return (ENOENT);
24236e91bba0SGirish Moodalbail }
24246e91bba0SGirish Moodalbail
24256e91bba0SGirish Moodalbail if (ifsock < 0) {
24266e91bba0SGirish Moodalbail ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
24276e91bba0SGirish Moodalbail if (ifsock < 0) {
24286e91bba0SGirish Moodalbail err = errno;
2429*44749cf0SAndy Fiddaman logperror("ndpd_delete_addrs: socket");
24306e91bba0SGirish Moodalbail return (err);
24316e91bba0SGirish Moodalbail }
24326e91bba0SGirish Moodalbail }
24336e91bba0SGirish Moodalbail /* Remove the prefixes for this phyint if they exist */
24346e91bba0SGirish Moodalbail for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
24356e91bba0SGirish Moodalbail next_pr = pr->pr_next;
24366e91bba0SGirish Moodalbail if (pr->pr_name[0] == '\0') {
24376e91bba0SGirish Moodalbail prefix_delete(pr);
24386e91bba0SGirish Moodalbail continue;
24396e91bba0SGirish Moodalbail }
24406e91bba0SGirish Moodalbail /*
24416e91bba0SGirish Moodalbail * Delete all the prefixes for the auto-configured
24426e91bba0SGirish Moodalbail * addresses as well as the DHCPv6 addresses.
24436e91bba0SGirish Moodalbail */
24446e91bba0SGirish Moodalbail (void) strncpy(lifr.lifr_name, pr->pr_name,
24456e91bba0SGirish Moodalbail sizeof (lifr.lifr_name));
24466e91bba0SGirish Moodalbail if (ioctl(ifsock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
24476e91bba0SGirish Moodalbail err = errno;
24486e91bba0SGirish Moodalbail logperror("SIOCGLIFFLAGS");
24496e91bba0SGirish Moodalbail return (err);
24506e91bba0SGirish Moodalbail }
24516e91bba0SGirish Moodalbail if ((lifr.lifr_flags & IFF_ADDRCONF) ||
24526e91bba0SGirish Moodalbail (lifr.lifr_flags & IFF_DHCPRUNNING)) {
24536e91bba0SGirish Moodalbail prefix_update_ipadm_addrobj(pr, _B_FALSE);
24546e91bba0SGirish Moodalbail }
24556e91bba0SGirish Moodalbail prefix_delete(pr);
24566e91bba0SGirish Moodalbail }
24576e91bba0SGirish Moodalbail
24586e91bba0SGirish Moodalbail /*
24596e91bba0SGirish Moodalbail * If we had started dhcpagent, we need to release the leases
24606e91bba0SGirish Moodalbail * if any are required.
24616e91bba0SGirish Moodalbail */
24626e91bba0SGirish Moodalbail if (pi->pi_stateful) {
24636e91bba0SGirish Moodalbail (void) strncpy(lifr.lifr_name, pi->pi_name,
24646e91bba0SGirish Moodalbail sizeof (lifr.lifr_name));
24656e91bba0SGirish Moodalbail if (ioctl(ifsock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
24666e91bba0SGirish Moodalbail err = errno;
24676e91bba0SGirish Moodalbail logperror("SIOCGLIFFLAGS");
24686e91bba0SGirish Moodalbail return (err);
24696e91bba0SGirish Moodalbail }
24706e91bba0SGirish Moodalbail if (lifr.lifr_flags & IFF_DHCPRUNNING)
24716e91bba0SGirish Moodalbail release_dhcp(pi);
24726e91bba0SGirish Moodalbail }
24736e91bba0SGirish Moodalbail
24746e91bba0SGirish Moodalbail /*
24756e91bba0SGirish Moodalbail * Reset the Interface ID on this phyint and stop autoconfigurations
24766e91bba0SGirish Moodalbail * until a new interface ID is provided.
24776e91bba0SGirish Moodalbail */
24786e91bba0SGirish Moodalbail pi->pi_token = in6addr_any;
2479*44749cf0SAndy Fiddaman pi->pi_ifaddr = in6addr_any;
24806e91bba0SGirish Moodalbail pi->pi_token_length = 0;
24816e91bba0SGirish Moodalbail pi->pi_autoconf = _B_FALSE;
24826e91bba0SGirish Moodalbail pi->pi_ipadm_aobjname[0] = '\0';
24836e91bba0SGirish Moodalbail
24846e91bba0SGirish Moodalbail /* Reset the stateless and stateful settings to default. */
24856e91bba0SGirish Moodalbail pi->pi_stateless = pi->pi_StatelessAddrConf;
24866e91bba0SGirish Moodalbail pi->pi_stateful = pi->pi_StatefulAddrConf;
24876e91bba0SGirish Moodalbail
24886e91bba0SGirish Moodalbail if (debug & D_PHYINT) {
24896e91bba0SGirish Moodalbail logmsg(LOG_DEBUG, "ndpd_delete_addrs: "
24906e91bba0SGirish Moodalbail "removed token from interface %s\n", pi->pi_name);
24916e91bba0SGirish Moodalbail }
24926e91bba0SGirish Moodalbail return (0);
24936e91bba0SGirish Moodalbail }
24946e91bba0SGirish Moodalbail
24956e91bba0SGirish Moodalbail void
check_autoconf_var_consistency(struct phyint * pi,boolean_t stateless,boolean_t stateful)24966e91bba0SGirish Moodalbail check_autoconf_var_consistency(struct phyint *pi, boolean_t stateless,
24976e91bba0SGirish Moodalbail boolean_t stateful)
24986e91bba0SGirish Moodalbail {
24996e91bba0SGirish Moodalbail /*
25006e91bba0SGirish Moodalbail * If StatelessAddrConf and StatelessAddrConf are set in
25016e91bba0SGirish Moodalbail * /etc/inet/ndpd.conf, check if the new values override those
25026e91bba0SGirish Moodalbail * settings. If so, log a warning.
25036e91bba0SGirish Moodalbail */
25046e91bba0SGirish Moodalbail if ((pi->pi_StatelessAddrConf !=
25056e91bba0SGirish Moodalbail ifdefaults[I_StatelessAddrConf].cf_value &&
25066e91bba0SGirish Moodalbail stateless != pi->pi_StatelessAddrConf) ||
25076e91bba0SGirish Moodalbail (pi->pi_StatefulAddrConf !=
25086e91bba0SGirish Moodalbail ifdefaults[I_StatefulAddrConf].cf_value &&
25096e91bba0SGirish Moodalbail stateful != pi->pi_StatefulAddrConf)) {
25106e91bba0SGirish Moodalbail logmsg(LOG_ERR, "check_autoconf_var_consistency: "
25116e91bba0SGirish Moodalbail "Overriding the StatelessAddrConf or StatefulAddrConf "
25126e91bba0SGirish Moodalbail "settings in ndpd.conf with the new values for "
25136e91bba0SGirish Moodalbail "interface %s\n", pi->pi_name);
25146e91bba0SGirish Moodalbail }
25156e91bba0SGirish Moodalbail }
25166e91bba0SGirish Moodalbail
25176e91bba0SGirish Moodalbail /*
25186e91bba0SGirish Moodalbail * If ipadm was used to start autoconfiguration and in.ndpd was restarted
25196e91bba0SGirish Moodalbail * for some reason, in.ndpd has to resume autoconfiguration when it comes up.
25206e91bba0SGirish Moodalbail * In this function, it scans the ipadm_addr_info() output to find a link-local
25216e91bba0SGirish Moodalbail * on this interface with address type "addrconf" and extracts the interface id.
25226e91bba0SGirish Moodalbail * It also stores the addrobj name to be used later when new addresses are
25236e91bba0SGirish Moodalbail * created for the prefixes advertised by the router.
25246e91bba0SGirish Moodalbail * If autoconfiguration was never started on this interface before in.ndpd
25256e91bba0SGirish Moodalbail * was killed, then in.ndpd should refrain from configuring prefixes, even if
25266e91bba0SGirish Moodalbail * there is a valid link-local on this interface, created by ipadm (identified
25276e91bba0SGirish Moodalbail * if there is a valid addrobj name).
25286e91bba0SGirish Moodalbail */
25296e91bba0SGirish Moodalbail static int
phyint_check_ipadm_intfid(struct phyint * pi)25306e91bba0SGirish Moodalbail phyint_check_ipadm_intfid(struct phyint *pi)
25316e91bba0SGirish Moodalbail {
25326e91bba0SGirish Moodalbail ipadm_status_t status;
25336e91bba0SGirish Moodalbail ipadm_addr_info_t *addrinfo;
25346e91bba0SGirish Moodalbail struct ifaddrs *ifap;
25356e91bba0SGirish Moodalbail ipadm_addr_info_t *ainfop;
25366e91bba0SGirish Moodalbail struct sockaddr_in6 *sin6;
25376e91bba0SGirish Moodalbail ipadm_handle_t iph;
25386e91bba0SGirish Moodalbail
25396e91bba0SGirish Moodalbail if (ipadm_open(&iph, 0) != IPADM_SUCCESS) {
25406e91bba0SGirish Moodalbail logmsg(LOG_ERR, "could not open handle to libipadm\n");
25416e91bba0SGirish Moodalbail return (-1);
25426e91bba0SGirish Moodalbail }
25436e91bba0SGirish Moodalbail
25446e91bba0SGirish Moodalbail status = ipadm_addr_info(iph, pi->pi_name, &addrinfo,
25456e91bba0SGirish Moodalbail IPADM_OPT_ZEROADDR, LIFC_NOXMIT|LIFC_TEMPORARY);
25466e91bba0SGirish Moodalbail if (status != IPADM_SUCCESS) {
25476e91bba0SGirish Moodalbail ipadm_close(iph);
25486e91bba0SGirish Moodalbail return (-1);
25496e91bba0SGirish Moodalbail }
25506e91bba0SGirish Moodalbail pi->pi_autoconf = _B_TRUE;
25516e91bba0SGirish Moodalbail for (ainfop = addrinfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
25526e91bba0SGirish Moodalbail ifap = &ainfop->ia_ifa;
255364639aafSDarren Reed if (ifap->ifa_addr->sa_family != AF_INET6 ||
25546e91bba0SGirish Moodalbail ainfop->ia_state == IFA_DISABLED)
25556e91bba0SGirish Moodalbail continue;
25566e91bba0SGirish Moodalbail sin6 = (struct sockaddr_in6 *)ifap->ifa_addr;
25576e91bba0SGirish Moodalbail if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
25586e91bba0SGirish Moodalbail if (ainfop->ia_atype == IPADM_ADDR_IPV6_ADDRCONF) {
25596e91bba0SGirish Moodalbail pi->pi_token = sin6->sin6_addr;
25606e91bba0SGirish Moodalbail pi->pi_token._S6_un._S6_u32[0] = 0;
25616e91bba0SGirish Moodalbail pi->pi_token._S6_un._S6_u32[1] = 0;
25626e91bba0SGirish Moodalbail pi->pi_autoconf = _B_TRUE;
25636e91bba0SGirish Moodalbail (void) strlcpy(pi->pi_ipadm_aobjname,
25646e91bba0SGirish Moodalbail ainfop->ia_aobjname,
25656e91bba0SGirish Moodalbail sizeof (pi->pi_ipadm_aobjname));
25666e91bba0SGirish Moodalbail break;
25676e91bba0SGirish Moodalbail }
25686e91bba0SGirish Moodalbail /*
25696e91bba0SGirish Moodalbail * If IFF_NOLINKLOCAL is set, then the link-local
25706e91bba0SGirish Moodalbail * was created using ipadm. Do not autoconfigure until
25716e91bba0SGirish Moodalbail * ipadm is explicitly used for autoconfiguration.
25726e91bba0SGirish Moodalbail */
25736e91bba0SGirish Moodalbail if (ifap->ifa_flags & IFF_NOLINKLOCAL)
25746e91bba0SGirish Moodalbail pi->pi_autoconf = _B_FALSE;
25756e91bba0SGirish Moodalbail } else if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
25766e91bba0SGirish Moodalbail strrchr(ifap->ifa_name, ':') == NULL) {
25776e91bba0SGirish Moodalbail /* The interface was created using ipadm. */
25786e91bba0SGirish Moodalbail pi->pi_autoconf = _B_FALSE;
25796e91bba0SGirish Moodalbail }
25806e91bba0SGirish Moodalbail }
25816e91bba0SGirish Moodalbail ipadm_free_addr_info(addrinfo);
25826e91bba0SGirish Moodalbail if (!pi->pi_autoconf) {
25836e91bba0SGirish Moodalbail pi->pi_token = in6addr_any;
25846e91bba0SGirish Moodalbail pi->pi_token_length = 0;
25856e91bba0SGirish Moodalbail }
25866e91bba0SGirish Moodalbail ipadm_close(iph);
25876e91bba0SGirish Moodalbail return (0);
25886e91bba0SGirish Moodalbail }
2589