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 20*e11c3f44Smeem * 21*e11c3f44Smeem * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 227c478bd9Sstevel@tonic-gate * Use is subject to license terms. 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 */ 943173664eSapersson int mibsock = -1; /* mib request socket */ 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate /* 977c478bd9Sstevel@tonic-gate * Return the current time in milliseconds truncated to 987c478bd9Sstevel@tonic-gate * fit in an integer. 997c478bd9Sstevel@tonic-gate */ 1007c478bd9Sstevel@tonic-gate uint_t 1017c478bd9Sstevel@tonic-gate getcurrenttime(void) 1027c478bd9Sstevel@tonic-gate { 1037c478bd9Sstevel@tonic-gate struct timeval tp; 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate if (gettimeofday(&tp, NULL) < 0) { 1067c478bd9Sstevel@tonic-gate logperror("getcurrenttime: gettimeofday failed"); 1077c478bd9Sstevel@tonic-gate exit(1); 1087c478bd9Sstevel@tonic-gate } 1097c478bd9Sstevel@tonic-gate return (tp.tv_sec * 1000 + tp.tv_usec / 1000); 1107c478bd9Sstevel@tonic-gate } 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate /* 1137c478bd9Sstevel@tonic-gate * Output a preformated packet from the packet[] buffer. 1147c478bd9Sstevel@tonic-gate */ 1157c478bd9Sstevel@tonic-gate static void 1167c478bd9Sstevel@tonic-gate sendpacket(struct sockaddr_in6 *sin6, int sock, int size, int flags) 1177c478bd9Sstevel@tonic-gate { 1187c478bd9Sstevel@tonic-gate int cc; 1197c478bd9Sstevel@tonic-gate char abuf[INET6_ADDRSTRLEN]; 1207c478bd9Sstevel@tonic-gate 1217c478bd9Sstevel@tonic-gate cc = sendto(sock, (char *)packet, size, flags, 122*e11c3f44Smeem (struct sockaddr *)sin6, sizeof (*sin6)); 1237c478bd9Sstevel@tonic-gate if (cc < 0 || cc != size) { 1247c478bd9Sstevel@tonic-gate if (cc < 0) { 1257c478bd9Sstevel@tonic-gate logperror("sendpacket: sendto"); 1267c478bd9Sstevel@tonic-gate } 1277c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "sendpacket: wrote %s %d chars, ret=%d\n", 1287c478bd9Sstevel@tonic-gate inet_ntop(sin6->sin6_family, 1297c478bd9Sstevel@tonic-gate (void *)&sin6->sin6_addr, 1307c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)), 1317c478bd9Sstevel@tonic-gate size, cc); 1327c478bd9Sstevel@tonic-gate } 1337c478bd9Sstevel@tonic-gate } 1347c478bd9Sstevel@tonic-gate 135*e11c3f44Smeem /* 136*e11c3f44Smeem * If possible, place an ND_OPT_SOURCE_LINKADDR option at `optp'. 137*e11c3f44Smeem * Return the number of bytes placed in the option. 138*e11c3f44Smeem */ 139*e11c3f44Smeem static uint_t 140*e11c3f44Smeem add_opt_lla(struct phyint *pi, struct nd_opt_lla *optp) 141*e11c3f44Smeem { 142*e11c3f44Smeem uint_t optlen; 143*e11c3f44Smeem uint_t hwaddrlen; 144*e11c3f44Smeem struct lifreq lifr; 145*e11c3f44Smeem 146*e11c3f44Smeem /* If this phyint doesn't have a link-layer address, bail */ 147*e11c3f44Smeem if (phyint_get_lla(pi, &lifr) == -1) 148*e11c3f44Smeem return (0); 149*e11c3f44Smeem 150*e11c3f44Smeem hwaddrlen = lifr.lifr_nd.lnr_hdw_len; 151*e11c3f44Smeem /* roundup to multiple of 8 and make padding zero */ 152*e11c3f44Smeem optlen = ((sizeof (struct nd_opt_hdr) + hwaddrlen + 7) / 8) * 8; 153*e11c3f44Smeem bzero(optp, optlen); 154*e11c3f44Smeem optp->nd_opt_lla_type = ND_OPT_SOURCE_LINKADDR; 155*e11c3f44Smeem optp->nd_opt_lla_len = optlen / 8; 156*e11c3f44Smeem bcopy(lifr.lifr_nd.lnr_hdw_addr, optp->nd_opt_lla_hdw_addr, hwaddrlen); 157*e11c3f44Smeem 158*e11c3f44Smeem return (optlen); 159*e11c3f44Smeem } 160*e11c3f44Smeem 1617c478bd9Sstevel@tonic-gate /* Send a Router Solicitation */ 1627c478bd9Sstevel@tonic-gate static void 1637c478bd9Sstevel@tonic-gate solicit(struct sockaddr_in6 *sin6, struct phyint *pi) 1647c478bd9Sstevel@tonic-gate { 1657c478bd9Sstevel@tonic-gate int packetlen = 0; 1667c478bd9Sstevel@tonic-gate struct nd_router_solicit *rs = (struct nd_router_solicit *)packet; 1677c478bd9Sstevel@tonic-gate char *pptr = (char *)packet; 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate rs->nd_rs_type = ND_ROUTER_SOLICIT; 1707c478bd9Sstevel@tonic-gate rs->nd_rs_code = 0; 1717c478bd9Sstevel@tonic-gate rs->nd_rs_cksum = htons(0); 1727c478bd9Sstevel@tonic-gate rs->nd_rs_reserved = htonl(0); 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate packetlen += sizeof (*rs); 1757c478bd9Sstevel@tonic-gate pptr += sizeof (*rs); 1767c478bd9Sstevel@tonic-gate 177*e11c3f44Smeem /* add options */ 178*e11c3f44Smeem packetlen += add_opt_lla(pi, (struct nd_opt_lla *)pptr); 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 1817c478bd9Sstevel@tonic-gate print_route_sol("Sending solicitation to ", pi, rs, packetlen, 1827c478bd9Sstevel@tonic-gate sin6); 1837c478bd9Sstevel@tonic-gate } 1847c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate /* 1887c478bd9Sstevel@tonic-gate * Send a (set of) Router Advertisements and feed them back to ourselves 1897c478bd9Sstevel@tonic-gate * for processing. Unless no_prefixes is set all prefixes are included. 1907c478bd9Sstevel@tonic-gate * If there are too many prefix options to fit in one packet multiple 1917c478bd9Sstevel@tonic-gate * packets will be sent - each containing a subset of the prefix options. 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate static void 1947c478bd9Sstevel@tonic-gate advertise(struct sockaddr_in6 *sin6, struct phyint *pi, boolean_t no_prefixes) 1957c478bd9Sstevel@tonic-gate { 1967c478bd9Sstevel@tonic-gate struct nd_opt_prefix_info *po; 1977c478bd9Sstevel@tonic-gate char *pptr = (char *)packet; 1987c478bd9Sstevel@tonic-gate struct nd_router_advert *ra; 1997c478bd9Sstevel@tonic-gate struct adv_prefix *adv_pr; 2007c478bd9Sstevel@tonic-gate int packetlen = 0; 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate ra = (struct nd_router_advert *)pptr; 2037c478bd9Sstevel@tonic-gate ra->nd_ra_type = ND_ROUTER_ADVERT; 2047c478bd9Sstevel@tonic-gate ra->nd_ra_code = 0; 2057c478bd9Sstevel@tonic-gate ra->nd_ra_cksum = htons(0); 2067c478bd9Sstevel@tonic-gate ra->nd_ra_curhoplimit = pi->pi_AdvCurHopLimit; 2077c478bd9Sstevel@tonic-gate ra->nd_ra_flags_reserved = 0; 2087c478bd9Sstevel@tonic-gate if (pi->pi_AdvManagedFlag) 2097c478bd9Sstevel@tonic-gate ra->nd_ra_flags_reserved |= ND_RA_FLAG_MANAGED; 2107c478bd9Sstevel@tonic-gate if (pi->pi_AdvOtherConfigFlag) 2117c478bd9Sstevel@tonic-gate ra->nd_ra_flags_reserved |= ND_RA_FLAG_OTHER; 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV) 2147c478bd9Sstevel@tonic-gate ra->nd_ra_router_lifetime = htons(0); 2157c478bd9Sstevel@tonic-gate else 2167c478bd9Sstevel@tonic-gate ra->nd_ra_router_lifetime = htons(pi->pi_AdvDefaultLifetime); 2177c478bd9Sstevel@tonic-gate ra->nd_ra_reachable = htonl(pi->pi_AdvReachableTime); 2187c478bd9Sstevel@tonic-gate ra->nd_ra_retransmit = htonl(pi->pi_AdvRetransTimer); 2197c478bd9Sstevel@tonic-gate 2207c478bd9Sstevel@tonic-gate packetlen = sizeof (*ra); 2217c478bd9Sstevel@tonic-gate pptr += sizeof (*ra); 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV) { 2247c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 2257c478bd9Sstevel@tonic-gate print_route_adv("Sending advert (FINAL) to ", pi, 2267c478bd9Sstevel@tonic-gate ra, packetlen, sin6); 2277c478bd9Sstevel@tonic-gate } 2287c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0); 2297c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */ 2307c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen); 2317c478bd9Sstevel@tonic-gate return; 2327c478bd9Sstevel@tonic-gate } 2337c478bd9Sstevel@tonic-gate 234*e11c3f44Smeem /* add options */ 235*e11c3f44Smeem packetlen += add_opt_lla(pi, (struct nd_opt_lla *)pptr); 236*e11c3f44Smeem pptr = (char *)packet + packetlen; 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate if (pi->pi_AdvLinkMTU != 0) { 2397c478bd9Sstevel@tonic-gate struct nd_opt_mtu *mo = (struct nd_opt_mtu *)pptr; 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_type = ND_OPT_MTU; 2427c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_len = sizeof (struct nd_opt_mtu) / 8; 2437c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_reserved = 0; 2447c478bd9Sstevel@tonic-gate mo->nd_opt_mtu_mtu = htonl(pi->pi_AdvLinkMTU); 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate packetlen += sizeof (struct nd_opt_mtu); 2477c478bd9Sstevel@tonic-gate pptr += sizeof (struct nd_opt_mtu); 2487c478bd9Sstevel@tonic-gate } 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate if (no_prefixes) { 2517c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 2527c478bd9Sstevel@tonic-gate print_route_adv("Sending advert to ", pi, 2537c478bd9Sstevel@tonic-gate ra, packetlen, sin6); 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0); 2567c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */ 2577c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen); 2587c478bd9Sstevel@tonic-gate return; 2597c478bd9Sstevel@tonic-gate } 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate po = (struct nd_opt_prefix_info *)pptr; 2627c478bd9Sstevel@tonic-gate for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL; 2637c478bd9Sstevel@tonic-gate adv_pr = adv_pr->adv_pr_next) { 2647c478bd9Sstevel@tonic-gate if (!adv_pr->adv_pr_AdvOnLinkFlag && 2657c478bd9Sstevel@tonic-gate !adv_pr->adv_pr_AdvAutonomousFlag) { 2667c478bd9Sstevel@tonic-gate continue; 2677c478bd9Sstevel@tonic-gate } 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate /* 2707c478bd9Sstevel@tonic-gate * If the prefix doesn't fit in packet send 2717c478bd9Sstevel@tonic-gate * what we have so far and start with new packet. 2727c478bd9Sstevel@tonic-gate */ 2737c478bd9Sstevel@tonic-gate if (packetlen + sizeof (*po) > 2747c478bd9Sstevel@tonic-gate pi->pi_LinkMTU - sizeof (struct ip6_hdr)) { 2757c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 2767c478bd9Sstevel@tonic-gate print_route_adv("Sending advert " 2777c478bd9Sstevel@tonic-gate "(FRAG) to ", 2787c478bd9Sstevel@tonic-gate pi, ra, packetlen, sin6); 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0); 2817c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */ 2827c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen); 2837c478bd9Sstevel@tonic-gate packetlen = sizeof (*ra); 2847c478bd9Sstevel@tonic-gate pptr = (char *)packet + sizeof (*ra); 2857c478bd9Sstevel@tonic-gate po = (struct nd_opt_prefix_info *)pptr; 2867c478bd9Sstevel@tonic-gate } 2877c478bd9Sstevel@tonic-gate po->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION; 2887c478bd9Sstevel@tonic-gate po->nd_opt_pi_len = sizeof (*po)/8; 2897c478bd9Sstevel@tonic-gate po->nd_opt_pi_flags_reserved = 0; 2907c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvOnLinkFlag) { 2917c478bd9Sstevel@tonic-gate po->nd_opt_pi_flags_reserved |= 2927c478bd9Sstevel@tonic-gate ND_OPT_PI_FLAG_ONLINK; 2937c478bd9Sstevel@tonic-gate } 2947c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvAutonomousFlag) { 2957c478bd9Sstevel@tonic-gate po->nd_opt_pi_flags_reserved |= 2967c478bd9Sstevel@tonic-gate ND_OPT_PI_FLAG_AUTO; 2977c478bd9Sstevel@tonic-gate } 2987c478bd9Sstevel@tonic-gate po->nd_opt_pi_prefix_len = adv_pr->adv_pr_prefix_len; 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * If both Adv*Expiration and Adv*Lifetime are 3017c478bd9Sstevel@tonic-gate * set we prefer the former and make the lifetime 3027c478bd9Sstevel@tonic-gate * decrement in real time. 3037c478bd9Sstevel@tonic-gate */ 3047c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvValidRealTime) { 3057c478bd9Sstevel@tonic-gate po->nd_opt_pi_valid_time = 3067c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvValidExpiration); 3077c478bd9Sstevel@tonic-gate } else { 3087c478bd9Sstevel@tonic-gate po->nd_opt_pi_valid_time = 3097c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvValidLifetime); 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate if (adv_pr->adv_pr_AdvPreferredRealTime) { 3127c478bd9Sstevel@tonic-gate po->nd_opt_pi_preferred_time = 3137c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvPreferredExpiration); 3147c478bd9Sstevel@tonic-gate } else { 3157c478bd9Sstevel@tonic-gate po->nd_opt_pi_preferred_time = 3167c478bd9Sstevel@tonic-gate htonl(adv_pr->adv_pr_AdvPreferredLifetime); 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate po->nd_opt_pi_reserved2 = htonl(0); 3197c478bd9Sstevel@tonic-gate po->nd_opt_pi_prefix = adv_pr->adv_pr_prefix; 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate po++; 3227c478bd9Sstevel@tonic-gate packetlen += sizeof (*po); 3237c478bd9Sstevel@tonic-gate } 3247c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 3257c478bd9Sstevel@tonic-gate print_route_adv("Sending advert to ", pi, 3267c478bd9Sstevel@tonic-gate ra, packetlen, sin6); 3277c478bd9Sstevel@tonic-gate } 3287c478bd9Sstevel@tonic-gate sendpacket(sin6, pi->pi_sock, packetlen, 0); 3297c478bd9Sstevel@tonic-gate /* Feed packet back in for router operation */ 3307c478bd9Sstevel@tonic-gate loopback_ra_enqueue(pi, ra, packetlen); 3317c478bd9Sstevel@tonic-gate } 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate /* Poll support */ 3347c478bd9Sstevel@tonic-gate static int pollfd_num = 0; /* Allocated and initialized */ 3357c478bd9Sstevel@tonic-gate static struct pollfd *pollfds = NULL; 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate /* 3387c478bd9Sstevel@tonic-gate * Add fd to the set being polled. Returns 0 if ok; -1 if failed. 3397c478bd9Sstevel@tonic-gate */ 3407c478bd9Sstevel@tonic-gate int 3417c478bd9Sstevel@tonic-gate poll_add(int fd) 3427c478bd9Sstevel@tonic-gate { 3437c478bd9Sstevel@tonic-gate int i; 3447c478bd9Sstevel@tonic-gate int new_num; 3457c478bd9Sstevel@tonic-gate struct pollfd *newfds; 3463173664eSapersson 3477c478bd9Sstevel@tonic-gate /* Check if already present */ 3487c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) { 3497c478bd9Sstevel@tonic-gate if (pollfds[i].fd == fd) 3507c478bd9Sstevel@tonic-gate return (0); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate /* Check for empty spot already present */ 3537c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) { 3547c478bd9Sstevel@tonic-gate if (pollfds[i].fd == -1) { 3557c478bd9Sstevel@tonic-gate pollfds[i].fd = fd; 3567c478bd9Sstevel@tonic-gate return (0); 3577c478bd9Sstevel@tonic-gate } 3587c478bd9Sstevel@tonic-gate } 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate /* Allocate space for 32 more fds and initialize to -1 */ 3617c478bd9Sstevel@tonic-gate new_num = pollfd_num + 32; 3627c478bd9Sstevel@tonic-gate newfds = realloc(pollfds, new_num * sizeof (struct pollfd)); 3637c478bd9Sstevel@tonic-gate if (newfds == NULL) { 3647c478bd9Sstevel@tonic-gate logperror("poll_add: realloc"); 3657c478bd9Sstevel@tonic-gate return (-1); 3667c478bd9Sstevel@tonic-gate } 3673173664eSapersson 3683173664eSapersson newfds[pollfd_num].fd = fd; 3693173664eSapersson newfds[pollfd_num++].events = POLLIN; 3703173664eSapersson 3717c478bd9Sstevel@tonic-gate for (i = pollfd_num; i < new_num; i++) { 3727c478bd9Sstevel@tonic-gate newfds[i].fd = -1; 3737c478bd9Sstevel@tonic-gate newfds[i].events = POLLIN; 3747c478bd9Sstevel@tonic-gate } 3757c478bd9Sstevel@tonic-gate pollfd_num = new_num; 3767c478bd9Sstevel@tonic-gate pollfds = newfds; 3773173664eSapersson return (0); 3787c478bd9Sstevel@tonic-gate } 3797c478bd9Sstevel@tonic-gate 3807c478bd9Sstevel@tonic-gate /* 3817c478bd9Sstevel@tonic-gate * Remove fd from the set being polled. Returns 0 if ok; -1 if failed. 3827c478bd9Sstevel@tonic-gate */ 3837c478bd9Sstevel@tonic-gate int 3847c478bd9Sstevel@tonic-gate poll_remove(int fd) 3857c478bd9Sstevel@tonic-gate { 3867c478bd9Sstevel@tonic-gate int i; 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate /* Check if already present */ 3897c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) { 3907c478bd9Sstevel@tonic-gate if (pollfds[i].fd == fd) { 3917c478bd9Sstevel@tonic-gate pollfds[i].fd = -1; 3927c478bd9Sstevel@tonic-gate return (0); 3937c478bd9Sstevel@tonic-gate } 3947c478bd9Sstevel@tonic-gate } 3957c478bd9Sstevel@tonic-gate return (-1); 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate /* 3997c478bd9Sstevel@tonic-gate * Extract information about the ifname (either a physical interface and 4007c478bd9Sstevel@tonic-gate * the ":0" logical interface or just a logical interface). 4017c478bd9Sstevel@tonic-gate * If the interface (still) exists in kernel set pr_in_use 4027c478bd9Sstevel@tonic-gate * for caller to be able to detect interfaces that are removed. 4037c478bd9Sstevel@tonic-gate * Starts sending advertisements/solicitations when new physical interfaces 4047c478bd9Sstevel@tonic-gate * are detected. 4057c478bd9Sstevel@tonic-gate */ 4067c478bd9Sstevel@tonic-gate static void 4077c478bd9Sstevel@tonic-gate if_process(int s, char *ifname, boolean_t first) 4087c478bd9Sstevel@tonic-gate { 4097c478bd9Sstevel@tonic-gate struct lifreq lifr; 4107c478bd9Sstevel@tonic-gate struct phyint *pi; 4117c478bd9Sstevel@tonic-gate struct prefix *pr; 4127c478bd9Sstevel@tonic-gate char *cp; 4137c478bd9Sstevel@tonic-gate char phyintname[LIFNAMSIZ + 1]; 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) 4167c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "if_process(%s)\n", ifname); 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate (void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name)); 4197c478bd9Sstevel@tonic-gate lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; 4207c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFFLAGS, (char *)&lifr) < 0) { 4217c478bd9Sstevel@tonic-gate if (errno == ENXIO) { 4227c478bd9Sstevel@tonic-gate /* 4237c478bd9Sstevel@tonic-gate * Interface has disappeared 4247c478bd9Sstevel@tonic-gate */ 4257c478bd9Sstevel@tonic-gate return; 4267c478bd9Sstevel@tonic-gate } 4277c478bd9Sstevel@tonic-gate logperror("if_process: ioctl (get interface flags)"); 4287c478bd9Sstevel@tonic-gate return; 4297c478bd9Sstevel@tonic-gate } 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate /* 4327c478bd9Sstevel@tonic-gate * Ignore loopback and point-to-multipoint interfaces. 4337c478bd9Sstevel@tonic-gate * Point-to-point interfaces always have IFF_MULTICAST set. 4347c478bd9Sstevel@tonic-gate */ 4357c478bd9Sstevel@tonic-gate if (!(lifr.lifr_flags & IFF_MULTICAST) || 4367c478bd9Sstevel@tonic-gate (lifr.lifr_flags & IFF_LOOPBACK)) { 4377c478bd9Sstevel@tonic-gate return; 4387c478bd9Sstevel@tonic-gate } 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate if (!(lifr.lifr_flags & IFF_IPV6)) 4417c478bd9Sstevel@tonic-gate return; 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate (void) strncpy(phyintname, ifname, sizeof (phyintname)); 4447c478bd9Sstevel@tonic-gate phyintname[sizeof (phyintname) - 1] = '\0'; 4457c478bd9Sstevel@tonic-gate if ((cp = strchr(phyintname, IF_SEPARATOR)) != NULL) { 4467c478bd9Sstevel@tonic-gate *cp = '\0'; 4477c478bd9Sstevel@tonic-gate } 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate pi = phyint_lookup(phyintname); 4507c478bd9Sstevel@tonic-gate if (pi == NULL) { 4517c478bd9Sstevel@tonic-gate /* 4527c478bd9Sstevel@tonic-gate * Do not add anything for new interfaces until they are UP. 4537c478bd9Sstevel@tonic-gate * For existing interfaces we track the up flag. 4547c478bd9Sstevel@tonic-gate */ 4557c478bd9Sstevel@tonic-gate if (!(lifr.lifr_flags & IFF_UP)) 4567c478bd9Sstevel@tonic-gate return; 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate pi = phyint_create(phyintname); 4597c478bd9Sstevel@tonic-gate if (pi == NULL) { 4607c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "if_process: out of memory\n"); 4617c478bd9Sstevel@tonic-gate return; 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate (void) phyint_init_from_k(pi); 4657c478bd9Sstevel@tonic-gate if (pi->pi_sock == -1 && !(pi->pi_kernel_state & PI_PRESENT)) { 4667c478bd9Sstevel@tonic-gate /* Interface is not yet present */ 4677c478bd9Sstevel@tonic-gate if (debug & D_PHYINT) { 4687c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "if_process: interface not yet " 4697c478bd9Sstevel@tonic-gate "present %s\n", pi->pi_name); 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate return; 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate if (pi->pi_sock != -1) { 4757c478bd9Sstevel@tonic-gate if (poll_add(pi->pi_sock) == -1) { 4767c478bd9Sstevel@tonic-gate /* 4777c478bd9Sstevel@tonic-gate * reset state. 4787c478bd9Sstevel@tonic-gate */ 4797c478bd9Sstevel@tonic-gate phyint_cleanup(pi); 4807c478bd9Sstevel@tonic-gate } 4817c478bd9Sstevel@tonic-gate } 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate /* 4847c478bd9Sstevel@tonic-gate * Check if IFF_ROUTER has been turned off in kernel in which 4857c478bd9Sstevel@tonic-gate * case we have to turn off AdvSendAdvertisements. 4867c478bd9Sstevel@tonic-gate * The kernel will automatically turn off IFF_ROUTER if 4877c478bd9Sstevel@tonic-gate * ip6_forwarding is turned off. 4887c478bd9Sstevel@tonic-gate * Note that we do not switch back should IFF_ROUTER be turned on. 4897c478bd9Sstevel@tonic-gate */ 4907c478bd9Sstevel@tonic-gate if (!first && 4917c478bd9Sstevel@tonic-gate pi->pi_AdvSendAdvertisements && !(pi->pi_flags & IFF_ROUTER)) { 4927c478bd9Sstevel@tonic-gate logmsg(LOG_INFO, "No longer a router on %s\n", pi->pi_name); 4937c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_FINAL_ADV); 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate pi->pi_AdvSendAdvertisements = 0; 4967c478bd9Sstevel@tonic-gate pi->pi_sol_state = NO_SOLICIT; 4977c478bd9Sstevel@tonic-gate } 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate /* 5007c478bd9Sstevel@tonic-gate * Send advertisments and solicitation only if the interface is 5017c478bd9Sstevel@tonic-gate * present in the kernel. 5027c478bd9Sstevel@tonic-gate */ 5037c478bd9Sstevel@tonic-gate if (pi->pi_kernel_state & PI_PRESENT) { 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements) { 5067c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV) 5077c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_INIT_ADV); 5087c478bd9Sstevel@tonic-gate } else { 5097c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == NO_SOLICIT) 5107c478bd9Sstevel@tonic-gate check_to_solicit(pi, START_INIT_SOLICIT); 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate } 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate /* 5157c478bd9Sstevel@tonic-gate * Track static kernel prefixes to prevent in.ndpd from clobbering 5167c478bd9Sstevel@tonic-gate * them by creating a struct prefix for each prefix detected in the 5177c478bd9Sstevel@tonic-gate * kernel. 5187c478bd9Sstevel@tonic-gate */ 5197c478bd9Sstevel@tonic-gate pr = prefix_lookup_name(pi, ifname); 5207c478bd9Sstevel@tonic-gate if (pr == NULL) { 5217c478bd9Sstevel@tonic-gate pr = prefix_create_name(pi, ifname); 5227c478bd9Sstevel@tonic-gate if (pr == NULL) { 5237c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "if_process: out of memory\n"); 5247c478bd9Sstevel@tonic-gate return; 5257c478bd9Sstevel@tonic-gate } 5267c478bd9Sstevel@tonic-gate if (prefix_init_from_k(pr) == -1) { 5277c478bd9Sstevel@tonic-gate prefix_delete(pr); 5287c478bd9Sstevel@tonic-gate return; 5297c478bd9Sstevel@tonic-gate } 5307c478bd9Sstevel@tonic-gate } 5317c478bd9Sstevel@tonic-gate /* Detect prefixes which are removed */ 5327c478bd9Sstevel@tonic-gate if (pr->pr_kernel_state != 0) 5337c478bd9Sstevel@tonic-gate pr->pr_in_use = _B_TRUE; 53469bb4bb4Scarlsonj 53569bb4bb4Scarlsonj if ((lifr.lifr_flags & IFF_DUPLICATE) && 536d04ccbb3Scarlsonj !(lifr.lifr_flags & IFF_DHCPRUNNING) && 53769bb4bb4Scarlsonj (pr->pr_flags & IFF_TEMPORARY)) { 53869bb4bb4Scarlsonj in6_addr_t *token; 53969bb4bb4Scarlsonj int i; 54069bb4bb4Scarlsonj char abuf[INET6_ADDRSTRLEN]; 54169bb4bb4Scarlsonj 54269bb4bb4Scarlsonj if (++pr->pr_attempts >= MAX_DAD_FAILURES) { 54369bb4bb4Scarlsonj logmsg(LOG_ERR, "%s: token %s is duplicate after %d " 54469bb4bb4Scarlsonj "attempts; disabling temporary addresses on %s", 54569bb4bb4Scarlsonj pr->pr_name, inet_ntop(AF_INET6, 54669bb4bb4Scarlsonj (void *)&pi->pi_tmp_token, abuf, sizeof (abuf)), 54769bb4bb4Scarlsonj pr->pr_attempts, pi->pi_name); 54869bb4bb4Scarlsonj pi->pi_TmpAddrsEnabled = 0; 54969bb4bb4Scarlsonj tmptoken_delete(pi); 55069bb4bb4Scarlsonj prefix_delete(pr); 55169bb4bb4Scarlsonj return; 55269bb4bb4Scarlsonj } 55369bb4bb4Scarlsonj logmsg(LOG_WARNING, "%s: token %s is duplicate; trying again", 55469bb4bb4Scarlsonj pr->pr_name, inet_ntop(AF_INET6, (void *)&pi->pi_tmp_token, 55569bb4bb4Scarlsonj abuf, sizeof (abuf))); 55669bb4bb4Scarlsonj if (!tmptoken_create(pi)) { 55769bb4bb4Scarlsonj prefix_delete(pr); 55869bb4bb4Scarlsonj return; 55969bb4bb4Scarlsonj } 56069bb4bb4Scarlsonj token = &pi->pi_tmp_token; 56169bb4bb4Scarlsonj for (i = 0; i < 16; i++) { 56269bb4bb4Scarlsonj /* 56369bb4bb4Scarlsonj * prefix_create ensures that pr_prefix has all-zero 56469bb4bb4Scarlsonj * bits after prefixlen. 56569bb4bb4Scarlsonj */ 56669bb4bb4Scarlsonj pr->pr_address.s6_addr[i] = pr->pr_prefix.s6_addr[i] | 56769bb4bb4Scarlsonj token->s6_addr[i]; 56869bb4bb4Scarlsonj } 56969bb4bb4Scarlsonj if (prefix_lookup_addr_match(pr) != NULL) { 57069bb4bb4Scarlsonj prefix_delete(pr); 57169bb4bb4Scarlsonj return; 57269bb4bb4Scarlsonj } 57369bb4bb4Scarlsonj pr->pr_CreateTime = getcurrenttime() / MILLISEC; 57469bb4bb4Scarlsonj /* 57569bb4bb4Scarlsonj * We've got a new token. Clearing PR_AUTO causes 57669bb4bb4Scarlsonj * prefix_update_k to bring the interface up and set the 57769bb4bb4Scarlsonj * address. 57869bb4bb4Scarlsonj */ 57969bb4bb4Scarlsonj pr->pr_kernel_state &= ~PR_AUTO; 58069bb4bb4Scarlsonj prefix_update_k(pr); 58169bb4bb4Scarlsonj } 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate static int ifsock = -1; 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate /* 5877c478bd9Sstevel@tonic-gate * Scan all interfaces to detect changes as well as new and deleted intefaces 5887c478bd9Sstevel@tonic-gate * 'first' is set for the initial call only. Do not effect anything. 5897c478bd9Sstevel@tonic-gate */ 5907c478bd9Sstevel@tonic-gate static void 5917c478bd9Sstevel@tonic-gate initifs(boolean_t first) 5927c478bd9Sstevel@tonic-gate { 5937c478bd9Sstevel@tonic-gate char *buf; 5947c478bd9Sstevel@tonic-gate int bufsize; 5957c478bd9Sstevel@tonic-gate int numifs; 5967c478bd9Sstevel@tonic-gate int n; 5977c478bd9Sstevel@tonic-gate struct lifnum lifn; 5987c478bd9Sstevel@tonic-gate struct lifconf lifc; 5997c478bd9Sstevel@tonic-gate struct lifreq *lifr; 6007c478bd9Sstevel@tonic-gate struct phyint *pi; 6017c478bd9Sstevel@tonic-gate struct phyint *next_pi; 6027c478bd9Sstevel@tonic-gate struct prefix *pr; 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) 6057c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Reading interface configuration\n"); 6067c478bd9Sstevel@tonic-gate if (ifsock < 0) { 6077c478bd9Sstevel@tonic-gate ifsock = socket(AF_INET6, SOCK_DGRAM, 0); 6087c478bd9Sstevel@tonic-gate if (ifsock < 0) { 6097c478bd9Sstevel@tonic-gate logperror("initifs: socket"); 6107c478bd9Sstevel@tonic-gate return; 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate } 6137c478bd9Sstevel@tonic-gate lifn.lifn_family = AF_INET6; 6147c478bd9Sstevel@tonic-gate lifn.lifn_flags = LIFC_NOXMIT | LIFC_TEMPORARY; 6157c478bd9Sstevel@tonic-gate if (ioctl(ifsock, SIOCGLIFNUM, (char *)&lifn) < 0) { 6167c478bd9Sstevel@tonic-gate logperror("initifs: ioctl (get interface numbers)"); 6177c478bd9Sstevel@tonic-gate return; 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate numifs = lifn.lifn_count; 6207c478bd9Sstevel@tonic-gate bufsize = numifs * sizeof (struct lifreq); 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate buf = (char *)malloc(bufsize); 6237c478bd9Sstevel@tonic-gate if (buf == NULL) { 6247c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "initifs: out of memory\n"); 6257c478bd9Sstevel@tonic-gate return; 6267c478bd9Sstevel@tonic-gate } 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate /* 6297c478bd9Sstevel@tonic-gate * Mark the interfaces so that we can find phyints and prefixes 6307c478bd9Sstevel@tonic-gate * which have disappeared from the kernel. 6317c478bd9Sstevel@tonic-gate * if_process will set pr_in_use when it finds the interface 6327c478bd9Sstevel@tonic-gate * in the kernel. 6337c478bd9Sstevel@tonic-gate */ 6347c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) { 6357c478bd9Sstevel@tonic-gate /* 6367c478bd9Sstevel@tonic-gate * Before re-examining the state of the interfaces, 6377c478bd9Sstevel@tonic-gate * PI_PRESENT should be cleared from pi_kernel_state. 6387c478bd9Sstevel@tonic-gate */ 6397c478bd9Sstevel@tonic-gate pi->pi_kernel_state &= ~PI_PRESENT; 6407c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { 6417c478bd9Sstevel@tonic-gate pr->pr_in_use = _B_FALSE; 6427c478bd9Sstevel@tonic-gate } 6437c478bd9Sstevel@tonic-gate } 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate lifc.lifc_family = AF_INET6; 6467c478bd9Sstevel@tonic-gate lifc.lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY; 6477c478bd9Sstevel@tonic-gate lifc.lifc_len = bufsize; 6487c478bd9Sstevel@tonic-gate lifc.lifc_buf = buf; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate if (ioctl(ifsock, SIOCGLIFCONF, (char *)&lifc) < 0) { 6517c478bd9Sstevel@tonic-gate logperror("initifs: ioctl (get interface configuration)"); 6527c478bd9Sstevel@tonic-gate free(buf); 6537c478bd9Sstevel@tonic-gate return; 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate lifr = (struct lifreq *)lifc.lifc_req; 6577c478bd9Sstevel@tonic-gate for (n = lifc.lifc_len / sizeof (struct lifreq); n > 0; n--, lifr++) 6587c478bd9Sstevel@tonic-gate if_process(ifsock, lifr->lifr_name, first); 6597c478bd9Sstevel@tonic-gate free(buf); 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate /* 6627c478bd9Sstevel@tonic-gate * Detect phyints that have been removed from the kernel. 6637c478bd9Sstevel@tonic-gate * Since we can't recreate it here (would require ifconfig plumb 6647c478bd9Sstevel@tonic-gate * logic) we just terminate use of that phyint. 6657c478bd9Sstevel@tonic-gate */ 6667c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) { 6677c478bd9Sstevel@tonic-gate next_pi = pi->pi_next; 6687c478bd9Sstevel@tonic-gate /* 6697c478bd9Sstevel@tonic-gate * If interface (still) exists in kernel, set 6707c478bd9Sstevel@tonic-gate * pi_state to indicate that. 6717c478bd9Sstevel@tonic-gate */ 6727c478bd9Sstevel@tonic-gate if (pi->pi_kernel_state & PI_PRESENT) { 6737c478bd9Sstevel@tonic-gate pi->pi_state |= PI_PRESENT; 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate check_if_removed(pi); 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate if (show_ifs) 6797c478bd9Sstevel@tonic-gate phyint_print_all(); 6807c478bd9Sstevel@tonic-gate } 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * Router advertisement state machine. Used for everything but timer 6857c478bd9Sstevel@tonic-gate * events which use advertise_event directly. 6867c478bd9Sstevel@tonic-gate */ 6877c478bd9Sstevel@tonic-gate void 6887c478bd9Sstevel@tonic-gate check_to_advertise(struct phyint *pi, enum adv_events event) 6897c478bd9Sstevel@tonic-gate { 6907c478bd9Sstevel@tonic-gate uint_t delay; 6917c478bd9Sstevel@tonic-gate enum adv_states old_state = pi->pi_adv_state; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate if (debug & D_STATE) { 6947c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_advertise(%s, %d) state %d\n", 6957c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state); 6967c478bd9Sstevel@tonic-gate } 6977c478bd9Sstevel@tonic-gate delay = advertise_event(pi, event, 0); 6987c478bd9Sstevel@tonic-gate if (delay != TIMER_INFINITY) { 6997c478bd9Sstevel@tonic-gate /* Make sure the global next event is updated */ 7007c478bd9Sstevel@tonic-gate timer_schedule(delay); 7017c478bd9Sstevel@tonic-gate } 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate if (debug & D_STATE) { 7047c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_advertise(%s, %d) state %d -> %d\n", 7057c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state, 7067c478bd9Sstevel@tonic-gate (int)pi->pi_adv_state); 7077c478bd9Sstevel@tonic-gate } 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate 7107c478bd9Sstevel@tonic-gate /* 7117c478bd9Sstevel@tonic-gate * Router advertisement state machine. 7127c478bd9Sstevel@tonic-gate * Return the number of milliseconds until next timeout (TIMER_INFINITY 7137c478bd9Sstevel@tonic-gate * if never). 7147c478bd9Sstevel@tonic-gate * For the ADV_TIMER event the caller passes in the number of milliseconds 7157c478bd9Sstevel@tonic-gate * since the last timer event in the 'elapsed' parameter. 7167c478bd9Sstevel@tonic-gate */ 7177c478bd9Sstevel@tonic-gate uint_t 7187c478bd9Sstevel@tonic-gate advertise_event(struct phyint *pi, enum adv_events event, uint_t elapsed) 7197c478bd9Sstevel@tonic-gate { 7207c478bd9Sstevel@tonic-gate uint_t delay; 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate if (debug & D_STATE) { 7237c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "advertise_event(%s, %d, %d) state %d\n", 7247c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, elapsed, (int)pi->pi_adv_state); 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate check_daemonize(); 7277c478bd9Sstevel@tonic-gate if (!pi->pi_AdvSendAdvertisements) 7287c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 7297c478bd9Sstevel@tonic-gate if (pi->pi_flags & IFF_NORTEXCH) { 7307c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 7317c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Suppress sending RA packet on %s " 7327c478bd9Sstevel@tonic-gate "(no route exchange on interface)\n", 7337c478bd9Sstevel@tonic-gate pi->pi_name); 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 7367c478bd9Sstevel@tonic-gate } 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate switch (event) { 7397c478bd9Sstevel@tonic-gate case ADV_OFF: 7407c478bd9Sstevel@tonic-gate pi->pi_adv_state = NO_ADV; 7417c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate case START_INIT_ADV: 7447c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == INIT_ADV) 7457c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left); 7467c478bd9Sstevel@tonic-gate pi->pi_adv_count = ND_MAX_INITIAL_RTR_ADVERTISEMENTS; 7477c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 0; 7487c478bd9Sstevel@tonic-gate pi->pi_adv_state = INIT_ADV; 7497c478bd9Sstevel@tonic-gate break; /* send advertisement */ 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate case START_FINAL_ADV: 7527c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV) 7537c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 7547c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV) 7557c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left); 7567c478bd9Sstevel@tonic-gate pi->pi_adv_count = ND_MAX_FINAL_RTR_ADVERTISEMENTS; 7577c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 0; 7587c478bd9Sstevel@tonic-gate pi->pi_adv_state = FINAL_ADV; 7597c478bd9Sstevel@tonic-gate break; /* send advertisement */ 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate case RECEIVED_SOLICIT: 7627c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV) 7637c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 7647c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == SOLICIT_ADV) { 7657c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_left != 0) 7667c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left); 7677c478bd9Sstevel@tonic-gate break; 7687c478bd9Sstevel@tonic-gate } 7697c478bd9Sstevel@tonic-gate delay = GET_RANDOM(0, ND_MAX_RA_DELAY_TIME); 7707c478bd9Sstevel@tonic-gate if (delay < pi->pi_adv_time_left) 7717c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = delay; 7727c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_since_sent < ND_MIN_DELAY_BETWEEN_RAS) { 7737c478bd9Sstevel@tonic-gate /* 7747c478bd9Sstevel@tonic-gate * Send an advertisement (ND_MIN_DELAY_BETWEEN_RAS 7757c478bd9Sstevel@tonic-gate * plus random delay) after the previous 7767c478bd9Sstevel@tonic-gate * advertisement was sent. 7777c478bd9Sstevel@tonic-gate */ 7787c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = delay + 7797c478bd9Sstevel@tonic-gate ND_MIN_DELAY_BETWEEN_RAS - 7807c478bd9Sstevel@tonic-gate pi->pi_adv_time_since_sent; 7817c478bd9Sstevel@tonic-gate } 7827c478bd9Sstevel@tonic-gate pi->pi_adv_state = SOLICIT_ADV; 7837c478bd9Sstevel@tonic-gate break; 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate case ADV_TIMER: 7867c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == NO_ADV) 7877c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 7887c478bd9Sstevel@tonic-gate /* Decrease time left */ 7897c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_left >= elapsed) 7907c478bd9Sstevel@tonic-gate pi->pi_adv_time_left -= elapsed; 7917c478bd9Sstevel@tonic-gate else 7927c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 0; 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate /* Increase time since last advertisement was sent */ 7957c478bd9Sstevel@tonic-gate pi->pi_adv_time_since_sent += elapsed; 7967c478bd9Sstevel@tonic-gate break; 7977c478bd9Sstevel@tonic-gate default: 7987c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "advertise_event: Unknown event %d\n", 7997c478bd9Sstevel@tonic-gate (int)event); 8007c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 8017c478bd9Sstevel@tonic-gate } 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate if (pi->pi_adv_time_left != 0) 8047c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left); 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate /* Send advertisement and calculate next time to send */ 8077c478bd9Sstevel@tonic-gate if (pi->pi_adv_state == FINAL_ADV) { 8087c478bd9Sstevel@tonic-gate /* Omit the prefixes */ 8097c478bd9Sstevel@tonic-gate advertise(&v6allnodes, pi, _B_TRUE); 8107c478bd9Sstevel@tonic-gate } else { 8117c478bd9Sstevel@tonic-gate advertise(&v6allnodes, pi, _B_FALSE); 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate pi->pi_adv_time_since_sent = 0; 8147c478bd9Sstevel@tonic-gate 8157c478bd9Sstevel@tonic-gate switch (pi->pi_adv_state) { 8167c478bd9Sstevel@tonic-gate case SOLICIT_ADV: 8177c478bd9Sstevel@tonic-gate /* 8187c478bd9Sstevel@tonic-gate * The solicited advertisement has been sent. 8197c478bd9Sstevel@tonic-gate * Revert to periodic advertisements. 8207c478bd9Sstevel@tonic-gate */ 8217c478bd9Sstevel@tonic-gate pi->pi_adv_state = REG_ADV; 8227c478bd9Sstevel@tonic-gate /* FALLTHRU */ 8237c478bd9Sstevel@tonic-gate case REG_ADV: 8247c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 8257c478bd9Sstevel@tonic-gate GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval, 8267c478bd9Sstevel@tonic-gate 1000 * pi->pi_MaxRtrAdvInterval); 8277c478bd9Sstevel@tonic-gate break; 8287c478bd9Sstevel@tonic-gate 8297c478bd9Sstevel@tonic-gate case INIT_ADV: 8307c478bd9Sstevel@tonic-gate if (--pi->pi_adv_count > 0) { 8317c478bd9Sstevel@tonic-gate delay = GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval, 8327c478bd9Sstevel@tonic-gate 1000 * pi->pi_MaxRtrAdvInterval); 8337c478bd9Sstevel@tonic-gate if (delay > ND_MAX_INITIAL_RTR_ADVERT_INTERVAL) 8347c478bd9Sstevel@tonic-gate delay = ND_MAX_INITIAL_RTR_ADVERT_INTERVAL; 8357c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = delay; 8367c478bd9Sstevel@tonic-gate } else { 8377c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 8387c478bd9Sstevel@tonic-gate GET_RANDOM(1000 * pi->pi_MinRtrAdvInterval, 8397c478bd9Sstevel@tonic-gate 1000 * pi->pi_MaxRtrAdvInterval); 8407c478bd9Sstevel@tonic-gate pi->pi_adv_state = REG_ADV; 8417c478bd9Sstevel@tonic-gate } 8427c478bd9Sstevel@tonic-gate break; 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate case FINAL_ADV: 8457c478bd9Sstevel@tonic-gate if (--pi->pi_adv_count > 0) { 8467c478bd9Sstevel@tonic-gate pi->pi_adv_time_left = 8477c478bd9Sstevel@tonic-gate ND_MAX_INITIAL_RTR_ADVERT_INTERVAL; 8487c478bd9Sstevel@tonic-gate } else { 8497c478bd9Sstevel@tonic-gate pi->pi_adv_state = NO_ADV; 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate break; 8527c478bd9Sstevel@tonic-gate } 8537c478bd9Sstevel@tonic-gate if (pi->pi_adv_state != NO_ADV) 8547c478bd9Sstevel@tonic-gate return (pi->pi_adv_time_left); 8557c478bd9Sstevel@tonic-gate else 8567c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 8577c478bd9Sstevel@tonic-gate } 8587c478bd9Sstevel@tonic-gate 8597c478bd9Sstevel@tonic-gate /* 8607c478bd9Sstevel@tonic-gate * Router solicitation state machine. Used for everything but timer 8617c478bd9Sstevel@tonic-gate * events which use solicit_event directly. 8627c478bd9Sstevel@tonic-gate */ 8637c478bd9Sstevel@tonic-gate void 8647c478bd9Sstevel@tonic-gate check_to_solicit(struct phyint *pi, enum solicit_events event) 8657c478bd9Sstevel@tonic-gate { 8667c478bd9Sstevel@tonic-gate uint_t delay; 8677c478bd9Sstevel@tonic-gate enum solicit_states old_state = pi->pi_sol_state; 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate if (debug & D_STATE) { 8707c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_solicit(%s, %d) state %d\n", 8717c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state); 8727c478bd9Sstevel@tonic-gate } 8737c478bd9Sstevel@tonic-gate delay = solicit_event(pi, event, 0); 8747c478bd9Sstevel@tonic-gate if (delay != TIMER_INFINITY) { 8757c478bd9Sstevel@tonic-gate /* Make sure the global next event is updated */ 8767c478bd9Sstevel@tonic-gate timer_schedule(delay); 8777c478bd9Sstevel@tonic-gate } 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate if (debug & D_STATE) { 8807c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "check_to_solicit(%s, %d) state %d -> %d\n", 8817c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, (int)old_state, 8827c478bd9Sstevel@tonic-gate (int)pi->pi_sol_state); 8837c478bd9Sstevel@tonic-gate } 8847c478bd9Sstevel@tonic-gate } 8857c478bd9Sstevel@tonic-gate 8867c478bd9Sstevel@tonic-gate static void 8877c478bd9Sstevel@tonic-gate daemonize_ndpd(void) 8887c478bd9Sstevel@tonic-gate { 8897c478bd9Sstevel@tonic-gate FILE *pidfp; 8907c478bd9Sstevel@tonic-gate mode_t pidmode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* 0644 */ 8917c478bd9Sstevel@tonic-gate struct itimerval it; 8927c478bd9Sstevel@tonic-gate boolean_t timerval = _B_TRUE; 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate /* 8957c478bd9Sstevel@tonic-gate * Need to get current timer settings so they can be restored 8967c478bd9Sstevel@tonic-gate * after the fork(), as the it_value and it_interval values for 8977c478bd9Sstevel@tonic-gate * the ITIMER_REAL timer are reset to 0 in the child process. 8987c478bd9Sstevel@tonic-gate */ 8997c478bd9Sstevel@tonic-gate if (getitimer(ITIMER_REAL, &it) < 0) { 9007c478bd9Sstevel@tonic-gate if (debug & D_TIMER) 9017c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, 9027c478bd9Sstevel@tonic-gate "daemonize_ndpd: failed to get itimerval\n"); 9037c478bd9Sstevel@tonic-gate timerval = _B_FALSE; 9047c478bd9Sstevel@tonic-gate } 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate /* Daemonize. */ 9077c478bd9Sstevel@tonic-gate switch (fork()) { 9087c478bd9Sstevel@tonic-gate case 0: 9097c478bd9Sstevel@tonic-gate /* Child */ 9107c478bd9Sstevel@tonic-gate break; 9117c478bd9Sstevel@tonic-gate case -1: 9127c478bd9Sstevel@tonic-gate logperror("fork"); 9137c478bd9Sstevel@tonic-gate exit(1); 9147c478bd9Sstevel@tonic-gate default: 9157c478bd9Sstevel@tonic-gate /* Parent */ 9167c478bd9Sstevel@tonic-gate _exit(0); 9177c478bd9Sstevel@tonic-gate } 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate /* Store our process id, blow away any existing file if it exists. */ 9207c478bd9Sstevel@tonic-gate if ((pidfp = fopen(PATH_PID, "w")) == NULL) { 9217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: unable to open " PATH_PID ": %s\n", 9227c478bd9Sstevel@tonic-gate argv0[0], strerror(errno)); 9237c478bd9Sstevel@tonic-gate } else { 9247c478bd9Sstevel@tonic-gate (void) fprintf(pidfp, "%ld\n", getpid()); 9257c478bd9Sstevel@tonic-gate (void) fclose(pidfp); 9267c478bd9Sstevel@tonic-gate (void) chmod(PATH_PID, pidmode); 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate (void) close(0); 9307c478bd9Sstevel@tonic-gate (void) close(1); 9317c478bd9Sstevel@tonic-gate (void) close(2); 9327c478bd9Sstevel@tonic-gate 9337c478bd9Sstevel@tonic-gate (void) chdir("/"); 9347c478bd9Sstevel@tonic-gate (void) open("/dev/null", O_RDWR); 9357c478bd9Sstevel@tonic-gate (void) dup2(0, 1); 9367c478bd9Sstevel@tonic-gate (void) dup2(0, 2); 9377c478bd9Sstevel@tonic-gate (void) setsid(); 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate already_daemonized = _B_TRUE; 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate /* 9427c478bd9Sstevel@tonic-gate * Restore timer values, if we were able to save them; if not, 9437c478bd9Sstevel@tonic-gate * check and set the right value by calling run_timeouts(). 9447c478bd9Sstevel@tonic-gate */ 9457c478bd9Sstevel@tonic-gate if (timerval) { 9467c478bd9Sstevel@tonic-gate if (setitimer(ITIMER_REAL, &it, NULL) < 0) { 9477c478bd9Sstevel@tonic-gate logperror("daemonize_ndpd: setitimer"); 9487c478bd9Sstevel@tonic-gate exit(2); 9497c478bd9Sstevel@tonic-gate } 9507c478bd9Sstevel@tonic-gate } else { 9517c478bd9Sstevel@tonic-gate run_timeouts(); 9527c478bd9Sstevel@tonic-gate } 9537c478bd9Sstevel@tonic-gate } 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate /* 9567c478bd9Sstevel@tonic-gate * Check to see if the time is right to daemonize. The right time is when: 9577c478bd9Sstevel@tonic-gate * 9587c478bd9Sstevel@tonic-gate * 1. We haven't already daemonized. 9597c478bd9Sstevel@tonic-gate * 2. We are not in debug mode. 9607c478bd9Sstevel@tonic-gate * 3. All interfaces are marked IFF_NOXMIT. 9617c478bd9Sstevel@tonic-gate * 4. All non-router interfaces have their prefixes set up and we're 9627c478bd9Sstevel@tonic-gate * done sending router solicitations on those interfaces without 9637c478bd9Sstevel@tonic-gate * prefixes. 9647c478bd9Sstevel@tonic-gate */ 9657c478bd9Sstevel@tonic-gate static void 9667c478bd9Sstevel@tonic-gate check_daemonize(void) 9677c478bd9Sstevel@tonic-gate { 9687c478bd9Sstevel@tonic-gate struct phyint *pi; 9697c478bd9Sstevel@tonic-gate 9707c478bd9Sstevel@tonic-gate if (already_daemonized || debug != 0) 9717c478bd9Sstevel@tonic-gate return; 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) { 9747c478bd9Sstevel@tonic-gate if (!(pi->pi_flags & IFF_NOXMIT)) 9757c478bd9Sstevel@tonic-gate break; 9767c478bd9Sstevel@tonic-gate } 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate /* 9797c478bd9Sstevel@tonic-gate * If we can't transmit on any of the interfaces there is no reason 9807c478bd9Sstevel@tonic-gate * to hold up progress. 9817c478bd9Sstevel@tonic-gate */ 9827c478bd9Sstevel@tonic-gate if (pi == NULL) { 9837c478bd9Sstevel@tonic-gate daemonize_ndpd(); 9847c478bd9Sstevel@tonic-gate return; 9857c478bd9Sstevel@tonic-gate } 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate /* Check all interfaces. If any are still soliciting, just return. */ 9887c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) { 9897c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements || 9907c478bd9Sstevel@tonic-gate !(pi->pi_kernel_state & PI_PRESENT)) 9917c478bd9Sstevel@tonic-gate continue; 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == INIT_SOLICIT) 9947c478bd9Sstevel@tonic-gate return; 9957c478bd9Sstevel@tonic-gate } 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate daemonize_ndpd(); 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate /* 10017c478bd9Sstevel@tonic-gate * Router solicitation state machine. 10027c478bd9Sstevel@tonic-gate * Return the number of milliseconds until next timeout (TIMER_INFINITY 10037c478bd9Sstevel@tonic-gate * if never). 10047c478bd9Sstevel@tonic-gate * For the SOL_TIMER event the caller passes in the number of milliseconds 10057c478bd9Sstevel@tonic-gate * since the last timer event in the 'elapsed' parameter. 10067c478bd9Sstevel@tonic-gate */ 10077c478bd9Sstevel@tonic-gate uint_t 10087c478bd9Sstevel@tonic-gate solicit_event(struct phyint *pi, enum solicit_events event, uint_t elapsed) 10097c478bd9Sstevel@tonic-gate { 10107c478bd9Sstevel@tonic-gate if (debug & D_STATE) { 10117c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "solicit_event(%s, %d, %d) state %d\n", 10127c478bd9Sstevel@tonic-gate pi->pi_name, (int)event, elapsed, (int)pi->pi_sol_state); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements) 10167c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10177c478bd9Sstevel@tonic-gate if (pi->pi_flags & IFF_NORTEXCH) { 10187c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) { 10197c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Suppress sending RS packet on %s " 10207c478bd9Sstevel@tonic-gate "(no route exchange on interface)\n", 10217c478bd9Sstevel@tonic-gate pi->pi_name); 10227c478bd9Sstevel@tonic-gate } 10237c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10247c478bd9Sstevel@tonic-gate } 10257c478bd9Sstevel@tonic-gate 10267c478bd9Sstevel@tonic-gate switch (event) { 10277c478bd9Sstevel@tonic-gate case SOLICIT_OFF: 10287c478bd9Sstevel@tonic-gate pi->pi_sol_state = NO_SOLICIT; 10297c478bd9Sstevel@tonic-gate check_daemonize(); 10307c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate case SOLICIT_DONE: 10337c478bd9Sstevel@tonic-gate pi->pi_sol_state = DONE_SOLICIT; 10347c478bd9Sstevel@tonic-gate check_daemonize(); 10357c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10367c478bd9Sstevel@tonic-gate 1037d04ccbb3Scarlsonj case RESTART_INIT_SOLICIT: 1038d04ccbb3Scarlsonj /* 1039d04ccbb3Scarlsonj * This event allows us to start solicitation over again 1040d04ccbb3Scarlsonj * without losing the RA flags. We start solicitation over 1041d04ccbb3Scarlsonj * when we are missing an interface prefix for a newly- 1042d04ccbb3Scarlsonj * encountered DHCP interface. 1043d04ccbb3Scarlsonj */ 1044d04ccbb3Scarlsonj if (pi->pi_sol_state == INIT_SOLICIT) 1045d04ccbb3Scarlsonj return (pi->pi_sol_time_left); 1046d04ccbb3Scarlsonj pi->pi_sol_count = ND_MAX_RTR_SOLICITATIONS; 1047d04ccbb3Scarlsonj pi->pi_sol_time_left = 1048d04ccbb3Scarlsonj GET_RANDOM(0, ND_MAX_RTR_SOLICITATION_DELAY); 1049d04ccbb3Scarlsonj pi->pi_sol_state = INIT_SOLICIT; 1050d04ccbb3Scarlsonj break; 1051d04ccbb3Scarlsonj 10527c478bd9Sstevel@tonic-gate case START_INIT_SOLICIT: 10537c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == INIT_SOLICIT) 10547c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left); 1055d04ccbb3Scarlsonj pi->pi_ra_flags = 0; 10567c478bd9Sstevel@tonic-gate pi->pi_sol_count = ND_MAX_RTR_SOLICITATIONS; 10577c478bd9Sstevel@tonic-gate pi->pi_sol_time_left = 10587c478bd9Sstevel@tonic-gate GET_RANDOM(0, ND_MAX_RTR_SOLICITATION_DELAY); 10597c478bd9Sstevel@tonic-gate pi->pi_sol_state = INIT_SOLICIT; 10607c478bd9Sstevel@tonic-gate break; 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate case SOL_TIMER: 10637c478bd9Sstevel@tonic-gate if (pi->pi_sol_state == NO_SOLICIT) 10647c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10657c478bd9Sstevel@tonic-gate /* Decrease time left */ 10667c478bd9Sstevel@tonic-gate if (pi->pi_sol_time_left >= elapsed) 10677c478bd9Sstevel@tonic-gate pi->pi_sol_time_left -= elapsed; 10687c478bd9Sstevel@tonic-gate else 10697c478bd9Sstevel@tonic-gate pi->pi_sol_time_left = 0; 10707c478bd9Sstevel@tonic-gate break; 10717c478bd9Sstevel@tonic-gate default: 10727c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "solicit_event: Unknown event %d\n", 10737c478bd9Sstevel@tonic-gate (int)event); 10747c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10757c478bd9Sstevel@tonic-gate } 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate if (pi->pi_sol_time_left != 0) 10787c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left); 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate /* Send solicitation and calculate next time */ 10817c478bd9Sstevel@tonic-gate switch (pi->pi_sol_state) { 10827c478bd9Sstevel@tonic-gate case INIT_SOLICIT: 10837c478bd9Sstevel@tonic-gate solicit(&v6allrouters, pi); 10847c478bd9Sstevel@tonic-gate if (--pi->pi_sol_count == 0) { 1085cfb9c9abScarlsonj if (debug & D_STATE) { 1086cfb9c9abScarlsonj logmsg(LOG_DEBUG, "solicit_event: no routers " 1087cfb9c9abScarlsonj "found on %s; assuming default flags\n", 1088cfb9c9abScarlsonj pi->pi_name); 1089cfb9c9abScarlsonj } 1090d04ccbb3Scarlsonj if (pi->pi_StatefulAddrConf) { 1091d04ccbb3Scarlsonj pi->pi_ra_flags |= ND_RA_FLAG_MANAGED | 1092d04ccbb3Scarlsonj ND_RA_FLAG_OTHER; 1093d04ccbb3Scarlsonj start_dhcp(pi); 1094d04ccbb3Scarlsonj } 10957c478bd9Sstevel@tonic-gate pi->pi_sol_state = DONE_SOLICIT; 10967c478bd9Sstevel@tonic-gate check_daemonize(); 10977c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 10987c478bd9Sstevel@tonic-gate } 10997c478bd9Sstevel@tonic-gate pi->pi_sol_time_left = ND_RTR_SOLICITATION_INTERVAL; 11007c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left); 11017c478bd9Sstevel@tonic-gate case NO_SOLICIT: 11027c478bd9Sstevel@tonic-gate case DONE_SOLICIT: 11037c478bd9Sstevel@tonic-gate return (TIMER_INFINITY); 11047c478bd9Sstevel@tonic-gate default: 11057c478bd9Sstevel@tonic-gate return (pi->pi_sol_time_left); 11067c478bd9Sstevel@tonic-gate } 11077c478bd9Sstevel@tonic-gate } 11087c478bd9Sstevel@tonic-gate 11097c478bd9Sstevel@tonic-gate /* 11107c478bd9Sstevel@tonic-gate * Timer mechanism using relative time (in milliseconds) from the 11117c478bd9Sstevel@tonic-gate * previous timer event. Timers exceeding TIMER_INFINITY milliseconds 11127c478bd9Sstevel@tonic-gate * will fire after TIMER_INFINITY milliseconds. 11137c478bd9Sstevel@tonic-gate */ 11147c478bd9Sstevel@tonic-gate static uint_t timer_previous; /* When last SIGALRM occurred */ 11157c478bd9Sstevel@tonic-gate static uint_t timer_next; /* Currently scheduled timeout */ 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate static void 11187c478bd9Sstevel@tonic-gate timer_init(void) 11197c478bd9Sstevel@tonic-gate { 11207c478bd9Sstevel@tonic-gate timer_previous = getcurrenttime(); 11217c478bd9Sstevel@tonic-gate timer_next = TIMER_INFINITY; 11227c478bd9Sstevel@tonic-gate run_timeouts(); 11237c478bd9Sstevel@tonic-gate } 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate /* 11267c478bd9Sstevel@tonic-gate * Make sure the next SIGALRM occurs delay milliseconds from the current 11277c478bd9Sstevel@tonic-gate * time if not earlier. 11287c478bd9Sstevel@tonic-gate * Handles getcurrenttime (32 bit integer holding milliseconds) wraparound 11297c478bd9Sstevel@tonic-gate * by treating differences greater than 0x80000000 as negative. 11307c478bd9Sstevel@tonic-gate */ 11317c478bd9Sstevel@tonic-gate void 11327c478bd9Sstevel@tonic-gate timer_schedule(uint_t delay) 11337c478bd9Sstevel@tonic-gate { 11347c478bd9Sstevel@tonic-gate uint_t now; 11357c478bd9Sstevel@tonic-gate struct itimerval itimerval; 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate now = getcurrenttime(); 11387c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 11397c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "timer_schedule(%u): now %u next %u\n", 11407c478bd9Sstevel@tonic-gate delay, now, timer_next); 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate /* Will this timer occur before the currently scheduled SIGALRM? */ 11437c478bd9Sstevel@tonic-gate if (delay >= timer_next - now) { 11447c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 11457c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "timer_schedule(%u): no action - " 11467c478bd9Sstevel@tonic-gate "next in %u ms\n", 11477c478bd9Sstevel@tonic-gate delay, timer_next - now); 11487c478bd9Sstevel@tonic-gate } 11497c478bd9Sstevel@tonic-gate return; 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate if (delay == 0) { 11527c478bd9Sstevel@tonic-gate /* Minimum allowed delay */ 11537c478bd9Sstevel@tonic-gate delay = 1; 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate timer_next = now + delay; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate itimerval.it_value.tv_sec = delay / 1000; 11587c478bd9Sstevel@tonic-gate itimerval.it_value.tv_usec = (delay % 1000) * 1000; 11597c478bd9Sstevel@tonic-gate itimerval.it_interval.tv_sec = 0; 11607c478bd9Sstevel@tonic-gate itimerval.it_interval.tv_usec = 0; 11617c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 11627c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "timer_schedule(%u): sec %lu usec %lu\n", 11637c478bd9Sstevel@tonic-gate delay, 11647c478bd9Sstevel@tonic-gate itimerval.it_value.tv_sec, itimerval.it_value.tv_usec); 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate if (setitimer(ITIMER_REAL, &itimerval, NULL) < 0) { 11677c478bd9Sstevel@tonic-gate logperror("timer_schedule: setitimer"); 11687c478bd9Sstevel@tonic-gate exit(2); 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate /* 11737c478bd9Sstevel@tonic-gate * Conditional running of timer. If more than 'minimal_time' millseconds 11747c478bd9Sstevel@tonic-gate * since the timer routines were last run we run them. 11757c478bd9Sstevel@tonic-gate * Used when packets arrive. 11767c478bd9Sstevel@tonic-gate */ 11777c478bd9Sstevel@tonic-gate static void 11787c478bd9Sstevel@tonic-gate conditional_run_timeouts(uint_t minimal_time) 11797c478bd9Sstevel@tonic-gate { 11807c478bd9Sstevel@tonic-gate uint_t now; 11817c478bd9Sstevel@tonic-gate uint_t elapsed; 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate now = getcurrenttime(); 11847c478bd9Sstevel@tonic-gate elapsed = now - timer_previous; 11857c478bd9Sstevel@tonic-gate if (elapsed > minimal_time) { 11867c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 11877c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "conditional_run_timeouts: " 11887c478bd9Sstevel@tonic-gate "elapsed %d\n", elapsed); 11897c478bd9Sstevel@tonic-gate } 11907c478bd9Sstevel@tonic-gate run_timeouts(); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate } 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate /* 11957c478bd9Sstevel@tonic-gate * Timer has fired. 11967c478bd9Sstevel@tonic-gate * Determine when the next timer event will occur by asking all 11977c478bd9Sstevel@tonic-gate * the timer routines. 11987c478bd9Sstevel@tonic-gate * Should not be called from a timer routine but in some cases this is 11997c478bd9Sstevel@tonic-gate * done because the code doesn't know that e.g. it was called from 12007c478bd9Sstevel@tonic-gate * ifconfig_timer(). In this case the nested run_timeouts will just return but 12017c478bd9Sstevel@tonic-gate * the running run_timeouts will ensure to call all the timer functions by 12027c478bd9Sstevel@tonic-gate * looping once more. 12037c478bd9Sstevel@tonic-gate */ 12047c478bd9Sstevel@tonic-gate static void 12057c478bd9Sstevel@tonic-gate run_timeouts(void) 12067c478bd9Sstevel@tonic-gate { 12077c478bd9Sstevel@tonic-gate uint_t now; 12087c478bd9Sstevel@tonic-gate uint_t elapsed; 12097c478bd9Sstevel@tonic-gate uint_t next; 12107c478bd9Sstevel@tonic-gate uint_t nexti; 12117c478bd9Sstevel@tonic-gate struct phyint *pi; 12127c478bd9Sstevel@tonic-gate struct phyint *next_pi; 12137c478bd9Sstevel@tonic-gate struct prefix *pr; 12147c478bd9Sstevel@tonic-gate struct prefix *next_pr; 12157c478bd9Sstevel@tonic-gate struct adv_prefix *adv_pr; 12167c478bd9Sstevel@tonic-gate struct adv_prefix *next_adv_pr; 12177c478bd9Sstevel@tonic-gate struct router *dr; 12187c478bd9Sstevel@tonic-gate struct router *next_dr; 12197c478bd9Sstevel@tonic-gate static boolean_t timeout_running; 12207c478bd9Sstevel@tonic-gate static boolean_t do_retry; 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate if (timeout_running) { 12237c478bd9Sstevel@tonic-gate if (debug & D_TIMER) 12247c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: nested call\n"); 12257c478bd9Sstevel@tonic-gate do_retry = _B_TRUE; 12267c478bd9Sstevel@tonic-gate return; 12277c478bd9Sstevel@tonic-gate } 12287c478bd9Sstevel@tonic-gate timeout_running = _B_TRUE; 12297c478bd9Sstevel@tonic-gate retry: 12307c478bd9Sstevel@tonic-gate /* How much time since the last time we were called? */ 12317c478bd9Sstevel@tonic-gate now = getcurrenttime(); 12327c478bd9Sstevel@tonic-gate elapsed = now - timer_previous; 12337c478bd9Sstevel@tonic-gate timer_previous = now; 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate if (debug & D_TIMER) 12367c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: elapsed %d\n", elapsed); 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate next = TIMER_INFINITY; 12397c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) { 12407c478bd9Sstevel@tonic-gate next_pi = pi->pi_next; 12417c478bd9Sstevel@tonic-gate nexti = phyint_timer(pi, elapsed); 12427c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next) 12437c478bd9Sstevel@tonic-gate next = nexti; 12447c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 12457c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (pi %s): %d -> %u ms\n", 12467c478bd9Sstevel@tonic-gate pi->pi_name, nexti, next); 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) { 12497c478bd9Sstevel@tonic-gate next_pr = pr->pr_next; 12507c478bd9Sstevel@tonic-gate nexti = prefix_timer(pr, elapsed); 12517c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next) 12527c478bd9Sstevel@tonic-gate next = nexti; 12537c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 12547c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (pr %s): " 12557c478bd9Sstevel@tonic-gate "%d -> %u ms\n", pr->pr_name, nexti, next); 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL; 12597c478bd9Sstevel@tonic-gate adv_pr = next_adv_pr) { 12607c478bd9Sstevel@tonic-gate next_adv_pr = adv_pr->adv_pr_next; 12617c478bd9Sstevel@tonic-gate nexti = adv_prefix_timer(adv_pr, elapsed); 12627c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next) 12637c478bd9Sstevel@tonic-gate next = nexti; 12647c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 12657c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts " 12667c478bd9Sstevel@tonic-gate "(adv pr on %s): %d -> %u ms\n", 12677c478bd9Sstevel@tonic-gate adv_pr->adv_pr_physical->pi_name, 12687c478bd9Sstevel@tonic-gate nexti, next); 12697c478bd9Sstevel@tonic-gate } 12707c478bd9Sstevel@tonic-gate } 12717c478bd9Sstevel@tonic-gate for (dr = pi->pi_router_list; dr != NULL; dr = next_dr) { 12727c478bd9Sstevel@tonic-gate next_dr = dr->dr_next; 12737c478bd9Sstevel@tonic-gate nexti = router_timer(dr, elapsed); 12747c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next) 12757c478bd9Sstevel@tonic-gate next = nexti; 12767c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 12777c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (dr): " 12787c478bd9Sstevel@tonic-gate "%d -> %u ms\n", nexti, next); 12797c478bd9Sstevel@tonic-gate } 12807c478bd9Sstevel@tonic-gate } 12817c478bd9Sstevel@tonic-gate if (pi->pi_TmpAddrsEnabled) { 12827c478bd9Sstevel@tonic-gate nexti = tmptoken_timer(pi, elapsed); 12837c478bd9Sstevel@tonic-gate if (nexti != TIMER_INFINITY && nexti < next) 12847c478bd9Sstevel@tonic-gate next = nexti; 12857c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 12867c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts (tmp on %s): " 12877c478bd9Sstevel@tonic-gate "%d -> %u ms\n", pi->pi_name, nexti, next); 12887c478bd9Sstevel@tonic-gate } 12897c478bd9Sstevel@tonic-gate } 12907c478bd9Sstevel@tonic-gate } 12917c478bd9Sstevel@tonic-gate /* 12927c478bd9Sstevel@tonic-gate * Make sure the timer functions are run at least once 12937c478bd9Sstevel@tonic-gate * an hour. 12947c478bd9Sstevel@tonic-gate */ 12957c478bd9Sstevel@tonic-gate if (next == TIMER_INFINITY) 12967c478bd9Sstevel@tonic-gate next = 3600 * 1000; /* 1 hour */ 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate if (debug & D_TIMER) 12997c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: %u ms\n", next); 13007c478bd9Sstevel@tonic-gate timer_schedule(next); 13017c478bd9Sstevel@tonic-gate if (do_retry) { 13027c478bd9Sstevel@tonic-gate if (debug & D_TIMER) 13037c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "run_timeouts: retry\n"); 13047c478bd9Sstevel@tonic-gate do_retry = _B_FALSE; 13057c478bd9Sstevel@tonic-gate goto retry; 13067c478bd9Sstevel@tonic-gate } 13077c478bd9Sstevel@tonic-gate timeout_running = _B_FALSE; 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate static int eventpipe_read = -1; /* Used for synchronous signal delivery */ 13117c478bd9Sstevel@tonic-gate static int eventpipe_write = -1; 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate /* 13147c478bd9Sstevel@tonic-gate * Ensure that signals are processed synchronously with the rest of 13157c478bd9Sstevel@tonic-gate * the code by just writing a one character signal number on the pipe. 13167c478bd9Sstevel@tonic-gate * The poll loop will pick this up and process the signal event. 13177c478bd9Sstevel@tonic-gate */ 13187c478bd9Sstevel@tonic-gate static void 13197c478bd9Sstevel@tonic-gate sig_handler(int signo) 13207c478bd9Sstevel@tonic-gate { 13217c478bd9Sstevel@tonic-gate uchar_t buf = (uchar_t)signo; 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate if (eventpipe_write == -1) { 13247c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "sig_handler: no pipe\n"); 13257c478bd9Sstevel@tonic-gate return; 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate if (write(eventpipe_write, &buf, sizeof (buf)) < 0) 13287c478bd9Sstevel@tonic-gate logperror("sig_handler: write"); 13297c478bd9Sstevel@tonic-gate } 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate /* 13327c478bd9Sstevel@tonic-gate * Pick up a signal "byte" from the pipe and process it. 13337c478bd9Sstevel@tonic-gate */ 13347c478bd9Sstevel@tonic-gate static void 13357c478bd9Sstevel@tonic-gate in_signal(int fd) 13367c478bd9Sstevel@tonic-gate { 13377c478bd9Sstevel@tonic-gate uchar_t buf; 13387c478bd9Sstevel@tonic-gate struct phyint *pi; 13397c478bd9Sstevel@tonic-gate struct phyint *next_pi; 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate switch (read(fd, &buf, sizeof (buf))) { 13427c478bd9Sstevel@tonic-gate case -1: 13437c478bd9Sstevel@tonic-gate logperror("in_signal: read"); 13447c478bd9Sstevel@tonic-gate exit(1); 13457c478bd9Sstevel@tonic-gate /* NOTREACHED */ 13467c478bd9Sstevel@tonic-gate case 1: 13477c478bd9Sstevel@tonic-gate break; 13487c478bd9Sstevel@tonic-gate case 0: 13497c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "in_signal: read eof\n"); 13507c478bd9Sstevel@tonic-gate exit(1); 13517c478bd9Sstevel@tonic-gate /* NOTREACHED */ 13527c478bd9Sstevel@tonic-gate default: 13537c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "in_signal: read > 1\n"); 13547c478bd9Sstevel@tonic-gate exit(1); 13557c478bd9Sstevel@tonic-gate } 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate if (debug & D_TIMER) 13587c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "in_signal() got %d\n", buf); 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate switch (buf) { 13617c478bd9Sstevel@tonic-gate case SIGALRM: 13627c478bd9Sstevel@tonic-gate if (debug & D_TIMER) { 13637c478bd9Sstevel@tonic-gate uint_t now = getcurrenttime(); 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "in_signal(SIGALRM) delta %u\n", 13667c478bd9Sstevel@tonic-gate now - timer_next); 13677c478bd9Sstevel@tonic-gate } 13687c478bd9Sstevel@tonic-gate timer_next = TIMER_INFINITY; 13697c478bd9Sstevel@tonic-gate run_timeouts(); 13707c478bd9Sstevel@tonic-gate break; 13717c478bd9Sstevel@tonic-gate case SIGHUP: 13727c478bd9Sstevel@tonic-gate /* Re-read config file by exec'ing ourselves */ 13737c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) { 13747c478bd9Sstevel@tonic-gate next_pi = pi->pi_next; 13757c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements) 13767c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_FINAL_ADV); 13777c478bd9Sstevel@tonic-gate 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 (void) unlink(PATH_PID); 13917c478bd9Sstevel@tonic-gate _exit(0177); 13927c478bd9Sstevel@tonic-gate /* NOTREACHED */ 13937c478bd9Sstevel@tonic-gate case SIGUSR1: 13947c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "Printing configuration:\n"); 13957c478bd9Sstevel@tonic-gate phyint_print_all(); 13967c478bd9Sstevel@tonic-gate break; 13977c478bd9Sstevel@tonic-gate case SIGINT: 13987c478bd9Sstevel@tonic-gate case SIGTERM: 13997c478bd9Sstevel@tonic-gate case SIGQUIT: 14007c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = next_pi) { 14017c478bd9Sstevel@tonic-gate next_pi = pi->pi_next; 14027c478bd9Sstevel@tonic-gate if (pi->pi_AdvSendAdvertisements) 14037c478bd9Sstevel@tonic-gate check_to_advertise(pi, START_FINAL_ADV); 14047c478bd9Sstevel@tonic-gate 14057c478bd9Sstevel@tonic-gate phyint_delete(pi); 14067c478bd9Sstevel@tonic-gate } 14073173664eSapersson (void) unlink(NDPD_SNMP_SOCKET); 14087c478bd9Sstevel@tonic-gate (void) unlink(PATH_PID); 14097c478bd9Sstevel@tonic-gate exit(0); 14107c478bd9Sstevel@tonic-gate /* NOTREACHED */ 14117c478bd9Sstevel@tonic-gate case 255: 14127c478bd9Sstevel@tonic-gate /* 14137c478bd9Sstevel@tonic-gate * Special "signal" from looback_ra_enqueue. 14147c478bd9Sstevel@tonic-gate * Handle any queued loopback router advertisements. 14157c478bd9Sstevel@tonic-gate */ 14167c478bd9Sstevel@tonic-gate loopback_ra_dequeue(); 14177c478bd9Sstevel@tonic-gate break; 14187c478bd9Sstevel@tonic-gate default: 14197c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "in_signal: unknown signal: %d\n", buf); 14207c478bd9Sstevel@tonic-gate } 14217c478bd9Sstevel@tonic-gate } 14227c478bd9Sstevel@tonic-gate 14237c478bd9Sstevel@tonic-gate /* 14247c478bd9Sstevel@tonic-gate * Create pipe for signal delivery and set up signal handlers. 14257c478bd9Sstevel@tonic-gate */ 14267c478bd9Sstevel@tonic-gate static void 14277c478bd9Sstevel@tonic-gate setup_eventpipe(void) 14287c478bd9Sstevel@tonic-gate { 14297c478bd9Sstevel@tonic-gate int fds[2]; 14307c478bd9Sstevel@tonic-gate struct sigaction act; 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate if ((pipe(fds)) < 0) { 14337c478bd9Sstevel@tonic-gate logperror("setup_eventpipe: pipe"); 14347c478bd9Sstevel@tonic-gate exit(1); 14357c478bd9Sstevel@tonic-gate } 14367c478bd9Sstevel@tonic-gate eventpipe_read = fds[0]; 14377c478bd9Sstevel@tonic-gate eventpipe_write = fds[1]; 14387c478bd9Sstevel@tonic-gate if (poll_add(eventpipe_read) == -1) { 14397c478bd9Sstevel@tonic-gate exit(1); 14407c478bd9Sstevel@tonic-gate } 14417c478bd9Sstevel@tonic-gate act.sa_handler = sig_handler; 14427c478bd9Sstevel@tonic-gate act.sa_flags = SA_RESTART; 14437c478bd9Sstevel@tonic-gate (void) sigaction(SIGALRM, &act, NULL); 14447c478bd9Sstevel@tonic-gate 14457c478bd9Sstevel@tonic-gate (void) sigset(SIGHUP, sig_handler); 14467c478bd9Sstevel@tonic-gate (void) sigset(SIGUSR1, sig_handler); 14477c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, sig_handler); 14487c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, sig_handler); 14497c478bd9Sstevel@tonic-gate (void) sigset(SIGQUIT, sig_handler); 14507c478bd9Sstevel@tonic-gate } 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate /* 14537c478bd9Sstevel@tonic-gate * Create a routing socket for receiving RTM_IFINFO messages and initialize 14547c478bd9Sstevel@tonic-gate * the routing socket message header and as much of the sockaddrs as possible. 14557c478bd9Sstevel@tonic-gate */ 14567c478bd9Sstevel@tonic-gate static int 14577c478bd9Sstevel@tonic-gate setup_rtsock(void) 14587c478bd9Sstevel@tonic-gate { 14597c478bd9Sstevel@tonic-gate int s; 14607c478bd9Sstevel@tonic-gate int ret; 14617c478bd9Sstevel@tonic-gate char *cp; 14627c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate s = socket(PF_ROUTE, SOCK_RAW, AF_INET6); 14657c478bd9Sstevel@tonic-gate if (s == -1) { 14667c478bd9Sstevel@tonic-gate logperror("socket(PF_ROUTE)"); 14677c478bd9Sstevel@tonic-gate exit(1); 14687c478bd9Sstevel@tonic-gate } 14697c478bd9Sstevel@tonic-gate ret = fcntl(s, F_SETFL, O_NDELAY|O_NONBLOCK); 14707c478bd9Sstevel@tonic-gate if (ret < 0) { 14717c478bd9Sstevel@tonic-gate logperror("fcntl(O_NDELAY)"); 14727c478bd9Sstevel@tonic-gate exit(1); 14737c478bd9Sstevel@tonic-gate } 14747c478bd9Sstevel@tonic-gate if (poll_add(s) == -1) { 14757c478bd9Sstevel@tonic-gate exit(1); 14767c478bd9Sstevel@tonic-gate } 14777c478bd9Sstevel@tonic-gate 14787c478bd9Sstevel@tonic-gate /* 14797c478bd9Sstevel@tonic-gate * Allocate storage for the routing socket message. 14807c478bd9Sstevel@tonic-gate */ 14817c478bd9Sstevel@tonic-gate rt_msg = (struct rt_msghdr *)malloc(NDP_RTM_MSGLEN); 14827c478bd9Sstevel@tonic-gate if (rt_msg == NULL) { 14837c478bd9Sstevel@tonic-gate logperror("malloc"); 14847c478bd9Sstevel@tonic-gate exit(1); 14857c478bd9Sstevel@tonic-gate } 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate /* 14887c478bd9Sstevel@tonic-gate * Initialize the routing socket message by zero-filling it and then 14897c478bd9Sstevel@tonic-gate * setting the fields where are constant through the lifetime of the 14907c478bd9Sstevel@tonic-gate * process. 14917c478bd9Sstevel@tonic-gate */ 14927c478bd9Sstevel@tonic-gate bzero(rt_msg, NDP_RTM_MSGLEN); 14937c478bd9Sstevel@tonic-gate rt_msg->rtm_msglen = NDP_RTM_MSGLEN; 14947c478bd9Sstevel@tonic-gate rt_msg->rtm_version = RTM_VERSION; 14957c478bd9Sstevel@tonic-gate rt_msg->rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK | RTA_IFP; 14967c478bd9Sstevel@tonic-gate rt_msg->rtm_pid = getpid(); 14977c478bd9Sstevel@tonic-gate if (rt_msg->rtm_pid < 0) { 14987c478bd9Sstevel@tonic-gate logperror("getpid"); 14997c478bd9Sstevel@tonic-gate exit(1); 15007c478bd9Sstevel@tonic-gate } 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate /* 15037c478bd9Sstevel@tonic-gate * The RTA_DST sockaddr does not change during the lifetime of the 15047c478bd9Sstevel@tonic-gate * process so it can be completely initialized at this time. 15057c478bd9Sstevel@tonic-gate */ 15067c478bd9Sstevel@tonic-gate cp = (char *)rt_msg + sizeof (struct rt_msghdr); 15077c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)cp; 15087c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6; 15097c478bd9Sstevel@tonic-gate sin6->sin6_addr = in6addr_any; 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate /* 15127c478bd9Sstevel@tonic-gate * Initialize the constant portion of the RTA_GATEWAY sockaddr. 15137c478bd9Sstevel@tonic-gate */ 15147c478bd9Sstevel@tonic-gate cp += sizeof (struct sockaddr_in6); 15157c478bd9Sstevel@tonic-gate rta_gateway = (struct sockaddr_in6 *)cp; 15167c478bd9Sstevel@tonic-gate rta_gateway->sin6_family = AF_INET6; 15177c478bd9Sstevel@tonic-gate 15187c478bd9Sstevel@tonic-gate /* 15197c478bd9Sstevel@tonic-gate * The RTA_NETMASK sockaddr does not change during the lifetime of the 15207c478bd9Sstevel@tonic-gate * process so it can be completely initialized at this time. 15217c478bd9Sstevel@tonic-gate */ 15227c478bd9Sstevel@tonic-gate cp += sizeof (struct sockaddr_in6); 15237c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)cp; 15247c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6; 15257c478bd9Sstevel@tonic-gate sin6->sin6_addr = in6addr_any; 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate /* 15287c478bd9Sstevel@tonic-gate * Initialize the constant portion of the RTA_IFP sockaddr. 15297c478bd9Sstevel@tonic-gate */ 15307c478bd9Sstevel@tonic-gate cp += sizeof (struct sockaddr_in6); 15317c478bd9Sstevel@tonic-gate rta_ifp = (struct sockaddr_dl *)cp; 15327c478bd9Sstevel@tonic-gate rta_ifp->sdl_family = AF_LINK; 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate return (s); 15357c478bd9Sstevel@tonic-gate } 15367c478bd9Sstevel@tonic-gate 15373173664eSapersson static int 15383173664eSapersson setup_mibsock(void) 15393173664eSapersson { 15403173664eSapersson int sock; 15413173664eSapersson int ret; 15423173664eSapersson int len; 15433173664eSapersson struct sockaddr_un laddr; 15443173664eSapersson 15453173664eSapersson sock = socket(AF_UNIX, SOCK_DGRAM, 0); 15463173664eSapersson if (sock == -1) { 15473173664eSapersson logperror("setup_mibsock: socket(AF_UNIX)"); 15483173664eSapersson exit(1); 15493173664eSapersson } 15503173664eSapersson 15513173664eSapersson bzero(&laddr, sizeof (laddr)); 15523173664eSapersson laddr.sun_family = AF_UNIX; 15533173664eSapersson 15543173664eSapersson (void) strncpy(laddr.sun_path, NDPD_SNMP_SOCKET, 15553173664eSapersson sizeof (laddr.sun_path)); 15563173664eSapersson len = sizeof (struct sockaddr_un); 15573173664eSapersson 15583173664eSapersson (void) unlink(NDPD_SNMP_SOCKET); 15593173664eSapersson ret = bind(sock, (struct sockaddr *)&laddr, len); 15603173664eSapersson if (ret < 0) { 15613173664eSapersson logperror("setup_mibsock: bind\n"); 15623173664eSapersson exit(1); 15633173664eSapersson } 15643173664eSapersson 15653173664eSapersson ret = fcntl(sock, F_SETFL, O_NONBLOCK); 15663173664eSapersson if (ret < 0) { 15673173664eSapersson logperror("fcntl(O_NONBLOCK)"); 15683173664eSapersson exit(1); 15693173664eSapersson } 15703173664eSapersson if (poll_add(sock) == -1) { 15713173664eSapersson exit(1); 15723173664eSapersson } 15733173664eSapersson return (sock); 15743173664eSapersson } 15753173664eSapersson 15767c478bd9Sstevel@tonic-gate /* 15777c478bd9Sstevel@tonic-gate * Retrieve one routing socket message. If RTM_IFINFO indicates 15787c478bd9Sstevel@tonic-gate * new phyint do a full scan of the interfaces. If RTM_IFINFO 157969bb4bb4Scarlsonj * indicates an existing phyint, only scan that phyint and associated 15807c478bd9Sstevel@tonic-gate * prefixes. 15817c478bd9Sstevel@tonic-gate */ 15827c478bd9Sstevel@tonic-gate static void 15837c478bd9Sstevel@tonic-gate process_rtsock(int rtsock) 15847c478bd9Sstevel@tonic-gate { 15857c478bd9Sstevel@tonic-gate int n; 15867c478bd9Sstevel@tonic-gate #define MSG_SIZE 2048/8 15877c478bd9Sstevel@tonic-gate int64_t msg[MSG_SIZE]; 15887c478bd9Sstevel@tonic-gate struct rt_msghdr *rtm; 15897c478bd9Sstevel@tonic-gate struct if_msghdr *ifm; 15907c478bd9Sstevel@tonic-gate struct phyint *pi; 15917c478bd9Sstevel@tonic-gate struct prefix *pr; 15927c478bd9Sstevel@tonic-gate boolean_t need_initifs = _B_FALSE; 15937c478bd9Sstevel@tonic-gate boolean_t need_ifscan = _B_FALSE; 15947c478bd9Sstevel@tonic-gate int64_t ifscan_msg[10][MSG_SIZE]; 15957c478bd9Sstevel@tonic-gate int ifscan_index = 0; 15967c478bd9Sstevel@tonic-gate int i; 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate /* Empty the rtsock and coealesce all the work that we have */ 15997c478bd9Sstevel@tonic-gate while (ifscan_index < 10) { 16007c478bd9Sstevel@tonic-gate n = read(rtsock, msg, sizeof (msg)); 16017c478bd9Sstevel@tonic-gate if (n <= 0) { 16027c478bd9Sstevel@tonic-gate /* No more messages */ 16037c478bd9Sstevel@tonic-gate break; 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate rtm = (struct rt_msghdr *)msg; 16067c478bd9Sstevel@tonic-gate if (rtm->rtm_version != RTM_VERSION) { 16077c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, 16087c478bd9Sstevel@tonic-gate "process_rtsock: version %d not understood\n", 16097c478bd9Sstevel@tonic-gate rtm->rtm_version); 16107c478bd9Sstevel@tonic-gate return; 16117c478bd9Sstevel@tonic-gate } 16127c478bd9Sstevel@tonic-gate switch (rtm->rtm_type) { 16137c478bd9Sstevel@tonic-gate case RTM_NEWADDR: 16147c478bd9Sstevel@tonic-gate case RTM_DELADDR: 16157c478bd9Sstevel@tonic-gate /* 16167c478bd9Sstevel@tonic-gate * Some logical interface has changed - have to scan 16177c478bd9Sstevel@tonic-gate * everything to determine what actually changed. 16187c478bd9Sstevel@tonic-gate */ 16197c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) { 16207c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "process_rtsock: " 16217c478bd9Sstevel@tonic-gate "message %d\n", rtm->rtm_type); 16227c478bd9Sstevel@tonic-gate } 16237c478bd9Sstevel@tonic-gate need_initifs = _B_TRUE; 16247c478bd9Sstevel@tonic-gate break; 16257c478bd9Sstevel@tonic-gate case RTM_IFINFO: 16267c478bd9Sstevel@tonic-gate need_ifscan = _B_TRUE; 16277c478bd9Sstevel@tonic-gate (void) memcpy(ifscan_msg[ifscan_index], rtm, 16287c478bd9Sstevel@tonic-gate sizeof (msg)); 16297c478bd9Sstevel@tonic-gate ifscan_index++; 16307c478bd9Sstevel@tonic-gate /* Handled below */ 16317c478bd9Sstevel@tonic-gate break; 16327c478bd9Sstevel@tonic-gate default: 16337c478bd9Sstevel@tonic-gate /* Not interesting */ 16347c478bd9Sstevel@tonic-gate break; 16357c478bd9Sstevel@tonic-gate } 16367c478bd9Sstevel@tonic-gate } 16377c478bd9Sstevel@tonic-gate /* 16387c478bd9Sstevel@tonic-gate * If we do full scan i.e initifs, we don't need to 16397c478bd9Sstevel@tonic-gate * scan a particular interface as we should have 16407c478bd9Sstevel@tonic-gate * done that as part of initifs. 16417c478bd9Sstevel@tonic-gate */ 16427c478bd9Sstevel@tonic-gate if (need_initifs) { 16437c478bd9Sstevel@tonic-gate initifs(_B_FALSE); 16447c478bd9Sstevel@tonic-gate return; 16457c478bd9Sstevel@tonic-gate } 16467c478bd9Sstevel@tonic-gate 16477c478bd9Sstevel@tonic-gate if (!need_ifscan) 16487c478bd9Sstevel@tonic-gate return; 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate for (i = 0; i < ifscan_index; i++) { 16517c478bd9Sstevel@tonic-gate ifm = (struct if_msghdr *)ifscan_msg[i]; 16527c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) 16537c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "process_rtsock: index %d\n", 16547c478bd9Sstevel@tonic-gate ifm->ifm_index); 16557c478bd9Sstevel@tonic-gate 16567c478bd9Sstevel@tonic-gate pi = phyint_lookup_on_index(ifm->ifm_index); 16577c478bd9Sstevel@tonic-gate if (pi == NULL) { 16587c478bd9Sstevel@tonic-gate /* 16597c478bd9Sstevel@tonic-gate * A new physical interface. Do a full scan of the 16607c478bd9Sstevel@tonic-gate * to catch any new logical interfaces. 16617c478bd9Sstevel@tonic-gate */ 16627c478bd9Sstevel@tonic-gate initifs(_B_FALSE); 16637c478bd9Sstevel@tonic-gate return; 16647c478bd9Sstevel@tonic-gate } 16657c478bd9Sstevel@tonic-gate 1666*e11c3f44Smeem if (ifm->ifm_flags != (uint_t)pi->pi_flags) { 16677c478bd9Sstevel@tonic-gate if (debug & D_IFSCAN) { 16687c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "process_rtsock: clr for " 1669*e11c3f44Smeem "%s old flags 0x%llx new flags 0x%x\n", 16707c478bd9Sstevel@tonic-gate pi->pi_name, pi->pi_flags, ifm->ifm_flags); 16717c478bd9Sstevel@tonic-gate } 16727c478bd9Sstevel@tonic-gate } 16737c478bd9Sstevel@tonic-gate 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate /* 16767c478bd9Sstevel@tonic-gate * Mark the interfaces so that we can find phyints and prefixes 16777c478bd9Sstevel@tonic-gate * which have disappeared from the kernel. 16787c478bd9Sstevel@tonic-gate * if_process will set pr_in_use when it finds the 16797c478bd9Sstevel@tonic-gate * interface in the kernel. 16807c478bd9Sstevel@tonic-gate * Before re-examining the state of the interfaces, 16817c478bd9Sstevel@tonic-gate * PI_PRESENT should be cleared from pi_kernel_state. 16827c478bd9Sstevel@tonic-gate */ 16837c478bd9Sstevel@tonic-gate pi->pi_kernel_state &= ~PI_PRESENT; 16847c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { 16857c478bd9Sstevel@tonic-gate pr->pr_in_use = _B_FALSE; 16867c478bd9Sstevel@tonic-gate } 16877c478bd9Sstevel@tonic-gate 16887c478bd9Sstevel@tonic-gate if (ifsock < 0) { 16897c478bd9Sstevel@tonic-gate ifsock = socket(AF_INET6, SOCK_DGRAM, 0); 16907c478bd9Sstevel@tonic-gate if (ifsock < 0) { 16917c478bd9Sstevel@tonic-gate logperror("process_rtsock: socket"); 16927c478bd9Sstevel@tonic-gate return; 16937c478bd9Sstevel@tonic-gate } 16947c478bd9Sstevel@tonic-gate } 16957c478bd9Sstevel@tonic-gate if_process(ifsock, pi->pi_name, _B_FALSE); 16967c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { 16977c478bd9Sstevel@tonic-gate if_process(ifsock, pr->pr_name, _B_FALSE); 16987c478bd9Sstevel@tonic-gate } 16997c478bd9Sstevel@tonic-gate /* 17007c478bd9Sstevel@tonic-gate * If interface (still) exists in kernel, set 17017c478bd9Sstevel@tonic-gate * pi_state to indicate that. 17027c478bd9Sstevel@tonic-gate */ 17037c478bd9Sstevel@tonic-gate if (pi->pi_kernel_state & PI_PRESENT) { 17047c478bd9Sstevel@tonic-gate pi->pi_state |= PI_PRESENT; 17057c478bd9Sstevel@tonic-gate } 17067c478bd9Sstevel@tonic-gate check_if_removed(pi); 17077c478bd9Sstevel@tonic-gate if (show_ifs) 17087c478bd9Sstevel@tonic-gate phyint_print_all(); 17097c478bd9Sstevel@tonic-gate } 17107c478bd9Sstevel@tonic-gate } 17117c478bd9Sstevel@tonic-gate 17123173664eSapersson static void 17133173664eSapersson process_mibsock(int mibsock) 17143173664eSapersson { 17153173664eSapersson struct phyint *pi; 17163173664eSapersson socklen_t fromlen; 17173173664eSapersson struct sockaddr_un from; 17183173664eSapersson ndpd_info_t ndpd_info; 17193173664eSapersson ssize_t len; 17203173664eSapersson int command; 17213173664eSapersson 17223173664eSapersson fromlen = (socklen_t)sizeof (from); 17233173664eSapersson len = recvfrom(mibsock, &command, sizeof (int), 0, 17243173664eSapersson (struct sockaddr *)&from, &fromlen); 17253173664eSapersson 17263173664eSapersson if (len < sizeof (int) || command != NDPD_SNMP_INFO_REQ) { 17273173664eSapersson logperror("process_mibsock: bad command \n"); 17283173664eSapersson return; 17293173664eSapersson } 17303173664eSapersson 17313173664eSapersson ndpd_info.info_type = NDPD_SNMP_INFO_RESPONSE; 17323173664eSapersson ndpd_info.info_version = NDPD_SNMP_INFO_VER; 17333173664eSapersson ndpd_info.info_num_of_phyints = num_of_phyints; 17343173664eSapersson 17353173664eSapersson (void) sendto(mibsock, &ndpd_info, sizeof (ndpd_info_t), 0, 17363173664eSapersson (struct sockaddr *)&from, fromlen); 17373173664eSapersson 17383173664eSapersson for (pi = phyints; pi != NULL; pi = pi->pi_next) { 17393173664eSapersson int prefixes; 17403173664eSapersson int routers; 17413173664eSapersson struct prefix *prefix_list; 17423173664eSapersson struct router *router_list; 17433173664eSapersson ndpd_phyint_info_t phyint; 17443173664eSapersson ndpd_prefix_info_t prefix; 17453173664eSapersson ndpd_router_info_t router; 17463173664eSapersson /* 17473173664eSapersson * get number of prefixes 17483173664eSapersson */ 17493173664eSapersson routers = 0; 17503173664eSapersson prefixes = 0; 17513173664eSapersson prefix_list = pi->pi_prefix_list; 17523173664eSapersson while (prefix_list != NULL) { 17533173664eSapersson prefixes++; 17543173664eSapersson prefix_list = prefix_list->pr_next; 17553173664eSapersson } 17563173664eSapersson 17573173664eSapersson /* 17583173664eSapersson * get number of routers 17593173664eSapersson */ 17603173664eSapersson router_list = pi->pi_router_list; 17613173664eSapersson while (router_list != NULL) { 17623173664eSapersson routers++; 17633173664eSapersson router_list = router_list->dr_next; 17643173664eSapersson } 17653173664eSapersson 17663173664eSapersson phyint.phyint_info_type = NDPD_PHYINT_INFO; 17673173664eSapersson phyint.phyint_info_version = NDPD_PHYINT_INFO_VER; 17683173664eSapersson phyint.phyint_index = pi->pi_index; 17693173664eSapersson bcopy(pi->pi_config, 17703173664eSapersson phyint.phyint_config, I_IFSIZE); 17713173664eSapersson phyint.phyint_num_of_prefixes = prefixes; 17723173664eSapersson phyint.phyint_num_of_routers = routers; 17733173664eSapersson (void) sendto(mibsock, &phyint, sizeof (phyint), 0, 17743173664eSapersson (struct sockaddr *)&from, fromlen); 17753173664eSapersson 17763173664eSapersson /* 17773173664eSapersson * Copy prefix information 17783173664eSapersson */ 17793173664eSapersson 17803173664eSapersson prefix_list = pi->pi_prefix_list; 17813173664eSapersson while (prefix_list != NULL) { 17823173664eSapersson prefix.prefix_info_type = NDPD_PREFIX_INFO; 17833173664eSapersson prefix.prefix_info_version = NDPD_PREFIX_INFO_VER; 17843173664eSapersson prefix.prefix_prefix = prefix_list->pr_prefix; 17853173664eSapersson prefix.prefix_len = prefix_list->pr_prefix_len; 17863173664eSapersson prefix.prefix_flags = prefix_list->pr_flags; 17873173664eSapersson prefix.prefix_phyint_index = pi->pi_index; 17883173664eSapersson prefix.prefix_ValidLifetime = 17893173664eSapersson prefix_list->pr_ValidLifetime; 17903173664eSapersson prefix.prefix_PreferredLifetime = 17913173664eSapersson prefix_list->pr_PreferredLifetime; 17923173664eSapersson prefix.prefix_OnLinkLifetime = 17933173664eSapersson prefix_list->pr_OnLinkLifetime; 17943173664eSapersson prefix.prefix_OnLinkFlag = 17953173664eSapersson prefix_list->pr_OnLinkFlag; 17963173664eSapersson prefix.prefix_AutonomousFlag = 17973173664eSapersson prefix_list->pr_AutonomousFlag; 17983173664eSapersson (void) sendto(mibsock, &prefix, sizeof (prefix), 0, 17993173664eSapersson (struct sockaddr *)&from, fromlen); 18003173664eSapersson prefix_list = prefix_list->pr_next; 18013173664eSapersson } 18023173664eSapersson /* 18033173664eSapersson * Copy router information 18043173664eSapersson */ 18053173664eSapersson router_list = pi->pi_router_list; 18063173664eSapersson while (router_list != NULL) { 18073173664eSapersson router.router_info_type = NDPD_ROUTER_INFO; 18083173664eSapersson router.router_info_version = NDPD_ROUTER_INFO_VER; 18093173664eSapersson router.router_address = router_list->dr_address; 18103173664eSapersson router.router_lifetime = router_list->dr_lifetime; 18113173664eSapersson router.router_phyint_index = pi->pi_index; 18123173664eSapersson (void) sendto(mibsock, &router, sizeof (router), 0, 18133173664eSapersson (struct sockaddr *)&from, fromlen); 18143173664eSapersson router_list = router_list->dr_next; 18153173664eSapersson } 18163173664eSapersson } 18173173664eSapersson } 18183173664eSapersson 18197c478bd9Sstevel@tonic-gate /* 18207c478bd9Sstevel@tonic-gate * Look if the phyint or one of its prefixes have been removed from 18217c478bd9Sstevel@tonic-gate * the kernel and take appropriate action. 1822*e11c3f44Smeem * Uses pr_in_use and pi{,_kernel}_state. 18237c478bd9Sstevel@tonic-gate */ 18247c478bd9Sstevel@tonic-gate static void 18257c478bd9Sstevel@tonic-gate check_if_removed(struct phyint *pi) 18267c478bd9Sstevel@tonic-gate { 1827*e11c3f44Smeem struct prefix *pr, *next_pr; 18287c478bd9Sstevel@tonic-gate 18297c478bd9Sstevel@tonic-gate /* 18307c478bd9Sstevel@tonic-gate * Detect prefixes which are removed. 1831*e11c3f44Smeem * Static prefixes are just removed from our tables. 1832*e11c3f44Smeem * Non-static prefixes are recreated i.e. in.ndpd takes precedence 1833*e11c3f44Smeem * over manually removing prefixes via ifconfig. 18347c478bd9Sstevel@tonic-gate */ 18357c478bd9Sstevel@tonic-gate for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) { 18367c478bd9Sstevel@tonic-gate next_pr = pr->pr_next; 18377c478bd9Sstevel@tonic-gate if (!pr->pr_in_use) { 1838*e11c3f44Smeem /* Clear everything except PR_STATIC */ 18397c478bd9Sstevel@tonic-gate pr->pr_kernel_state &= PR_STATIC; 1840*e11c3f44Smeem pr->pr_name[0] = '\0'; 1841*e11c3f44Smeem if (pr->pr_state & PR_STATIC) { 18427c478bd9Sstevel@tonic-gate prefix_delete(pr); 1843*e11c3f44Smeem } else if (!(pi->pi_kernel_state & PI_PRESENT)) { 1844*e11c3f44Smeem /* 1845*e11c3f44Smeem * Ensure that there are no future attempts to 1846*e11c3f44Smeem * run prefix_update_k since the phyint is gone. 1847*e11c3f44Smeem */ 1848*e11c3f44Smeem pr->pr_state = pr->pr_kernel_state; 1849*e11c3f44Smeem } else if (pr->pr_state != pr->pr_kernel_state) { 18507c478bd9Sstevel@tonic-gate logmsg(LOG_INFO, "Prefix manually removed " 1851*e11c3f44Smeem "on %s; recreating\n", pi->pi_name); 18527c478bd9Sstevel@tonic-gate prefix_update_k(pr); 18537c478bd9Sstevel@tonic-gate } 18547c478bd9Sstevel@tonic-gate } 18557c478bd9Sstevel@tonic-gate } 1856*e11c3f44Smeem 1857*e11c3f44Smeem /* 1858*e11c3f44Smeem * Detect phyints that have been removed from the kernel, and tear 1859*e11c3f44Smeem * down any prefixes we created that are associated with that phyint. 1860*e11c3f44Smeem * (NOTE: IPMP depends on in.ndpd tearing down these prefixes so an 1861*e11c3f44Smeem * administrator can easily place an IP interface with ADDRCONF'd 1862*e11c3f44Smeem * addresses into an IPMP group.) 1863*e11c3f44Smeem */ 1864*e11c3f44Smeem if (!(pi->pi_kernel_state & PI_PRESENT) && 1865*e11c3f44Smeem (pi->pi_state & PI_PRESENT)) { 1866*e11c3f44Smeem logmsg(LOG_ERR, "Interface %s has been removed from kernel. " 1867*e11c3f44Smeem "in.ndpd will no longer use it\n", pi->pi_name); 1868*e11c3f44Smeem 1869*e11c3f44Smeem for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) { 1870*e11c3f44Smeem next_pr = pr->pr_next; 1871*e11c3f44Smeem if (pr->pr_state & PR_AUTO) 1872*e11c3f44Smeem prefix_delete(pr); 1873*e11c3f44Smeem } 1874*e11c3f44Smeem 1875*e11c3f44Smeem /* 1876*e11c3f44Smeem * Clear state so that should the phyint reappear we will 1877*e11c3f44Smeem * start with initial advertisements or solicitations. 1878*e11c3f44Smeem */ 1879*e11c3f44Smeem phyint_cleanup(pi); 1880*e11c3f44Smeem } 18817c478bd9Sstevel@tonic-gate } 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate 18847c478bd9Sstevel@tonic-gate /* 18857c478bd9Sstevel@tonic-gate * Queuing mechanism for router advertisements that are sent by in.ndpd 18867c478bd9Sstevel@tonic-gate * and that also need to be processed by in.ndpd. 18877c478bd9Sstevel@tonic-gate * Uses "signal number" 255 to indicate to the main poll loop 18887c478bd9Sstevel@tonic-gate * that there is something to dequeue and send to incomining_ra(). 18897c478bd9Sstevel@tonic-gate */ 18907c478bd9Sstevel@tonic-gate struct raq { 18917c478bd9Sstevel@tonic-gate struct raq *raq_next; 18927c478bd9Sstevel@tonic-gate struct phyint *raq_pi; 18937c478bd9Sstevel@tonic-gate int raq_packetlen; 18947c478bd9Sstevel@tonic-gate uchar_t *raq_packet; 18957c478bd9Sstevel@tonic-gate }; 18967c478bd9Sstevel@tonic-gate static struct raq *raq_head = NULL; 18977c478bd9Sstevel@tonic-gate 18987c478bd9Sstevel@tonic-gate /* 18997c478bd9Sstevel@tonic-gate * Allocate a struct raq and memory for the packet. 19007c478bd9Sstevel@tonic-gate * Send signal 255 to have poll dequeue. 19017c478bd9Sstevel@tonic-gate */ 19027c478bd9Sstevel@tonic-gate static void 19037c478bd9Sstevel@tonic-gate loopback_ra_enqueue(struct phyint *pi, struct nd_router_advert *ra, int len) 19047c478bd9Sstevel@tonic-gate { 19057c478bd9Sstevel@tonic-gate struct raq *raq; 19067c478bd9Sstevel@tonic-gate struct raq **raqp; 19077c478bd9Sstevel@tonic-gate 19087c478bd9Sstevel@tonic-gate if (no_loopback) 19097c478bd9Sstevel@tonic-gate return; 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate if (debug & D_PKTOUT) 19127c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "loopback_ra_enqueue for %s\n", pi->pi_name); 19137c478bd9Sstevel@tonic-gate 19147c478bd9Sstevel@tonic-gate raq = calloc(sizeof (struct raq), 1); 19157c478bd9Sstevel@tonic-gate if (raq == NULL) { 19167c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "loopback_ra_enqueue: out of memory\n"); 19177c478bd9Sstevel@tonic-gate return; 19187c478bd9Sstevel@tonic-gate } 19197c478bd9Sstevel@tonic-gate raq->raq_packet = malloc(len); 19207c478bd9Sstevel@tonic-gate if (raq->raq_packet == NULL) { 19217c478bd9Sstevel@tonic-gate free(raq); 19227c478bd9Sstevel@tonic-gate logmsg(LOG_ERR, "loopback_ra_enqueue: out of memory\n"); 19237c478bd9Sstevel@tonic-gate return; 19247c478bd9Sstevel@tonic-gate } 19257c478bd9Sstevel@tonic-gate bcopy(ra, raq->raq_packet, len); 19267c478bd9Sstevel@tonic-gate raq->raq_packetlen = len; 19277c478bd9Sstevel@tonic-gate raq->raq_pi = pi; 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate /* Tail insert */ 19307c478bd9Sstevel@tonic-gate raqp = &raq_head; 19317c478bd9Sstevel@tonic-gate while (*raqp != NULL) 19327c478bd9Sstevel@tonic-gate raqp = &((*raqp)->raq_next); 19337c478bd9Sstevel@tonic-gate *raqp = raq; 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate /* Signal for poll loop */ 19367c478bd9Sstevel@tonic-gate sig_handler(255); 19377c478bd9Sstevel@tonic-gate } 19387c478bd9Sstevel@tonic-gate 19397c478bd9Sstevel@tonic-gate /* 19407c478bd9Sstevel@tonic-gate * Dequeue and process all queued advertisements. 19417c478bd9Sstevel@tonic-gate */ 19427c478bd9Sstevel@tonic-gate static void 19437c478bd9Sstevel@tonic-gate loopback_ra_dequeue(void) 19447c478bd9Sstevel@tonic-gate { 19457c478bd9Sstevel@tonic-gate struct sockaddr_in6 from = IN6ADDR_LOOPBACK_INIT; 19467c478bd9Sstevel@tonic-gate struct raq *raq; 19477c478bd9Sstevel@tonic-gate 19487c478bd9Sstevel@tonic-gate if (debug & D_PKTIN) 19497c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "loopback_ra_dequeue()\n"); 19507c478bd9Sstevel@tonic-gate 19517c478bd9Sstevel@tonic-gate while ((raq = raq_head) != NULL) { 19527c478bd9Sstevel@tonic-gate raq_head = raq->raq_next; 19537c478bd9Sstevel@tonic-gate raq->raq_next = NULL; 19547c478bd9Sstevel@tonic-gate 19557c478bd9Sstevel@tonic-gate if (debug & D_PKTIN) { 19567c478bd9Sstevel@tonic-gate logmsg(LOG_DEBUG, "loopback_ra_dequeue for %s\n", 19577c478bd9Sstevel@tonic-gate raq->raq_pi->pi_name); 19587c478bd9Sstevel@tonic-gate } 19597c478bd9Sstevel@tonic-gate 19607c478bd9Sstevel@tonic-gate incoming_ra(raq->raq_pi, 19617c478bd9Sstevel@tonic-gate (struct nd_router_advert *)raq->raq_packet, 19627c478bd9Sstevel@tonic-gate raq->raq_packetlen, &from, _B_TRUE); 19637c478bd9Sstevel@tonic-gate free(raq->raq_packet); 19647c478bd9Sstevel@tonic-gate free(raq); 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate } 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate 19697c478bd9Sstevel@tonic-gate static void 19707c478bd9Sstevel@tonic-gate usage(char *cmd) 19717c478bd9Sstevel@tonic-gate { 19727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 19737c478bd9Sstevel@tonic-gate "usage: %s [ -adt ] [-f <config file>]\n", cmd); 19747c478bd9Sstevel@tonic-gate } 19757c478bd9Sstevel@tonic-gate 19767c478bd9Sstevel@tonic-gate int 19777c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 19787c478bd9Sstevel@tonic-gate { 19797c478bd9Sstevel@tonic-gate int i; 19807c478bd9Sstevel@tonic-gate struct phyint *pi; 19817c478bd9Sstevel@tonic-gate int c; 19827c478bd9Sstevel@tonic-gate char *config_file = PATH_NDPD_CONF; 19837c478bd9Sstevel@tonic-gate boolean_t file_required = _B_FALSE; 19847c478bd9Sstevel@tonic-gate 19857c478bd9Sstevel@tonic-gate argv0 = argv; 19867c478bd9Sstevel@tonic-gate srandom(gethostid()); 19877c478bd9Sstevel@tonic-gate (void) umask(0022); 19887c478bd9Sstevel@tonic-gate 19897c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "adD:ntIf:")) != EOF) { 19907c478bd9Sstevel@tonic-gate switch (c) { 19917c478bd9Sstevel@tonic-gate case 'a': 19927c478bd9Sstevel@tonic-gate /* 19937c478bd9Sstevel@tonic-gate * The StatelessAddrConf variable in ndpd.conf, if 19947c478bd9Sstevel@tonic-gate * present, will override this setting. 19957c478bd9Sstevel@tonic-gate */ 19967c478bd9Sstevel@tonic-gate ifdefaults[I_StatelessAddrConf].cf_value = 0; 19977c478bd9Sstevel@tonic-gate break; 19987c478bd9Sstevel@tonic-gate case 'd': 19997c478bd9Sstevel@tonic-gate debug = D_ALL; 20007c478bd9Sstevel@tonic-gate break; 20017c478bd9Sstevel@tonic-gate case 'D': 20027c478bd9Sstevel@tonic-gate i = strtol((char *)optarg, NULL, 0); 20037c478bd9Sstevel@tonic-gate if (i == 0) { 20047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "Bad debug flags: %s\n", 20057c478bd9Sstevel@tonic-gate (char *)optarg); 20067c478bd9Sstevel@tonic-gate exit(1); 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate debug |= i; 20097c478bd9Sstevel@tonic-gate break; 20107c478bd9Sstevel@tonic-gate case 'n': 20117c478bd9Sstevel@tonic-gate no_loopback = 1; 20127c478bd9Sstevel@tonic-gate break; 20137c478bd9Sstevel@tonic-gate case 'I': 20147c478bd9Sstevel@tonic-gate show_ifs = 1; 20157c478bd9Sstevel@tonic-gate break; 20167c478bd9Sstevel@tonic-gate case 't': 20177c478bd9Sstevel@tonic-gate debug |= D_PKTIN | D_PKTOUT | D_PKTBAD; 20187c478bd9Sstevel@tonic-gate break; 20197c478bd9Sstevel@tonic-gate case 'f': 20207c478bd9Sstevel@tonic-gate config_file = (char *)optarg; 20217c478bd9Sstevel@tonic-gate file_required = _B_TRUE; 20227c478bd9Sstevel@tonic-gate break; 20237c478bd9Sstevel@tonic-gate case '?': 20247c478bd9Sstevel@tonic-gate usage(argv[0]); 20257c478bd9Sstevel@tonic-gate exit(1); 20267c478bd9Sstevel@tonic-gate } 20277c478bd9Sstevel@tonic-gate } 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate if (parse_config(config_file, file_required) == -1) 20307c478bd9Sstevel@tonic-gate exit(2); 20317c478bd9Sstevel@tonic-gate 20327c478bd9Sstevel@tonic-gate if (show_ifs) 20337c478bd9Sstevel@tonic-gate phyint_print_all(); 20347c478bd9Sstevel@tonic-gate 20357c478bd9Sstevel@tonic-gate if (debug == 0) { 20367c478bd9Sstevel@tonic-gate initlog(); 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate setup_eventpipe(); 20407c478bd9Sstevel@tonic-gate rtsock = setup_rtsock(); 20413173664eSapersson mibsock = setup_mibsock(); 20427c478bd9Sstevel@tonic-gate timer_init(); 20437c478bd9Sstevel@tonic-gate initifs(_B_TRUE); 20447c478bd9Sstevel@tonic-gate 20457c478bd9Sstevel@tonic-gate check_daemonize(); 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate for (;;) { 20487c478bd9Sstevel@tonic-gate if (poll(pollfds, pollfd_num, -1) < 0) { 20497c478bd9Sstevel@tonic-gate if (errno == EINTR) 20507c478bd9Sstevel@tonic-gate continue; 20517c478bd9Sstevel@tonic-gate logperror("main: poll"); 20527c478bd9Sstevel@tonic-gate exit(1); 20537c478bd9Sstevel@tonic-gate } 20547c478bd9Sstevel@tonic-gate for (i = 0; i < pollfd_num; i++) { 20557c478bd9Sstevel@tonic-gate if (!(pollfds[i].revents & POLLIN)) 20567c478bd9Sstevel@tonic-gate continue; 20577c478bd9Sstevel@tonic-gate if (pollfds[i].fd == eventpipe_read) { 20587c478bd9Sstevel@tonic-gate in_signal(eventpipe_read); 20597c478bd9Sstevel@tonic-gate break; 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate if (pollfds[i].fd == rtsock) { 20627c478bd9Sstevel@tonic-gate process_rtsock(rtsock); 20637c478bd9Sstevel@tonic-gate break; 20647c478bd9Sstevel@tonic-gate } 20653173664eSapersson if (pollfds[i].fd == mibsock) { 20663173664eSapersson process_mibsock(mibsock); 20673173664eSapersson break; 20683173664eSapersson } 20697c478bd9Sstevel@tonic-gate /* 20707c478bd9Sstevel@tonic-gate * Run timer routine to advance clock if more than 20717c478bd9Sstevel@tonic-gate * half a second since the clock was advanced. 20727c478bd9Sstevel@tonic-gate * This limits CPU usage under severe packet 20737c478bd9Sstevel@tonic-gate * arrival rates but it creates a slight inaccuracy 20747c478bd9Sstevel@tonic-gate * in the timer mechanism. 20757c478bd9Sstevel@tonic-gate */ 20767c478bd9Sstevel@tonic-gate conditional_run_timeouts(500U); 20777c478bd9Sstevel@tonic-gate for (pi = phyints; pi != NULL; pi = pi->pi_next) { 20787c478bd9Sstevel@tonic-gate if (pollfds[i].fd == pi->pi_sock) { 20797c478bd9Sstevel@tonic-gate in_data(pi); 20807c478bd9Sstevel@tonic-gate break; 20817c478bd9Sstevel@tonic-gate } 20827c478bd9Sstevel@tonic-gate } 20837c478bd9Sstevel@tonic-gate } 20847c478bd9Sstevel@tonic-gate } 20857c478bd9Sstevel@tonic-gate /* NOTREACHED */ 20867c478bd9Sstevel@tonic-gate return (0); 20877c478bd9Sstevel@tonic-gate } 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate /* 20907c478bd9Sstevel@tonic-gate * LOGGER 20917c478bd9Sstevel@tonic-gate */ 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate static boolean_t logging = _B_FALSE; 20947c478bd9Sstevel@tonic-gate 20957c478bd9Sstevel@tonic-gate static void 20967c478bd9Sstevel@tonic-gate initlog(void) 20977c478bd9Sstevel@tonic-gate { 20987c478bd9Sstevel@tonic-gate logging = _B_TRUE; 20997c478bd9Sstevel@tonic-gate openlog("in.ndpd", LOG_PID | LOG_CONS, LOG_DAEMON); 21007c478bd9Sstevel@tonic-gate } 21017c478bd9Sstevel@tonic-gate 21027c478bd9Sstevel@tonic-gate /* Print the date/time without a trailing carridge return */ 21037c478bd9Sstevel@tonic-gate static void 21047c478bd9Sstevel@tonic-gate fprintdate(FILE *file) 21057c478bd9Sstevel@tonic-gate { 21067c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 21077c478bd9Sstevel@tonic-gate struct tm tms; 21087c478bd9Sstevel@tonic-gate time_t now; 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate now = time(NULL); 21117c478bd9Sstevel@tonic-gate (void) localtime_r(&now, &tms); 21127c478bd9Sstevel@tonic-gate (void) strftime(buf, sizeof (buf), "%h %d %X", &tms); 21137c478bd9Sstevel@tonic-gate (void) fprintf(file, "%s ", buf); 21147c478bd9Sstevel@tonic-gate } 21157c478bd9Sstevel@tonic-gate 211669bb4bb4Scarlsonj /* PRINTFLIKE2 */ 21177c478bd9Sstevel@tonic-gate void 2118b0f490f4Smh logmsg(int level, const char *fmt, ...) 21197c478bd9Sstevel@tonic-gate { 21207c478bd9Sstevel@tonic-gate va_list ap; 21217c478bd9Sstevel@tonic-gate va_start(ap, fmt); 21227c478bd9Sstevel@tonic-gate 21237c478bd9Sstevel@tonic-gate if (logging) { 21247c478bd9Sstevel@tonic-gate vsyslog(level, fmt, ap); 21257c478bd9Sstevel@tonic-gate } else { 21267c478bd9Sstevel@tonic-gate fprintdate(stderr); 21277c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, ap); 21287c478bd9Sstevel@tonic-gate } 21297c478bd9Sstevel@tonic-gate va_end(ap); 21307c478bd9Sstevel@tonic-gate } 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate void 2133b0f490f4Smh logperror(const char *str) 21347c478bd9Sstevel@tonic-gate { 21357c478bd9Sstevel@tonic-gate if (logging) { 21367c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "%s: %m\n", str); 21377c478bd9Sstevel@tonic-gate } else { 21387c478bd9Sstevel@tonic-gate fprintdate(stderr); 21397c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s\n", str, strerror(errno)); 21407c478bd9Sstevel@tonic-gate } 21417c478bd9Sstevel@tonic-gate } 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate void 2144b0f490f4Smh logperror_pi(const struct phyint *pi, const char *str) 21457c478bd9Sstevel@tonic-gate { 21467c478bd9Sstevel@tonic-gate if (logging) { 21477c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "%s (interface %s): %m\n", 21487c478bd9Sstevel@tonic-gate str, pi->pi_name); 21497c478bd9Sstevel@tonic-gate } else { 21507c478bd9Sstevel@tonic-gate fprintdate(stderr); 21517c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s (interface %s): %s\n", 21527c478bd9Sstevel@tonic-gate str, pi->pi_name, strerror(errno)); 21537c478bd9Sstevel@tonic-gate } 21547c478bd9Sstevel@tonic-gate } 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate void 2157b0f490f4Smh logperror_pr(const struct prefix *pr, const char *str) 21587c478bd9Sstevel@tonic-gate { 21597c478bd9Sstevel@tonic-gate if (logging) { 21607c478bd9Sstevel@tonic-gate syslog(LOG_ERR, "%s (prefix %s if %s): %m\n", 21617c478bd9Sstevel@tonic-gate str, pr->pr_name, pr->pr_physical->pi_name); 21627c478bd9Sstevel@tonic-gate } else { 21637c478bd9Sstevel@tonic-gate fprintdate(stderr); 21647c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s (prefix %s if %s): %s\n", 21657c478bd9Sstevel@tonic-gate str, pr->pr_name, pr->pr_physical->pi_name, 21667c478bd9Sstevel@tonic-gate strerror(errno)); 21677c478bd9Sstevel@tonic-gate } 21687c478bd9Sstevel@tonic-gate } 2169