/*
* dhcpcd - DHCP client daemon
* Copyright 2006-2008 Roy Marples <roy@marples.name>
* All rights reserved
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <arpa/inet.h>
/* Netlink suff */
#ifdef __linux__
#include <asm/types.h> /* Needed for 2.4 kernels */
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <netinet/ether.h>
#include <netpacket/packet.h>
#else
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/route.h>
#include <netinet/in.h>
#endif
#include <ctype.h>
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "config.h"
#include "common.h"
#include "dhcp.h"
#include "interface.h"
#include "logger.h"
void free_address (struct address_head *addresses)
{
address_t *p;
address_t *n;
if (! addresses)
return;
p = STAILQ_FIRST (addresses);
while (p)
{
n = STAILQ_NEXT (p, entries);
free (p);
p = n;
}
free (addresses);
}
void free_route (struct route_head *routes)
{
route_t *p;
route_t *n;
if (! routes)
return;
p = STAILQ_FIRST (routes);
while (p)
{
n = STAILQ_NEXT (p, entries);
free (p);
p = n;
}
free (routes);
}
int inet_ntocidr (struct in_addr address)
{
int cidr = 0;
uint32_t mask = htonl (address.s_addr);
while (mask)
{
cidr++;
mask <<= 1;
}
return (cidr);
}
int inet_cidrtoaddr (int cidr, struct in_addr *addr)
{
int ocets;
if (cidr < 0 || cidr > 32)
{
errno = EINVAL;
return (-1);
}
ocets = (cidr + 7) / 8;
memset (addr, 0, sizeof (*addr));
if (ocets > 0)
{
memset (&addr->s_addr, 255, (size_t) ocets - 1);
memset ((unsigned char *) &addr->s_addr + (ocets - 1),
(256 - (1 << (32 - cidr) % 8)), 1);
}
return (0);
}
uint32_t get_netmask (uint32_t addr)
{
uint32_t dst;
if (addr == 0)
return (0);
dst = htonl (addr);
if (IN_CLASSA (dst))
return (ntohl (IN_CLASSA_NET));
if (IN_CLASSB (dst))
return (ntohl (IN_CLASSB_NET));
if (IN_CLASSC (dst))
return (ntohl (IN_CLASSC_NET));
return (0);
}
char *hwaddr_ntoa (const unsigned char *hwaddr, size_t hwlen)
{
static char buffer[(HWADDR_LEN * 3) + 1];
char *p = buffer;
size_t i;
for (i = 0; i < hwlen && i < HWADDR_LEN; i++)
{
if (i > 0)
*p ++ = ':';
p += snprintf (p, 3, "%.2x", hwaddr[i]);
}
*p ++ = '\0';
return (buffer);
}
size_t hwaddr_aton (unsigned char *buffer, const char *addr)
{
char c[3];
const char *p = addr;
unsigned char *bp = buffer;
size_t len = 0;
c[2] = '\0';
while (*p)
{
c[0] = *p++;
c[1] = *p++;
/* Ensure that next data is EOL or a seperator with data */
if (! (*p == '\0' || (*p == ':' && *(p + 1) != '\0')))
{
errno = EINVAL;
return (0);
}
/* Ensure that digits are hex */
if (isxdigit ((int) c[0]) == 0 || isxdigit ((int) c[1]) == 0)
{
errno = EINVAL;
return (0);
}
p++;
if (bp)
*bp++ = (unsigned char) strtol (c, NULL, 16);
else
len++;
}
if (bp)
return (bp - buffer);
return (len);
}
static int _do_interface (const char *ifname,
_unused unsigned char *hwaddr, _unused size_t *hwlen,
struct in_addr *addr,
bool flush, bool get)
{
int s;
struct ifconf ifc;
int retval = 0;
int len = 10 * sizeof (struct ifreq);
int lastlen = 0;
char *p;
if ((s = socket (AF_INET, SOCK_DGRAM, 0)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return -1;
}
/* Not all implementations return the needed buffer size for
* SIOGIFCONF so we loop like so for all until it works */
memset (&ifc, 0, sizeof (ifc));
for (;;)
{
ifc.ifc_len = len;
ifc.ifc_buf = xmalloc ((size_t) len);
if (ioctl (s, SIOCGIFCONF, &ifc) == -1)
{
if (errno != EINVAL || lastlen != 0)
{
logger (LOG_ERR, "ioctl SIOCGIFCONF: %s",
strerror (errno));
close (s);
free (ifc.ifc_buf);
return -1;
}
}
else
{
if (ifc.ifc_len == lastlen)
break;
lastlen = ifc.ifc_len;
}
free (ifc.ifc_buf);
ifc.ifc_buf = NULL;
len *= 2;
}
for (p = ifc.ifc_buf; p < ifc.ifc_buf + ifc.ifc_len;)
{
union
{
char *buffer;
struct ifreq *ifr;
} ifreqs;
struct sockaddr_in address;
struct ifreq *ifr;
/* Cast the ifc buffer to an ifreq cleanly */
ifreqs.buffer = p;
ifr = ifreqs.ifr;
#ifdef __linux__
p += sizeof (*ifr);
#else
p += offsetof (struct ifreq, ifr_ifru) + ifr->ifr_addr.sa_len;
#endif
if (strcmp (ifname, ifr->ifr_name) != 0)
continue;
#ifdef AF_LINK
if (hwaddr && hwlen && ifr->ifr_addr.sa_family == AF_LINK)
{
struct sockaddr_dl sdl;
memcpy (&sdl, &ifr->ifr_addr, sizeof (sdl));
*hwlen = sdl.sdl_alen;
memcpy (hwaddr, sdl.sdl_data + sdl.sdl_nlen,
(size_t) sdl.sdl_alen);
retval = 1;
break;
}
#endif
if (ifr->ifr_addr.sa_family == AF_INET)
{
memcpy (&address, &ifr->ifr_addr, sizeof (address));
if (flush)
{
struct sockaddr_in netmask;
if (ioctl (s, SIOCGIFNETMASK, ifr) == -1)
{
logger (LOG_ERR,
"ioctl SIOCGIFNETMASK: %s",
strerror (errno));
continue;
}
memcpy (&netmask, &ifr->ifr_addr,
sizeof (netmask));
if (del_address (ifname,
address.sin_addr,
netmask.sin_addr) == -1)
retval = -1;
}
else if (get)
{
addr->s_addr = address.sin_addr.s_addr;
retval = 1;
break;
}
else if (address.sin_addr.s_addr == addr->s_addr)
{
retval = 1;
break;
}
}
}
close (s);
free (ifc.ifc_buf);
return retval;
}
interface_t *read_interface (const char *ifname, _unused int metric)
{
int s;
struct ifreq ifr;
interface_t *iface = NULL;
unsigned char *hwaddr = NULL;
size_t hwlen = 0;
sa_family_t family = 0;
unsigned short mtu;
#ifdef __linux__
char *p;
#endif
if (! ifname)
return NULL;
memset (&ifr, 0, sizeof (ifr));
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if ((s = socket (AF_INET, SOCK_DGRAM, 0)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return NULL;
}
#ifdef __linux__
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if (ioctl (s, SIOCGIFHWADDR, &ifr) == -1)
{
logger (LOG_ERR, "ioctl SIOCGIFHWADDR: %s", strerror (errno));
goto exit;
}
switch (ifr.ifr_hwaddr.sa_family)
{
case ARPHRD_ETHER:
case ARPHRD_IEEE802:
hwlen = ETHER_ADDR_LEN;
break;
case ARPHRD_IEEE1394:
hwlen = EUI64_ADDR_LEN;
case ARPHRD_INFINIBAND:
hwlen = INFINIBAND_ADDR_LEN;
break;
default:
logger (LOG_ERR,
"interface is not Ethernet, FireWire, " \
"InfiniBand or Token Ring");
goto exit;
}
hwaddr = xmalloc (sizeof (unsigned char) * HWADDR_LEN);
memcpy (hwaddr, ifr.ifr_hwaddr.sa_data, hwlen);
family = ifr.ifr_hwaddr.sa_family;
#else
ifr.ifr_metric = metric;
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if (ioctl (s, SIOCSIFMETRIC, &ifr) == -1)
{
logger (LOG_ERR, "ioctl SIOCSIFMETRIC: %s", strerror (errno));
goto exit;
}
hwaddr = xmalloc (sizeof (unsigned char) * HWADDR_LEN);
if (_do_interface (ifname, hwaddr, &hwlen, NULL, false, false) != 1)
{
logger (LOG_ERR, "could not find interface %s", ifname);
goto exit;
}
family = ARPHRD_ETHER;
#endif
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if (ioctl (s, SIOCGIFMTU, &ifr) == -1)
{
logger (LOG_ERR, "ioctl SIOCGIFMTU: %s", strerror (errno));
goto exit;
}
if (ifr.ifr_mtu < MTU_MIN)
{
logger (LOG_DEBUG, "MTU of %d is too low, setting to %d",
ifr.ifr_mtu, MTU_MIN);
ifr.ifr_mtu = MTU_MIN;
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
if (ioctl (s, SIOCSIFMTU, &ifr) == -1)
{
logger (LOG_ERR, "ioctl SIOCSIFMTU,: %s",
strerror (errno));
goto exit;
}
}
mtu = ifr.ifr_mtu;
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
#ifdef __linux__
/* We can only bring the real interface up */
if ((p = strchr (ifr.ifr_name, ':')))
* p = '\0';
#endif
if (ioctl (s, SIOCGIFFLAGS, &ifr) == -1)
{
logger (LOG_ERR, "ioctl SIOCGIFFLAGS: %s", strerror (errno));
goto exit;
}
if (! (ifr.ifr_flags & IFF_UP) || ! (ifr.ifr_flags & IFF_RUNNING))
{
ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
if (ioctl (s, SIOCSIFFLAGS, &ifr) != 0)
{
logger (LOG_ERR, "ioctl SIOCSIFFLAGS: %s",
strerror (errno));
goto exit;
}
}
iface = xzalloc (sizeof (*iface));
strlcpy (iface->name, ifname, IF_NAMESIZE);
#ifdef ENABLE_INFO
snprintf (iface->infofile, PATH_MAX, INFOFILE, ifname);
#endif
memcpy (&iface->hwaddr, hwaddr, hwlen);
iface->hwlen = hwlen;
iface->family = family;
iface->arpable = ! (ifr.ifr_flags & (IFF_NOARP | IFF_LOOPBACK));
iface->mtu = iface->previous_mtu = mtu;
logger (LOG_INFO, "hardware address = %s",
hwaddr_ntoa (iface->hwaddr, iface->hwlen));
/* 0 is a valid fd, so init to -1 */
iface->fd = -1;
#ifdef __linux__
iface->listen_fd = -1;
#endif
exit:
close (s);
free (hwaddr);
return iface;
}
int get_mtu (const char *ifname)
{
struct ifreq ifr;
int r;
int s;
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return (-1);
}
memset (&ifr, 0, sizeof (ifr));
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
r = ioctl (s, SIOCGIFMTU, &ifr);
close (s);
if (r == -1)
{
logger (LOG_ERR, "ioctl SIOCGIFMTU: %s", strerror (errno));
return (-1);
}
return (ifr.ifr_mtu);
}
int set_mtu (const char *ifname, short int mtu)
{
struct ifreq ifr;
int r;
int s;
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return (-1);
}
memset (&ifr, 0, sizeof (ifr));
logger (LOG_DEBUG, "setting MTU to %d", mtu);
strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
ifr.ifr_mtu = mtu;
r = ioctl (s, SIOCSIFMTU, &ifr);
close (s);
if (r == -1)
logger (LOG_ERR, "ioctl SIOCSIFMTU: %s", strerror (errno));
return (r == 0 ? 0 : -1);
}
static void log_route (struct in_addr destination,
struct in_addr netmask,
struct in_addr gateway,
_unused int metric,
int change, int del)
{
char *dstd = xstrdup (inet_ntoa (destination));
#ifdef __linux__
#define METRIC " metric %d"
#else
#define METRIC ""
#endif
if (gateway.s_addr == destination.s_addr ||
gateway.s_addr == INADDR_ANY)
logger (LOG_INFO, "%s route to %s/%d" METRIC,
change ? "changing" : del ? "removing" : "adding",
dstd, inet_ntocidr (netmask)
#ifdef __linux__
, metric
#endif
);
else if (destination.s_addr == INADDR_ANY)
logger (LOG_INFO, "%s default route via %s" METRIC,
change ? "changing" : del ? "removing" : "adding",
inet_ntoa (gateway)
#ifdef __linux__
, metric
#endif
);
else
logger (LOG_INFO, "%s route to %s/%d via %s" METRIC,
change ? "changing" : del ? "removing" : "adding",
dstd, inet_ntocidr (netmask), inet_ntoa (gateway)
#ifdef __linux__
, metric
#endif
);
free (dstd);
}
#if defined(BSD) || defined(__FreeBSD_kernel__)
/* Darwin doesn't define this for some very odd reason */
#ifndef SA_SIZE
# define SA_SIZE(sa) \
( (!(sa) || ((struct sockaddr *)(sa))->sa_len == 0) ? \
sizeof(long) : \
1 + ( (((struct sockaddr *)(sa))->sa_len - 1) | (sizeof(long) - 1) ) )
#endif
static int do_address (const char *ifname, struct in_addr address,
struct in_addr netmask, struct in_addr broadcast,
int del)
{
int s;
struct ifaliasreq ifa;
if (! ifname)
return -1;
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return -1;
}
memset (&ifa, 0, sizeof (ifa));
strlcpy (ifa.ifra_name, ifname, sizeof (ifa.ifra_name));
#define ADDADDR(_var, _addr) { \
union { struct sockaddr *sa; struct sockaddr_in *sin; } _s; \
_s.sa = &_var; \
_s.sin->sin_family = AF_INET; \
_s.sin->sin_len = sizeof (*_s.sin); \
memcpy (&_s.sin->sin_addr, &_addr, sizeof (_s.sin->sin_addr)); \
}
ADDADDR (ifa.ifra_addr, address);
ADDADDR (ifa.ifra_mask, netmask);
if (! del)
ADDADDR (ifa.ifra_broadaddr, broadcast);
#undef ADDADDR
if (ioctl (s, del ? SIOCDIFADDR : SIOCAIFADDR, &ifa) == -1)
{
logger (LOG_ERR, "ioctl %s: %s",
del ? "SIOCDIFADDR" : "SIOCAIFADDR",
strerror (errno));
close (s);
return -1;
}
close (s);
return 0;
}
static int do_route (const char *ifname,
struct in_addr destination,
struct in_addr netmask,
struct in_addr gateway,
int metric,
int change, int del)
{
int s;
static int seq;
union sockunion
{
struct sockaddr sa;
struct sockaddr_in sin;
#ifdef INET6
struct sockaddr_in6 sin6;
#endif
struct sockaddr_dl sdl;
struct sockaddr_storage ss;
} su;
struct rtm
{
struct rt_msghdr hdr;
char buffer[sizeof (su) * 3];
} rtm;
char *bp = rtm.buffer;
size_t l;
if (! ifname)
return -1;
log_route (destination, netmask, gateway, metric, change, del);
if ((s = socket (PF_ROUTE, SOCK_RAW, 0)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return -1;
}
memset (&rtm, 0, sizeof (rtm));
rtm.hdr.rtm_version = RTM_VERSION;
rtm.hdr.rtm_seq = ++seq;
rtm.hdr.rtm_type = change ? RTM_CHANGE : del ? RTM_DELETE : RTM_ADD;
rtm.hdr.rtm_flags = RTF_UP | RTF_STATIC;
/* This order is important */
rtm.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
#define ADDADDR(_addr) \
memset (&su, 0, sizeof (su)); \
su.sin.sin_family = AF_INET; \
su.sin.sin_len = sizeof (su.sin); \
memcpy (&su.sin.sin_addr, &_addr, sizeof (su.sin.sin_addr)); \
l = SA_SIZE (&(su.sa)); \
memcpy (bp, &(su), l); \
bp += l;
ADDADDR (destination);
if (netmask.s_addr == INADDR_BROADCAST ||
gateway.s_addr == INADDR_ANY)
{
/* Make us a link layer socket */
unsigned char *hwaddr;
size_t hwlen = 0;
if (netmask.s_addr == INADDR_BROADCAST)
rtm.hdr.rtm_flags |= RTF_HOST;
hwaddr = xmalloc (sizeof (unsigned char) * HWADDR_LEN);
_do_interface (ifname, hwaddr, &hwlen, NULL, false, false);
memset (&su, 0, sizeof (su));
su.sdl.sdl_len = sizeof (su.sdl);
su.sdl.sdl_family = AF_LINK;
su.sdl.sdl_nlen = strlen (ifname);
memcpy (&su.sdl.sdl_data, ifname, (size_t) su.sdl.sdl_nlen);
su.sdl.sdl_alen = hwlen;
memcpy (((unsigned char *) &su.sdl.sdl_data) + su.sdl.sdl_nlen,
hwaddr, (size_t) su.sdl.sdl_alen);
l = SA_SIZE (&(su.sa));
memcpy (bp, &su, l);
bp += l;
free (hwaddr);
}
else
{
rtm.hdr.rtm_flags |= RTF_GATEWAY;
ADDADDR (gateway);
}
ADDADDR (netmask);
#undef ADDADDR
rtm.hdr.rtm_msglen = l = bp - (char *)&rtm;
if (write (s, &rtm, l) == -1)
{
/* Don't report error about routes already existing */
if (errno != EEXIST)
logger (LOG_ERR, "write: %s", strerror (errno));
close (s);
return -1;
}
close (s);
return 0;
}
#elif __linux__
/* This netlink stuff is overly compex IMO.
* The BSD implementation is much cleaner and a lot less code.
* send_netlink handles the actual transmission so we can work out
* if there was an error or not. */
#define BUFFERLEN 256
int send_netlink (struct nlmsghdr *hdr, netlink_callback callback, void *arg)
{
int s;
pid_t mypid = getpid ();
struct sockaddr_nl nl;
struct iovec iov;
struct msghdr msg;
static unsigned int seq;
char *buffer;
ssize_t bytes;
union
{
char *buffer;
struct nlmsghdr *nlm;
} h;
if ((s = socket (AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1)
{
logger (LOG_ERR, "socket: %s", strerror (errno));
return -1;
}
memset (&nl, 0, sizeof (nl));
nl.nl_family = AF_NETLINK;
if (bind (s, (struct sockaddr *) &nl, sizeof (nl)) == -1)
{
logger (LOG_ERR, "bind: %s", strerror (errno));
close (s);
return -1;
}
memset (&iov, 0, sizeof (iov));
iov.iov_base = hdr;
iov.iov_len = hdr->nlmsg_len;
memset (&msg, 0, sizeof (msg));
msg.msg_name = &nl;
msg.msg_namelen = sizeof (nl);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
/* Request a reply */
hdr->nlmsg_flags |= NLM_F_ACK;
hdr->nlmsg_seq = ++seq;
if (sendmsg (s, &msg, 0) == -1)
{
logger (LOG_ERR, "write: %s", strerror (errno));
close (s);
return -1;
}
buffer = xzalloc (sizeof (char) * BUFFERLEN);
iov.iov_base = buffer;
for (;;)
{
iov.iov_len = BUFFERLEN;
bytes = recvmsg (s, &msg, 0);
if (bytes == -1)
{
if (errno != EINTR)
logger (LOG_ERR, "recvmsg: %s",
strerror (errno));
continue;
}
if (bytes == 0)
{
logger (LOG_ERR, "netlink: EOF");
goto eexit;
}
if (msg.msg_namelen != sizeof (nl))
{
logger (LOG_ERR,
"netlink: sender address length mismatch");
goto eexit;
}
for (h.buffer = buffer; bytes >= (signed) sizeof (*h.nlm); )
{
int len = h.nlm->nlmsg_len;
int l = len - sizeof (*h.nlm);
struct nlmsgerr *err = (struct nlmsgerr *) NLMSG_DATA (h.nlm);
if (l < 0 || len > bytes)
{
if (msg.msg_flags & MSG_TRUNC)
logger (LOG_ERR, "netlink: truncated message");
else
logger (LOG_ERR, "netlink: malformed message");
goto eexit;
}
/* Ensure it's our message */
if (nl.nl_pid != 0 ||
(pid_t) h.nlm->nlmsg_pid != mypid ||
h.nlm->nlmsg_seq != seq)
{
/* Next Message */
bytes -= NLMSG_ALIGN (len);
h.buffer += NLMSG_ALIGN (len);
continue;
}
/* We get an NLMSG_ERROR back with a code of zero for success */
if (h.nlm->nlmsg_type != NLMSG_ERROR)
{
logger (LOG_ERR, "netlink: unexpected reply %d",
h.nlm->nlmsg_type);
goto eexit;
}
if ((unsigned) l < sizeof (*err))
{
logger (LOG_ERR, "netlink: error truncated");
goto eexit;
}
if (err->error == 0)
{
int retval = 0;
close (s);
if (callback)
{
if ((retval = callback (hdr, arg)) == -1)
logger (LOG_ERR, "netlink: callback failed");
}
free (buffer);
return (retval);
}
errno = -err->error;
/* Don't report on something already existing */
if (errno != EEXIST)
logger (LOG_ERR, "netlink: %s",
strerror (errno));
goto eexit;
}
}
eexit:
close (s);
free (buffer);
return -1;
}
#define NLMSG_TAIL(nmsg) \
((struct rtattr *) (((ptrdiff_t) (nmsg)) + NLMSG_ALIGN ((nmsg)->nlmsg_len)))
static int add_attr_l(struct nlmsghdr *n, unsigned int maxlen, int type,
const void *data, int alen)
{
int len = RTA_LENGTH(alen);
struct rtattr *rta;
if (NLMSG_ALIGN (n->nlmsg_len) + RTA_ALIGN (len) > maxlen)
{
logger (LOG_ERR, "add_attr_l: message exceeded bound of %d\n",
maxlen);
return -1;
}
rta = NLMSG_TAIL (n);
rta->rta_type = type;
rta->rta_len = len;
memcpy (RTA_DATA (rta), data, alen);
n->nlmsg_len = NLMSG_ALIGN (n->nlmsg_len) + RTA_ALIGN (len);
return 0;
}
static int add_attr_32(struct nlmsghdr *n, unsigned int maxlen, int type,
uint32_t data)
{
int len = RTA_LENGTH (sizeof (data));
struct rtattr *rta;
if (NLMSG_ALIGN (n->nlmsg_len) + len > maxlen)
{
logger (LOG_ERR, "add_attr32: message exceeded bound of %d\n",
maxlen);
return -1;
}
rta = NLMSG_TAIL (n);
rta->rta_type = type;
rta->rta_len = len;
memcpy (RTA_DATA (rta), &data, sizeof (data));
n->nlmsg_len = NLMSG_ALIGN (n->nlmsg_len) + len;
return 0;
}
struct nlma
{
struct nlmsghdr hdr;
struct ifaddrmsg ifa;
char buffer[64];
};
struct nlmr
{
struct nlmsghdr hdr;
struct rtmsg rt;
char buffer[256];
};
static int do_address(const char *ifname,
struct in_addr address, struct in_addr netmask,
struct in_addr broadcast, int del)
{
struct nlma *nlm;
int retval;
if (!ifname)
return -1;
nlm = xzalloc (sizeof (*nlm));
nlm->hdr.nlmsg_len = NLMSG_LENGTH (sizeof (struct ifaddrmsg));
nlm->hdr.nlmsg_flags = NLM_F_REQUEST;
if (! del)
nlm->hdr.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
nlm->hdr.nlmsg_type = del ? RTM_DELADDR : RTM_NEWADDR;
if (! (nlm->ifa.ifa_index = if_nametoindex (ifname)))
{
logger (LOG_ERR, "if_nametoindex: no index for interface `%s'",
ifname);
free (nlm);
return -1;
}
nlm->ifa.ifa_family = AF_INET;
nlm->ifa.ifa_prefixlen = inet_ntocidr (netmask);
/* This creates the aliased interface */
add_attr_l (&nlm->hdr, sizeof (*nlm), IFA_LABEL,
ifname, strlen (ifname) + 1);
add_attr_l (&nlm->hdr, sizeof (*nlm), IFA_LOCAL,
&address.s_addr, sizeof (address.s_addr));
if (! del)
add_attr_l (&nlm->hdr, sizeof (*nlm), IFA_BROADCAST,
&broadcast.s_addr, sizeof (broadcast.s_addr));
retval = send_netlink (&nlm->hdr, NULL, NULL);
free (nlm);
return retval;
}
static int do_route (const char *ifname,
struct in_addr destination,
struct in_addr netmask,
struct in_addr gateway,
int metric, int change, int del)
{
struct nlmr *nlm;
unsigned int ifindex;
int retval;
if (! ifname)
return -1;
log_route (destination, netmask, gateway, metric, change, del);
if (! (ifindex = if_nametoindex (ifname)))
{
logger (LOG_ERR, "if_nametoindex: no index for interface `%s'",
ifname);
return -1;
}
nlm = xzalloc (sizeof (*nlm));
nlm->hdr.nlmsg_len = NLMSG_LENGTH (sizeof (struct rtmsg));
if (change)
nlm->hdr.nlmsg_flags = NLM_F_REPLACE;
else if (! del)
nlm->hdr.nlmsg_flags = NLM_F_CREATE | NLM_F_EXCL;
nlm->hdr.nlmsg_flags |= NLM_F_REQUEST;
nlm->hdr.nlmsg_type = del ? RTM_DELROUTE : RTM_NEWROUTE;
nlm->rt.rtm_family = AF_INET;
nlm->rt.rtm_table = RT_TABLE_MAIN;
if (del)
nlm->rt.rtm_scope = RT_SCOPE_NOWHERE;
else
{
nlm->hdr.nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
nlm->rt.rtm_protocol = RTPROT_BOOT;
if (netmask.s_addr == INADDR_BROADCAST ||
gateway.s_addr == INADDR_ANY)
nlm->rt.rtm_scope = RT_SCOPE_LINK;
else
nlm->rt.rtm_scope = RT_SCOPE_UNIVERSE;
nlm->rt.rtm_type = RTN_UNICAST;
}
nlm->rt.rtm_dst_len = inet_ntocidr (netmask);
add_attr_l (&nlm->hdr, sizeof (*nlm), RTA_DST,
&destination.s_addr, sizeof (destination.s_addr));
if (netmask.s_addr != INADDR_BROADCAST &&
destination.s_addr != gateway.s_addr)
add_attr_l (&nlm->hdr, sizeof (*nlm), RTA_GATEWAY,
&gateway.s_addr, sizeof (gateway.s_addr));
add_attr_32 (&nlm->hdr, sizeof (*nlm), RTA_OIF, ifindex);
add_attr_32 (&nlm->hdr, sizeof (*nlm), RTA_PRIORITY, metric);
retval = send_netlink (&nlm->hdr, NULL, NULL);
free (nlm);
return retval;
}
#else
#error "Platform not supported!"
#error "We currently support BPF and Linux sockets."
#error "Other platforms may work using BPF. If yours does, please let me know"
#error "so I can add it to our list."
#endif
int add_address (const char *ifname, struct in_addr address,
struct in_addr netmask, struct in_addr broadcast)
{
logger (LOG_INFO, "adding IP address %s/%d",
inet_ntoa (address), inet_ntocidr (netmask));
return (do_address (ifname, address, netmask, broadcast, 0));
}
int del_address (const char *ifname,
struct in_addr address, struct in_addr netmask)
{
struct in_addr t;
logger (LOG_INFO, "removing IP address %s/%d",
inet_ntoa (address), inet_ntocidr (netmask));
memset (&t, 0, sizeof (t));
return (do_address (ifname, address, netmask, t, 1));
}
int add_route (const char *ifname, struct in_addr destination,
struct in_addr netmask, struct in_addr gateway, int metric)
{
return (do_route (ifname, destination, netmask, gateway, metric, 0, 0));
}
int change_route (const char *ifname, struct in_addr destination,
struct in_addr netmask, struct in_addr gateway, int metric)
{
return (do_route (ifname, destination, netmask, gateway, metric, 1, 0));
}
int del_route (const char *ifname, struct in_addr destination,
struct in_addr netmask, struct in_addr gateway, int metric)
{
return (do_route (ifname, destination, netmask, gateway, metric, 0, 1));
}
int flush_addresses (const char *ifname)
{
return (_do_interface (ifname, NULL, NULL, NULL, true, false));
}
in_addr_t get_address (const char *ifname)
{
struct in_addr address;
if (_do_interface (ifname, NULL, NULL, &address, false, true) > 0)
return (address.s_addr);
return (0);
}
int has_address (const char *ifname, struct in_addr address)
{
return (_do_interface (ifname, NULL, NULL, &address, false, false));
}