e963960681
for talking to the server and for setting the interface address and route. However, otherwise it is quite different, since we need to be working under the assumptions that there is no stable storage on a rump instance, and that there are n networking stacks on a given host.
504 lines
11 KiB
C
504 lines
11 KiB
C
/*
|
|
* dhcpcd - DHCP client daemon
|
|
* Copyright (c) 2006-2010 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/ioctl.h>
|
|
#include <sys/param.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <arpa/inet.h>
|
|
#include <net/if.h>
|
|
#include <net/if_arp.h>
|
|
#ifdef AF_LINK
|
|
# include <net/if_dl.h>
|
|
# include <net/if_types.h>
|
|
#endif
|
|
#include <netinet/in_systm.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/ip.h>
|
|
#define __FAVOR_BSD /* Nasty glibc hack so we can use BSD semantics for UDP */
|
|
#include <netinet/udp.h>
|
|
#undef __FAVOR_BSD
|
|
#ifdef AF_PACKET
|
|
# include <netpacket/packet.h>
|
|
#endif
|
|
#ifdef SIOCGIFMEDIA
|
|
# include <net/if_media.h>
|
|
#endif
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <ifaddrs.h>
|
|
#include <fnmatch.h>
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "common.h"
|
|
#include "dhcp.h"
|
|
#include "if-options.h"
|
|
#include "net.h"
|
|
|
|
#include <rump/rump_syscalls.h>
|
|
|
|
static char hwaddr_buffer[(HWADDR_LEN * 3) + 1];
|
|
|
|
int socket_afnet = -1;
|
|
|
|
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 < 1 || cidr > 32) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
ocets = (cidr + 7) / 8;
|
|
|
|
addr->s_addr = 0;
|
|
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)
|
|
{
|
|
char *p = hwaddr_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 hwaddr_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 digits are hex */
|
|
if (isxdigit((unsigned char)c[0]) == 0 ||
|
|
isxdigit((unsigned char)c[1]) == 0)
|
|
{
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
/* We should have at least two entries 00:01 */
|
|
if (len == 0 && *p == '\0') {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
/* Ensure that next data is EOL or a seperator with data */
|
|
if (!(*p == '\0' || (*p == ':' && *(p + 1) != '\0'))) {
|
|
errno = EINVAL;
|
|
return 0;
|
|
}
|
|
if (*p)
|
|
p++;
|
|
if (bp)
|
|
*bp++ = (unsigned char)strtol(c, NULL, 16);
|
|
len++;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
struct interface *
|
|
init_interface(const char *ifname)
|
|
{
|
|
struct ifreq ifr;
|
|
struct interface *iface = NULL;
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
|
|
if (rump_sys_ioctl(socket_afnet, SIOCGIFFLAGS, &ifr) == -1)
|
|
goto eexit;
|
|
|
|
iface = xzalloc(sizeof(*iface));
|
|
strlcpy(iface->name, ifname, sizeof(iface->name));
|
|
iface->flags = ifr.ifr_flags;
|
|
/* We reserve the 100 range for virtual interfaces, if and when
|
|
* we can work them out. */
|
|
iface->metric = 200 + if_nametoindex(iface->name);
|
|
if (getifssid(ifname, iface->ssid) != -1) {
|
|
iface->wireless = 1;
|
|
iface->metric += 100;
|
|
}
|
|
|
|
if (rump_sys_ioctl(socket_afnet, SIOCGIFMTU, &ifr) == -1)
|
|
goto eexit;
|
|
/* Ensure that the MTU is big enough for DHCP */
|
|
if (ifr.ifr_mtu < MTU_MIN) {
|
|
ifr.ifr_mtu = MTU_MIN;
|
|
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
|
|
if (rump_sys_ioctl(socket_afnet, SIOCSIFMTU, &ifr) == -1)
|
|
goto eexit;
|
|
}
|
|
|
|
/* 0 is a valid fd, so init to -1 */
|
|
iface->raw_fd = -1;
|
|
iface->udp_fd = -1;
|
|
iface->arp_fd = -1;
|
|
goto exit;
|
|
|
|
eexit:
|
|
free(iface);
|
|
iface = NULL;
|
|
exit:
|
|
return iface;
|
|
}
|
|
|
|
int
|
|
carrier_status(struct interface *iface)
|
|
{
|
|
int ret;
|
|
struct ifreq ifr;
|
|
#ifdef SIOCGIFMEDIA
|
|
struct ifmediareq ifmr;
|
|
#endif
|
|
#ifdef __linux__
|
|
char *p;
|
|
#endif
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
|
|
#ifdef __linux__
|
|
/* We can only test the real interface up */
|
|
if ((p = strchr(ifr.ifr_name, ':')))
|
|
*p = '\0';
|
|
#endif
|
|
|
|
if (rump_sys_ioctl(socket_afnet, SIOCGIFFLAGS, &ifr) == -1)
|
|
return -1;
|
|
iface->flags = ifr.ifr_flags;
|
|
|
|
ret = -1;
|
|
#ifdef SIOCGIFMEDIA
|
|
memset(&ifmr, 0, sizeof(ifmr));
|
|
strlcpy(ifmr.ifm_name, iface->name, sizeof(ifmr.ifm_name));
|
|
if (rump_sys_ioctl(socket_afnet, SIOCGIFMEDIA, &ifmr) != -1 &&
|
|
ifmr.ifm_status & IFM_AVALID)
|
|
ret = (ifmr.ifm_status & IFM_ACTIVE) ? 1 : 0;
|
|
#endif
|
|
if (ret == -1)
|
|
ret = (ifr.ifr_flags & IFF_RUNNING) ? 1 : 0;
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
up_interface(struct interface *iface)
|
|
{
|
|
struct ifreq ifr;
|
|
int retval = -1;
|
|
#ifdef __linux__
|
|
char *p;
|
|
#endif
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
|
|
#ifdef __linux__
|
|
/* We can only bring the real interface up */
|
|
if ((p = strchr(ifr.ifr_name, ':')))
|
|
*p = '\0';
|
|
#endif
|
|
if (rump_sys_ioctl(socket_afnet, SIOCGIFFLAGS, &ifr) == 0) {
|
|
if ((ifr.ifr_flags & IFF_UP))
|
|
retval = 0;
|
|
else {
|
|
ifr.ifr_flags |= IFF_UP;
|
|
if (rump_sys_ioctl(socket_afnet, SIOCSIFFLAGS, &ifr) == 0)
|
|
retval = 0;
|
|
}
|
|
iface->flags = ifr.ifr_flags;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
do_address(const char *ifname,
|
|
struct in_addr *addr, struct in_addr *net, struct in_addr *dst, int act)
|
|
{
|
|
struct ifaddrs *ifaddrs, *ifa;
|
|
const struct sockaddr_in *a, *n, *d;
|
|
int retval;
|
|
|
|
if (getifaddrs(&ifaddrs) == -1)
|
|
return -1;
|
|
|
|
retval = 0;
|
|
for (ifa = ifaddrs; ifa; ifa = ifa->ifa_next) {
|
|
if (ifa->ifa_addr == NULL ||
|
|
ifa->ifa_addr->sa_family != AF_INET ||
|
|
strcmp(ifa->ifa_name, ifname) != 0)
|
|
continue;
|
|
a = (const struct sockaddr_in *)(void *)ifa->ifa_addr;
|
|
n = (const struct sockaddr_in *)(void *)ifa->ifa_netmask;
|
|
if (ifa->ifa_flags & IFF_POINTOPOINT)
|
|
d = (const struct sockaddr_in *)(void *)
|
|
ifa->ifa_dstaddr;
|
|
else
|
|
d = NULL;
|
|
if (act == 1) {
|
|
addr->s_addr = a->sin_addr.s_addr;
|
|
net->s_addr = n->sin_addr.s_addr;
|
|
if (dst) {
|
|
if (ifa->ifa_flags & IFF_POINTOPOINT)
|
|
dst->s_addr = d->sin_addr.s_addr;
|
|
else
|
|
dst->s_addr = INADDR_ANY;
|
|
}
|
|
retval = 1;
|
|
break;
|
|
}
|
|
if (addr->s_addr == a->sin_addr.s_addr &&
|
|
(net == NULL || net->s_addr == n->sin_addr.s_addr))
|
|
{
|
|
retval = 1;
|
|
break;
|
|
}
|
|
}
|
|
freeifaddrs(ifaddrs);
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
do_mtu(const char *ifname, short int mtu)
|
|
{
|
|
struct ifreq ifr;
|
|
int r;
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
|
|
ifr.ifr_mtu = mtu;
|
|
r = rump_sys_ioctl(socket_afnet, mtu ? SIOCSIFMTU : SIOCGIFMTU, &ifr);
|
|
if (r == -1)
|
|
return -1;
|
|
return ifr.ifr_mtu;
|
|
}
|
|
|
|
void
|
|
free_routes(struct rt *routes)
|
|
{
|
|
struct rt *r;
|
|
|
|
while (routes) {
|
|
r = routes->next;
|
|
free(routes);
|
|
routes = r;
|
|
}
|
|
}
|
|
|
|
struct udp_dhcp_packet
|
|
{
|
|
struct ip ip;
|
|
struct udphdr udp;
|
|
struct dhcp_message dhcp;
|
|
};
|
|
const size_t udp_dhcp_len = sizeof(struct udp_dhcp_packet);
|
|
|
|
static uint16_t
|
|
checksum(const void *data, uint16_t len)
|
|
{
|
|
const uint8_t *addr = data;
|
|
uint32_t sum = 0;
|
|
|
|
while (len > 1) {
|
|
sum += addr[0] * 256 + addr[1];
|
|
addr += 2;
|
|
len -= 2;
|
|
}
|
|
|
|
if (len == 1)
|
|
sum += *addr * 256;
|
|
|
|
sum = (sum >> 16) + (sum & 0xffff);
|
|
sum += (sum >> 16);
|
|
|
|
sum = htons(sum);
|
|
|
|
return ~sum;
|
|
}
|
|
|
|
ssize_t
|
|
make_udp_packet(uint8_t **packet, const uint8_t *data, size_t length,
|
|
struct in_addr source, struct in_addr dest)
|
|
{
|
|
struct udp_dhcp_packet *udpp;
|
|
struct ip *ip;
|
|
struct udphdr *udp;
|
|
|
|
udpp = xzalloc(sizeof(*udpp));
|
|
ip = &udpp->ip;
|
|
udp = &udpp->udp;
|
|
|
|
/* OK, this is important :)
|
|
* We copy the data to our packet and then create a small part of the
|
|
* ip structure and an invalid ip_len (basically udp length).
|
|
* We then fill the udp structure and put the checksum
|
|
* of the whole packet into the udp checksum.
|
|
* Finally we complete the ip structure and ip checksum.
|
|
* If we don't do the ordering like so then the udp checksum will be
|
|
* broken, so find another way of doing it! */
|
|
|
|
memcpy(&udpp->dhcp, data, length);
|
|
|
|
ip->ip_p = IPPROTO_UDP;
|
|
ip->ip_src.s_addr = source.s_addr;
|
|
if (dest.s_addr == 0)
|
|
ip->ip_dst.s_addr = INADDR_BROADCAST;
|
|
else
|
|
ip->ip_dst.s_addr = dest.s_addr;
|
|
|
|
udp->uh_sport = htons(DHCP_CLIENT_PORT);
|
|
udp->uh_dport = htons(DHCP_SERVER_PORT);
|
|
udp->uh_ulen = htons(sizeof(*udp) + length);
|
|
ip->ip_len = udp->uh_ulen;
|
|
udp->uh_sum = checksum(udpp, sizeof(*udpp));
|
|
|
|
ip->ip_v = IPVERSION;
|
|
ip->ip_hl = sizeof(*ip) >> 2;
|
|
ip->ip_id = arc4random() & UINT16_MAX;
|
|
ip->ip_ttl = IPDEFTTL;
|
|
ip->ip_len = htons(sizeof(*ip) + sizeof(*udp) + length);
|
|
ip->ip_sum = checksum(ip, sizeof(*ip));
|
|
|
|
*packet = (uint8_t *)udpp;
|
|
return sizeof(*ip) + sizeof(*udp) + length;
|
|
}
|
|
|
|
ssize_t
|
|
get_udp_data(const uint8_t **data, const uint8_t *udp)
|
|
{
|
|
struct udp_dhcp_packet packet;
|
|
|
|
memcpy(&packet, udp, sizeof(packet));
|
|
*data = udp + offsetof(struct udp_dhcp_packet, dhcp);
|
|
return ntohs(packet.ip.ip_len) -
|
|
sizeof(packet.ip) -
|
|
sizeof(packet.udp);
|
|
}
|
|
|
|
int
|
|
valid_udp_packet(const uint8_t *data, size_t data_len, struct in_addr *from)
|
|
{
|
|
struct udp_dhcp_packet packet;
|
|
uint16_t bytes, udpsum;
|
|
|
|
if (data_len < sizeof(packet.ip)) {
|
|
if (from)
|
|
from->s_addr = INADDR_ANY;
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
memcpy(&packet, data, MIN(data_len, sizeof(packet)));
|
|
if (from)
|
|
from->s_addr = packet.ip.ip_src.s_addr;
|
|
if (data_len > sizeof(packet)) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
if (checksum(&packet.ip, sizeof(packet.ip)) != 0) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
bytes = ntohs(packet.ip.ip_len);
|
|
if (data_len < bytes) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
udpsum = packet.udp.uh_sum;
|
|
packet.udp.uh_sum = 0;
|
|
packet.ip.ip_hl = 0;
|
|
packet.ip.ip_v = 0;
|
|
packet.ip.ip_tos = 0;
|
|
packet.ip.ip_len = packet.udp.uh_ulen;
|
|
packet.ip.ip_id = 0;
|
|
packet.ip.ip_off = 0;
|
|
packet.ip.ip_ttl = 0;
|
|
packet.ip.ip_sum = 0;
|
|
if (udpsum && checksum(&packet, bytes) != udpsum) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|