void
start_interface(void *arg)
{
struct interface *ifp = arg;
struct if_options *ifo = ifp->options;
int nolease;
handle_carrier(LINK_UNKNOWN, 0, ifp->name);
if (ifp->carrier == LINK_DOWN) {
syslog(LOG_INFO, "%s: waiting for carrier", ifp->name);
return;
}
if (ifo->options & DHCPCD_IPV6) {
if (ifo->options & DHCPCD_IPV6RS &&
!(ifo->options & DHCPCD_INFORM))
ipv6rs_start(ifp);
if (!(ifo->options & DHCPCD_IPV6RS)) {
if (ifo->options & DHCPCD_IA_FORCED)
nolease = dhcp6_start(ifp, DH6S_INIT);
else {
nolease = dhcp6_find_delegates(ifp);
/* Enabling the below doesn't really make
* sense as there is currently no standard
* to push routes via DHCPv6.
* (There is an expired working draft,
* maybe abandoned?)
* You can also get it to work by forcing
* an IA as shown above. */
#if 0
/* With no RS or delegates we might
* as well try and solicit a DHCPv6 address */
if (nolease == 0)
nolease = dhcp6_start(ifp, DH6S_INIT);
#endif
}
if (nolease == -1)
syslog(LOG_ERR,
"%s: dhcp6_start: %m", ifp->name);
}
}
if (ifo->options & DHCPCD_IPV4)
dhcp_start(ifp);
}
int
manage_link(int fd)
{
char *p, *e, *cp;
char ifname[IF_NAMESIZE];
ssize_t bytes;
struct rt_msghdr *rtm;
struct if_announcemsghdr *ifan;
struct if_msghdr *ifm;
struct ifa_msghdr *ifam;
struct sockaddr *sa, *rti_info[RTAX_MAX];
int len;
struct sockaddr_dl sdl;
#ifdef INET
struct rt rt;
#endif
#if defined(INET6) && !defined(LISTEN_DAD)
struct in6_addr ia6;
struct sockaddr_in6 *sin6;
int ifa_flags;
#endif
for (;;) {
if (ioctl(fd, FIONREAD, &len) == -1)
return -1;
if (link_buflen < len) {
p = realloc(link_buf, len);
if (p == NULL)
return -1;
link_buf = p;
link_buflen = len;
}
bytes = read(fd, link_buf, link_buflen);
if (bytes == -1) {
if (errno == EAGAIN)
return 0;
if (errno == EINTR)
continue;
return -1;
}
e = link_buf + bytes;
for (p = link_buf; p < e; p += rtm->rtm_msglen) {
rtm = (struct rt_msghdr *)(void *)p;
// Ignore messages generated by us
if (rtm->rtm_pid == getpid())
break;
switch(rtm->rtm_type) {
#ifdef RTM_IFANNOUNCE
case RTM_IFANNOUNCE:
ifan = (struct if_announcemsghdr *)(void *)p;
switch(ifan->ifan_what) {
case IFAN_ARRIVAL:
handle_interface(1, ifan->ifan_name);
break;
case IFAN_DEPARTURE:
handle_interface(-1, ifan->ifan_name);
break;
}
break;
#endif
case RTM_IFINFO:
ifm = (struct if_msghdr *)(void *)p;
memset(ifname, 0, sizeof(ifname));
if (!(if_indextoname(ifm->ifm_index, ifname)))
break;
switch (ifm->ifm_data.ifi_link_state) {
case LINK_STATE_DOWN:
len = LINK_DOWN;
break;
case LINK_STATE_UP:
len = LINK_UP;
break;
default:
/* handle_carrier will re-load
* the interface flags and check for
* IFF_RUNNING as some drivers that
* don't handle link state also don't
* set IFF_RUNNING when this routing
* message is generated.
* As such, it is a race ...*/
len = LINK_UNKNOWN;
break;
}
handle_carrier(len, ifm->ifm_flags, ifname);
break;
case RTM_DELETE:
if (~rtm->rtm_addrs &
(RTA_DST | RTA_GATEWAY | RTA_NETMASK))
break;
cp = (char *)(void *)(rtm + 1);
sa = (struct sockaddr *)(void *)cp;
if (sa->sa_family != AF_INET)
break;
#ifdef INET
get_addrs(rtm->rtm_addrs, cp, rti_info);
memset(&rt, 0, sizeof(rt));
rt.iface = NULL;
COPYOUT(rt.dest, rti_info[RTAX_DST]);
COPYOUT(rt.net, rti_info[RTAX_NETMASK]);
COPYOUT(rt.gate, rti_info[RTAX_GATEWAY]);
ipv4_routedeleted(&rt);
#endif
break;
#ifdef RTM_CHGADDR
case RTM_CHGADDR: /* FALLTHROUGH */
#endif
case RTM_DELADDR: /* FALLTHROUGH */
case RTM_NEWADDR:
ifam = (struct ifa_msghdr *)(void *)p;
if (!if_indextoname(ifam->ifam_index, ifname))
break;
cp = (char *)(void *)(ifam + 1);
get_addrs(ifam->ifam_addrs, cp, rti_info);
if (rti_info[RTAX_IFA] == NULL)
break;
switch (rti_info[RTAX_IFA]->sa_family) {
case AF_LINK:
#ifdef RTM_CHGADDR
if (rtm->rtm_type != RTM_CHGADDR)
break;
#else
if (rtm->rtm_type != RTM_NEWADDR)
break;
#endif
memcpy(&sdl, rti_info[RTAX_IFA],
rti_info[RTAX_IFA]->sa_len);
handle_hwaddr(ifname,
(const unsigned char*)CLLADDR(&sdl),
sdl.sdl_alen);
break;
#ifdef INET
case AF_INET:
case 255: /* FIXME: Why 255? */
COPYOUT(rt.dest, rti_info[RTAX_IFA]);
COPYOUT(rt.net, rti_info[RTAX_NETMASK]);
COPYOUT(rt.gate, rti_info[RTAX_BRD]);
ipv4_handleifa(rtm->rtm_type,
NULL, ifname,
&rt.dest, &rt.net, &rt.gate);
break;
#endif
#if defined(INET6) && !defined(LISTEN_DAD)
case AF_INET6:
sin6 = (struct sockaddr_in6*)(void *)
rti_info[RTAX_IFA];
memcpy(ia6.s6_addr,
sin6->sin6_addr.s6_addr,
sizeof(ia6.s6_addr));
if (rtm->rtm_type == RTM_NEWADDR) {
ifa_flags = in6_addr_flags(
ifname,
&ia6);
if (ifa_flags == -1)
break;
} else
ifa_flags = 0;
ipv6_handleifa(rtm->rtm_type, NULL,
ifname, &ia6, ifa_flags);
break;
#endif
}
break;
}
}
}
}
static int
link_netlink(struct nlmsghdr *nlm)
{
int len;
struct rtattr *rta, *hwaddr;
struct ifinfomsg *ifi;
char ifn[IF_NAMESIZE + 1];
struct interface *ifp;
len = link_route(nlm);
if (len != 0)
return len;
len = link_addr(nlm);
if (len != 0)
return len;
if (nlm->nlmsg_type != RTM_NEWLINK && nlm->nlmsg_type != RTM_DELLINK)
return 0;
len = nlm->nlmsg_len - sizeof(*nlm);
if ((size_t)len < sizeof(*ifi)) {
errno = EBADMSG;
return -1;
}
ifi = NLMSG_DATA(nlm);
if (ifi->ifi_flags & IFF_LOOPBACK)
return 1;
rta = (struct rtattr *)(void *)((char *)ifi +NLMSG_ALIGN(sizeof(*ifi)));
len = NLMSG_PAYLOAD(nlm, sizeof(*ifi));
*ifn = '\0';
hwaddr = NULL;
while (RTA_OK(rta, len)) {
switch (rta->rta_type) {
case IFLA_WIRELESS:
/* Ignore wireless messages */
if (nlm->nlmsg_type == RTM_NEWLINK &&
ifi->ifi_change == 0)
return 1;
break;
case IFLA_IFNAME:
strlcpy(ifn, RTA_DATA(rta), sizeof(ifn));
break;
case IFLA_ADDRESS:
hwaddr = rta;
break;
}
rta = RTA_NEXT(rta, len);
}
if (nlm->nlmsg_type == RTM_DELLINK) {
handle_interface(-1, ifn);
return 1;
}
/* Virtual interfaces may not get a valid hardware address
* at this point.
* To trigger a valid hardware address pickup we need to pretend
* that that don't exist until they have one. */
if (ifi->ifi_flags & IFF_MASTER && !hwaddr) {
handle_interface(-1, ifn);
return 1;
}
/* Check for interface name change */
if (handle_rename(ifi->ifi_index, ifn))
return 1;
/* Check for a new interface */
ifp = find_interface(ifn);
if (ifp == NULL) {
/* If are listening to a dev manager, let that announce
* the interface rather than the kernel. */
if (dev_listening() < 1)
handle_interface(1, ifn);
return 1;
}
/* Re-read hardware address and friends */
if (!(ifi->ifi_flags & IFF_UP) && hwaddr) {
len = l2addr_len(ifi->ifi_type);
if (hwaddr->rta_len == RTA_LENGTH(len))
handle_hwaddr(ifn, RTA_DATA(hwaddr), len);
}
handle_carrier(ifi->ifi_flags & IFF_RUNNING ? LINK_UP : LINK_DOWN,
ifi->ifi_flags, ifn);
return 1;
}
void
start_interface(void *arg)
{
struct interface *ifp = arg;
struct if_options *ifo = ifp->options;
int nolease;
size_t i;
handle_carrier(LINK_UNKNOWN, 0, ifp->name);
if (ifp->carrier == LINK_DOWN) {
syslog(LOG_INFO, "%s: waiting for carrier", ifp->name);
return;
}
if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) {
/* Report client DUID */
if (duid == NULL) {
if (duid_init(ifp) == 0)
return;
syslog(LOG_INFO, "DUID %s",
hwaddr_ntoa(duid, duid_len));
}
/* Report IAIDs */
syslog(LOG_INFO, "%s: IAID %s", ifp->name,
hwaddr_ntoa(ifo->iaid, sizeof(ifo->iaid)));
warn_iaid_conflict(ifp, ifo->iaid);
for (i = 0; i < ifo->ia_len; i++) {
if (memcmp(ifo->iaid, ifo->ia[i].iaid,
sizeof(ifo->iaid)))
{
syslog(LOG_INFO, "%s: IAID %s", ifp->name,
hwaddr_ntoa(ifo->ia[i].iaid,
sizeof(ifo->ia[i].iaid)));
warn_iaid_conflict(ifp, ifo->ia[i].iaid);
}
}
}
if (ifo->options & DHCPCD_IPV6) {
if (ifo->options & DHCPCD_IPV6RS &&
!(ifo->options & DHCPCD_INFORM))
ipv6nd_startrs(ifp);
if (!(ifo->options & DHCPCD_IPV6RS)) {
if (ifo->options & DHCPCD_IA_FORCED)
nolease = dhcp6_start(ifp, DH6S_INIT);
else {
nolease = dhcp6_find_delegates(ifp);
/* Enabling the below doesn't really make
* sense as there is currently no standard
* to push routes via DHCPv6.
* (There is an expired working draft,
* maybe abandoned?)
* You can also get it to work by forcing
* an IA as shown above. */
#if 0
/* With no RS or delegates we might
* as well try and solicit a DHCPv6 address */
if (nolease == 0)
nolease = dhcp6_start(ifp, DH6S_INIT);
#endif
}
if (nolease == -1)
syslog(LOG_ERR,
"%s: dhcp6_start: %m", ifp->name);
}
}
if (ifo->options & DHCPCD_IPV4)
dhcp_start(ifp);
}