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;
|
|
}
|