void
handle_carrier(int carrier, int flags, const char *ifname)
{
struct interface *ifp;
if (!(options & DHCPCD_LINK))
return;
ifp = find_interface(ifname);
if (ifp == NULL) {
handle_interface(1, ifname);
return;
}
if (!(ifp->options->options & DHCPCD_LINK))
return;
if (carrier == LINK_UNKNOWN)
carrier = carrier_status(ifp); /* will set ifp->flags */
else
ifp->flags = flags;
if (carrier == LINK_UNKNOWN)
syslog(LOG_ERR, "%s: carrier_status: %m", ifname);
/* IFF_RUNNING is checked, if needed, earlier and is OS dependant */
else if (carrier == LINK_DOWN || (ifp->flags & IFF_UP) == 0) {
if (ifp->carrier != LINK_DOWN) {
if (ifp->carrier == LINK_UP)
syslog(LOG_INFO, "%s: carrier lost", ifp->name);
ifp->carrier = LINK_DOWN;
dhcp_close(ifp);
dhcp6_drop(ifp, "EXPIRE6");
ipv6rs_drop(ifp);
/* Don't blindly delete our knowledge of LL addresses.
* We need to listen to what the kernel does with
* them as some OS's will remove, mark tentative or
* do nothing. */
ipv6_free_ll_callbacks(ifp);
dhcp_drop(ifp, "NOCARRIER");
}
} else if (carrier == LINK_UP && ifp->flags & IFF_UP) {
if (ifp->carrier != LINK_UP) {
syslog(LOG_INFO, "%s: carrier acquired", ifp->name);
ifp->carrier = LINK_UP;
#if !defined(__linux__) && !defined(__NetBSD__)
/* BSD does not emit RTM_NEWADDR or RTM_CHGADDR when the
* hardware address changes so we have to go
* through the disovery process to work it out. */
handle_interface(0, ifp->name);
#endif
if (ifp->wireless)
getifssid(ifp->name, ifp->ssid);
configure_interface(ifp, margc, margv);
script_runreason(ifp, "CARRIER");
start_interface(ifp);
}
}
}
static void
configure_interface1(struct interface *ifp)
{
struct if_options *ifo = ifp->options;
int ra_global, ra_iface;
/* Do any platform specific configuration */
if_conf(ifp);
if (ifp->flags & IFF_POINTOPOINT && !(ifo->options & DHCPCD_INFORM))
ifo->options |= DHCPCD_STATIC;
if (ifp->flags & IFF_NOARP ||
ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))
ifo->options &= ~(DHCPCD_ARP | DHCPCD_IPV4LL);
if (!(ifp->flags & (IFF_POINTOPOINT | IFF_LOOPBACK | IFF_MULTICAST)))
ifo->options &= ~DHCPCD_IPV6RS;
if (ifo->options & DHCPCD_LINK && carrier_status(ifp) == LINK_UNKNOWN)
ifo->options &= ~DHCPCD_LINK;
if (ifo->metric != -1)
ifp->metric = ifo->metric;
/* We want to disable kernel interface RA as early as possible. */
if (ifo->options & DHCPCD_IPV6RS) {
ra_global = check_ipv6(NULL, options & DHCPCD_IPV6RA_OWN ? 1:0);
ra_iface = check_ipv6(ifp->name,
ifp->options->options & DHCPCD_IPV6RA_OWN ? 1 : 0);
if (ra_global == -1 || ra_iface == -1)
ifo->options &= ~DHCPCD_IPV6RS;
else if (ra_iface == 0)
ifo->options |= DHCPCD_IPV6RA_OWN;
}
/* If we haven't specified a ClientID and our hardware address
* length is greater than DHCP_CHADDR_LEN then we enforce a ClientID
* of the hardware address family and the hardware address. */
if (ifp->hwlen > DHCP_CHADDR_LEN)
ifo->options |= DHCPCD_CLIENTID;
/* Firewire and InfiniBand interfaces require ClientID and
* the broadcast option being set. */
switch (ifp->family) {
case ARPHRD_IEEE1394: /* FALLTHROUGH */
case ARPHRD_INFINIBAND:
ifo->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST;
break;
}
}
static void
init_state(struct interface *ifp, int argc, char **argv)
{
struct if_options *ifo;
const char *reason = NULL;
configure_interface(ifp, argc, argv);
ifo = ifp->options;
if (ifo->options & DHCPCD_IPV4 && ipv4_init() == -1) {
syslog(LOG_ERR, "ipv4_init: %m");
ifo->options &= ~DHCPCD_IPV4;
}
if (ifo->options & DHCPCD_IPV6 && ipv6_init() == -1) {
syslog(LOG_ERR, "ipv6_init: %m");
ifo->options &= ~DHCPCD_IPV6RS;
}
if (!(options & DHCPCD_TEST))
script_runreason(ifp, "PREINIT");
if (ifo->options & DHCPCD_LINK) {
switch (carrier_status(ifp)) {
case 0:
ifp->carrier = LINK_DOWN;
reason = "NOCARRIER";
break;
case 1:
ifp->carrier = LINK_UP;
reason = "CARRIER";
break;
default:
ifp->carrier = LINK_UNKNOWN;
return;
}
if (reason && !(options & DHCPCD_TEST))
script_runreason(ifp, reason);
} else
ifp->carrier = LINK_UNKNOWN;
}
struct if_head *
discover_interfaces(struct dhcpcd_ctx *ctx, int argc, char * const *argv)
{
struct ifaddrs *ifaddrs, *ifa;
char *p;
int i, sdl_type;
struct if_head *ifs;
struct interface *ifp;
#ifdef __linux__
char ifn[IF_NAMESIZE];
#endif
#ifdef INET
const struct sockaddr_in *addr;
const struct sockaddr_in *net;
const struct sockaddr_in *dst;
#endif
#ifdef INET6
const struct sockaddr_in6 *sin6;
int ifa_flags;
#endif
#ifdef AF_LINK
const struct sockaddr_dl *sdl;
#ifdef SIOCGIFPRIORITY
struct ifreq ifr;
int s_inet;
#endif
#ifdef IFLR_ACTIVE
struct if_laddrreq iflr;
int s_link;
#endif
#ifdef SIOCGIFPRIORITY
if ((s_inet = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
return NULL;
#endif
#ifdef IFLR_ACTIVE
if ((s_link = socket(AF_LINK, SOCK_DGRAM, 0)) == -1) {
#ifdef SIOCGIFPRIORITY
close(s_inet);
#endif
return NULL;
}
memset(&iflr, 0, sizeof(iflr));
#endif
#elif AF_PACKET
const struct sockaddr_ll *sll;
#endif
if (getifaddrs(&ifaddrs) == -1)
return NULL;
ifs = malloc(sizeof(*ifs));
if (ifs == NULL)
return NULL;
TAILQ_INIT(ifs);
for (ifa = ifaddrs; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr != NULL) {
#ifdef AF_LINK
if (ifa->ifa_addr->sa_family != AF_LINK)
continue;
#elif AF_PACKET
if (ifa->ifa_addr->sa_family != AF_PACKET)
continue;
#endif
}
/* Ensure that the interface name has settled */
if (!dev_initialized(ctx, ifa->ifa_name))
continue;
/* It's possible for an interface to have >1 AF_LINK.
* For our purposes, we use the first one. */
TAILQ_FOREACH(ifp, ifs, next) {
if (strcmp(ifp->name, ifa->ifa_name) == 0)
break;
}
if (ifp)
continue;
if (argc > 0) {
for (i = 0; i < argc; i++) {
#ifdef __linux__
/* Check the real interface name */
strlcpy(ifn, argv[i], sizeof(ifn));
p = strchr(ifn, ':');
if (p)
*p = '\0';
if (strcmp(ifn, ifa->ifa_name) == 0)
break;
#else
if (strcmp(argv[i], ifa->ifa_name) == 0)
break;
#endif
}
if (i == argc)
continue;
p = argv[i];
} else {
p = ifa->ifa_name;
/* -1 means we're discovering against a specific
* interface, but we still need the below rules
* to apply. */
if (argc == -1 && strcmp(argv[0], ifa->ifa_name) != 0)
continue;
}
for (i = 0; i < ctx->ifdc; i++)
if (!fnmatch(ctx->ifdv[i], p, 0))
break;
if (i < ctx->ifdc)
continue;
for (i = 0; i < ctx->ifac; i++)
if (!fnmatch(ctx->ifav[i], p, 0))
break;
if (ctx->ifac && i == ctx->ifac)
continue;
if (if_vimaster(ifa->ifa_name) == 1) {
syslog(argc ? LOG_ERR : LOG_DEBUG,
"%s: is a Virtual Interface Master, skipping",
ifa->ifa_name);
continue;
}
ifp = calloc(1, sizeof(*ifp));
if (ifp == NULL) {
syslog(LOG_ERR, "%s: %m", __func__);
break;
}
ifp->ctx = ctx;
strlcpy(ifp->name, p, sizeof(ifp->name));
ifp->flags = ifa->ifa_flags;
/* Bring the interface up if not already */
if (!(ifp->flags & IFF_UP)
#ifdef SIOCGIFMEDIA
&& carrier_status(ifp) != LINK_UNKNOWN
#endif
)
{
if (up_interface(ifp) == 0)
ctx->options |= DHCPCD_WAITUP;
else
syslog(LOG_ERR, "%s: up_interface: %m",
ifp->name);
}
sdl_type = 0;
/* Don't allow loopback unless explicit */
if (ifp->flags & IFF_LOOPBACK) {
if (argc == 0 && ctx->ifac == 0) {
free_interface(ifp);
continue;
}
} else if (ifa->ifa_addr != NULL) {
#ifdef AF_LINK
sdl = (const struct sockaddr_dl *)(void *)ifa->ifa_addr;
#ifdef IFLR_ACTIVE
/* We need to check for active address */
strlcpy(iflr.iflr_name, ifp->name,
sizeof(iflr.iflr_name));
memcpy(&iflr.addr, ifa->ifa_addr,
MIN(ifa->ifa_addr->sa_len, sizeof(iflr.addr)));
iflr.flags = IFLR_PREFIX;
iflr.prefixlen = sdl->sdl_alen * NBBY;
if (ioctl(s_link, SIOCGLIFADDR, &iflr) == -1 ||
!(iflr.flags & IFLR_ACTIVE))
{
free_interface(ifp);
continue;
}
#endif
ifp->index = sdl->sdl_index;
sdl_type = sdl->sdl_type;
switch(sdl->sdl_type) {
case IFT_BRIDGE: /* FALLTHROUGH */
case IFT_L2VLAN: /* FALLTHOUGH */
case IFT_L3IPVLAN: /* FALLTHROUGH */
case IFT_ETHER:
ifp->family = ARPHRD_ETHER;
break;
case IFT_IEEE1394:
ifp->family = ARPHRD_IEEE1394;
break;
#ifdef IFT_INFINIBAND
case IFT_INFINIBAND:
ifp->family = ARPHRD_INFINIBAND;
break;
#endif
}
ifp->hwlen = sdl->sdl_alen;
#ifndef CLLADDR
# define CLLADDR(s) ((const char *)((s)->sdl_data + (s)->sdl_nlen))
#endif
memcpy(ifp->hwaddr, CLLADDR(sdl), ifp->hwlen);
#elif AF_PACKET
sll = (const struct sockaddr_ll *)(void *)ifa->ifa_addr;
ifp->index = sll->sll_ifindex;
ifp->family = sdl_type = sll->sll_hatype;
ifp->hwlen = sll->sll_halen;
if (ifp->hwlen != 0)
memcpy(ifp->hwaddr, sll->sll_addr, ifp->hwlen);
#endif
}
#ifdef __linux__
/* PPP addresses on Linux don't have hardware addresses */
else
ifp->index = if_nametoindex(ifp->name);
#endif
/* We only work on ethernet by default */
if (!(ifp->flags & IFF_POINTOPOINT) &&
ifp->family != ARPHRD_ETHER)
{
if (argc == 0 && ctx->ifac == 0) {
free_interface(ifp);
continue;
}
switch (ifp->family) {
case ARPHRD_IEEE1394: /* FALLTHROUGH */
case ARPHRD_INFINIBAND:
/* We don't warn for supported families */
break;
default:
syslog(LOG_WARNING,
"%s: unsupported interface type %.2x"
", falling back to ethernet",
ifp->name, sdl_type);
ifp->family = ARPHRD_ETHER;
break;
}
}
/* Handle any platform init for the interface */
if (if_init(ifp) == -1) {
syslog(LOG_ERR, "%s: if_init: %m", p);
free_interface(ifp);
continue;
}
/* Ensure that the MTU is big enough for DHCP */
if (get_mtu(ifp->name) < MTU_MIN &&
set_mtu(ifp->name, MTU_MIN) == -1)
{
syslog(LOG_ERR, "%s: set_mtu: %m", p);
free_interface(ifp);
continue;
}
#ifdef SIOCGIFPRIORITY
/* Respect the interface priority */
memset(&ifr, 0, sizeof(ifr));
strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
if (ioctl(s_inet, SIOCGIFPRIORITY, &ifr) == 0)
ifp->metric = ifr.ifr_metric;
#else
/* We reserve the 100 range for virtual interfaces, if and when
* we can work them out. */
ifp->metric = 200 + ifp->index;
if (getifssid(ifp->name, ifp->ssid) != -1) {
ifp->wireless = 1;
ifp->metric += 100;
}
#endif
TAILQ_INSERT_TAIL(ifs, ifp, next);
}
for (ifa = ifaddrs; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr == NULL)
continue;
switch(ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
addr = (const struct sockaddr_in *)
(void *)ifa->ifa_addr;
net = (const struct sockaddr_in *)
(void *)ifa->ifa_netmask;
if (ifa->ifa_flags & IFF_POINTOPOINT)
dst = (const struct sockaddr_in *)
(void *)ifa->ifa_dstaddr;
else
dst = NULL;
ipv4_handleifa(ctx, RTM_NEWADDR, ifs, ifa->ifa_name,
&addr->sin_addr,
&net->sin_addr,
dst ? &dst->sin_addr : NULL);
break;
#endif
#ifdef INET6
case AF_INET6:
sin6 = (const struct sockaddr_in6 *)
(void *)ifa->ifa_addr;
ifa_flags = in6_addr_flags(ifa->ifa_name,
&sin6->sin6_addr);
if (ifa_flags != -1)
ipv6_handleifa(ctx, RTM_NEWADDR, ifs,
ifa->ifa_name,
&sin6->sin6_addr, ifa_flags);
break;
#endif
}
}
freeifaddrs(ifaddrs);
#ifdef SIOCGIFPRIORITY
close(s_inet);
#endif
#ifdef IFLR_ACTIVE
close(s_link);
#endif
return ifs;
}
static void
configure_interface1(struct interface *ifp)
{
struct if_options *ifo = ifp->options;
int ra_global, ra_iface;
/* Do any platform specific configuration */
if_conf(ifp);
if (ifp->flags & IFF_POINTOPOINT && !(ifo->options & DHCPCD_INFORM))
ifo->options |= DHCPCD_STATIC;
if (ifp->flags & IFF_NOARP ||
ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))
ifo->options &= ~(DHCPCD_ARP | DHCPCD_IPV4LL);
if (!(ifp->flags & (IFF_POINTOPOINT | IFF_LOOPBACK | IFF_MULTICAST)))
ifo->options &= ~DHCPCD_IPV6RS;
if (ifo->options & DHCPCD_LINK && carrier_status(ifp) == LINK_UNKNOWN)
ifo->options &= ~DHCPCD_LINK;
if (ifo->metric != -1)
ifp->metric = ifo->metric;
if (!(ifo->options & DHCPCD_IPV6))
ifo->options &= ~DHCPCD_IPV6RS;
/* We want to disable kernel interface RA as early as possible. */
if (ifo->options & DHCPCD_IPV6RS) {
ra_global = check_ipv6(NULL, options & DHCPCD_IPV6RA_OWN ? 1:0);
ra_iface = check_ipv6(ifp->name,
ifp->options->options & DHCPCD_IPV6RA_OWN ? 1 : 0);
if (ra_global == -1 || ra_iface == -1)
ifo->options &= ~DHCPCD_IPV6RS;
else if (ra_iface == 0)
ifo->options |= DHCPCD_IPV6RA_OWN;
}
/* If we haven't specified a ClientID and our hardware address
* length is greater than DHCP_CHADDR_LEN then we enforce a ClientID
* of the hardware address family and the hardware address. */
if (ifp->hwlen > DHCP_CHADDR_LEN)
ifo->options |= DHCPCD_CLIENTID;
/* Firewire and InfiniBand interfaces require ClientID and
* the broadcast option being set. */
switch (ifp->family) {
case ARPHRD_IEEE1394: /* FALLTHROUGH */
case ARPHRD_INFINIBAND:
ifo->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST;
break;
}
if (!(ifo->options & DHCPCD_IAID)) {
/*
* An IAID is for identifying a unqiue interface within
* the client. It is 4 bytes long. Working out a default
* value is problematic.
*
* Interface name and number are not stable
* between different OS's. Some OS's also cannot make
* up their mind what the interface should be called
* (yes, udev, I'm looking at you).
* Also, the name could be longer than 4 bytes.
* Also, with pluggable interfaces the name and index
* could easily get swapped per actual interface.
*
* The MAC address is 6 bytes long, the final 3
* being unique to the manufacturer and the initial 3
* being unique to the organisation which makes it.
* We could use the last 4 bytes of the MAC address
* as the IAID as it's the most stable part given the
* above, but equally it's not guaranteed to be
* unique.
*
* Given the above, and our need to reliably work
* between reboots without persitent storage,
* generating the IAID from the MAC address is the only
* logical default.
*
* dhclient uses the last 4 bytes of the MAC address.
* dibbler uses an increamenting counter.
* wide-dhcpv6 uses 0 or a configured value.
* odhcp6c uses 1.
* Windows 7 uses the first 3 bytes of the MAC address
* and an unknown byte.
* dhcpcd-6.1.0 and earlier used the interface name,
* falling back to interface index if name > 4.
*/
memcpy(ifo->iaid, ifp->hwaddr + ifp->hwlen - sizeof(ifo->iaid),
sizeof(ifo->iaid));
#if 0
len = strlen(ifp->name);
if (len <= sizeof(ifo->iaid)) {
memcpy(ifo->iaid, ifp->name, len);
memset(ifo->iaid + len, 0, sizeof(ifo->iaid) - len);
} else {
/* IAID is the same size as a uint32_t */
len = htonl(ifp->index);
memcpy(ifo->iaid, &len, sizeof(len));
}
#endif
ifo->options |= DHCPCD_IAID;
}
#ifdef INET6
if (ifo->ia == NULL && ifo->options & DHCPCD_IPV6) {
ifo->ia = malloc(sizeof(*ifo->ia));
if (ifo->ia == NULL)
syslog(LOG_ERR, "%s: %m", __func__);
else {
if (ifo->ia_type == 0)
ifo->ia_type = D6_OPTION_IA_NA;
memcpy(ifo->ia->iaid, ifo->iaid, sizeof(ifo->iaid));
ifo->ia_len = 1;
ifo->ia->sla = NULL;
ifo->ia->sla_len = 0;
}
}
#endif
}
