Home | History | Annotate | Download | only in dhcpcd 
      1 /*
      2  * dhcpcd - DHCP client daemon
      3  * Copyright (c) 2006-2008 Roy Marples <roy (at) marples.name>
      4  * All rights reserved
      5 
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 #include <errno.h>
     29 #include <signal.h>
     30 #include <stdlib.h>
     31 #include <string.h>
     32 #include <syslog.h>
     33 #include <unistd.h>
     34 
     35 #include "arp.h"
     36 #include "bind.h"
     37 #include "common.h"
     38 #include "dhcpcd.h"
     39 #include "eloop.h"
     40 #include "if-options.h"
     41 #include "ipv4ll.h"
     42 #include "net.h"
     43 
     44 #define ARP_LEN								      \
     45 	(sizeof(struct arphdr) + (2 * sizeof(uint32_t)) + (2 * HWADDR_LEN))
     46 
     47 static int
     48 send_arp(const struct interface *iface, int op, in_addr_t sip, in_addr_t tip)
     49 {
     50 	uint8_t arp_buffer[ARP_LEN];
     51 	struct arphdr ar;
     52 	size_t len;
     53 	uint8_t *p;
     54 	int retval;
     55 
     56 	ar.ar_hrd = htons(iface->family);
     57 	ar.ar_pro = htons(ETHERTYPE_IP);
     58 	ar.ar_hln = iface->hwlen;
     59 	ar.ar_pln = sizeof(sip);
     60 	ar.ar_op = htons(op);
     61 	memcpy(arp_buffer, &ar, sizeof(ar));
     62 	p = arp_buffer + sizeof(ar);
     63 	memcpy(p, iface->hwaddr, iface->hwlen);
     64 	p += iface->hwlen;
     65 	memcpy(p, &sip, sizeof(sip));
     66 	p += sizeof(sip);
     67 	/* ARP requests should ignore this */
     68 	retval = iface->hwlen;
     69 	while (retval--)
     70 		*p++ = '\0';
     71 	memcpy(p, &tip, sizeof(tip));
     72 	p += sizeof(tip);
     73 	len = p - arp_buffer;
     74 	retval = send_raw_packet(iface, ETHERTYPE_ARP, arp_buffer, len);
     75 	return retval;
     76 }
     77 
     78 static void
     79 handle_arp_failure(struct interface *iface)
     80 {
     81 
     82 	/* If we failed without a magic cookie then we need to try
     83 	 * and defend our IPv4LL address. */
     84 	if ((iface->state->offer != NULL &&
     85 		iface->state->offer->cookie != htonl(MAGIC_COOKIE)) ||
     86 	    (iface->state->new != NULL &&
     87 		iface->state->new->cookie != htonl(MAGIC_COOKIE)))
     88 	{
     89 		handle_ipv4ll_failure(iface);
     90 		return;
     91 	}
     92 
     93 	unlink(iface->leasefile);
     94 	if (!iface->state->lease.frominfo)
     95 		send_decline(iface);
     96 	close_sockets(iface);
     97 	delete_timeout(NULL, iface);
     98 	if (iface->state->lease.frominfo)
     99 		start_interface(iface);
    100 	else
    101 		add_timeout_sec(DHCP_ARP_FAIL, start_interface, iface);
    102 }
    103 
    104 static void
    105 handle_arp_packet(void *arg)
    106 {
    107 	struct interface *iface = arg;
    108 	uint8_t arp_buffer[ARP_LEN];
    109 	struct arphdr ar;
    110 	uint32_t reply_s;
    111 	uint32_t reply_t;
    112 	uint8_t *hw_s, *hw_t;
    113 	ssize_t bytes;
    114 	struct if_state *state = iface->state;
    115 	struct if_options *opts = state->options;
    116 	const char *hwaddr;
    117 	struct in_addr ina;
    118 
    119 	state->fail.s_addr = 0;
    120 	for(;;) {
    121 		bytes = get_raw_packet(iface, ETHERTYPE_ARP,
    122 		    arp_buffer, sizeof(arp_buffer));
    123 		if (bytes == 0 || bytes == -1)
    124 			return;
    125 		/* We must have a full ARP header */
    126 		if ((size_t)bytes < sizeof(ar))
    127 			continue;
    128 		memcpy(&ar, arp_buffer, sizeof(ar));
    129 		/* Protocol must be IP. */
    130 		if (ar.ar_pro != htons(ETHERTYPE_IP))
    131 			continue;
    132 		if (ar.ar_pln != sizeof(reply_s))
    133 			continue;
    134 		/* Only these types are recognised */
    135 		if (ar.ar_op != htons(ARPOP_REPLY) &&
    136 		    ar.ar_op != htons(ARPOP_REQUEST))
    137 			continue;
    138 
    139 		/* Get pointers to the hardware addreses */
    140 		hw_s = arp_buffer + sizeof(ar);
    141 		hw_t = hw_s + ar.ar_hln + ar.ar_pln;
    142 		/* Ensure we got all the data */
    143 		if ((hw_t + ar.ar_hln + ar.ar_pln) - arp_buffer > bytes)
    144 			continue;
    145 		/* Ignore messages from ourself */
    146 		if (ar.ar_hln == iface->hwlen &&
    147 		    memcmp(hw_s, iface->hwaddr, iface->hwlen) == 0)
    148 			continue;
    149 		/* Copy out the IP addresses */
    150 		memcpy(&reply_s, hw_s + ar.ar_hln, ar.ar_pln);
    151 		memcpy(&reply_t, hw_t + ar.ar_hln, ar.ar_pln);
    152 
    153 		/* Check for arping */
    154 		if (state->arping_index &&
    155 		    state->arping_index <= opts->arping_len &&
    156 		    (reply_s == opts->arping[state->arping_index - 1] ||
    157 			(reply_s == 0 &&
    158 			    reply_t == opts->arping[state->arping_index - 1])))
    159 		{
    160 			ina.s_addr = reply_s;
    161 			hwaddr = hwaddr_ntoa((unsigned char *)hw_s,
    162 			    (size_t)ar.ar_hln);
    163 			syslog(LOG_INFO,
    164 			    "%s: found %s on hardware address %s",
    165 			    iface->name, inet_ntoa(ina), hwaddr);
    166 			if (select_profile(iface, hwaddr) == -1 &&
    167 			    errno == ENOENT)
    168 				select_profile(iface, inet_ntoa(ina));
    169 			close_sockets(iface);
    170 			delete_timeout(NULL, iface);
    171 			start_interface(iface);
    172 			return;
    173 		}
    174 
    175 		/* Check for conflict */
    176 		if (state->offer &&
    177 		    (reply_s == state->offer->yiaddr ||
    178 			(reply_s == 0 && reply_t == state->offer->yiaddr)))
    179 			state->fail.s_addr = state->offer->yiaddr;
    180 
    181 		/* Handle IPv4LL conflicts */
    182 		if (IN_LINKLOCAL(htonl(iface->addr.s_addr)) &&
    183 		    (reply_s == iface->addr.s_addr ||
    184 			(reply_s == 0 && reply_t == iface->addr.s_addr)))
    185 			state->fail.s_addr = iface->addr.s_addr;
    186 
    187 		if (state->fail.s_addr) {
    188 			syslog(LOG_ERR, "%s: hardware address %s claims %s",
    189 			    iface->name,
    190 			    hwaddr_ntoa((unsigned char *)hw_s,
    191 				(size_t)ar.ar_hln),
    192 			    inet_ntoa(state->fail));
    193 			errno = EEXIST;
    194 			handle_arp_failure(iface);
    195 			return;
    196 		}
    197 	}
    198 }
    199 
    200 void
    201 send_arp_announce(void *arg)
    202 {
    203 	struct interface *iface = arg;
    204 	struct if_state *state = iface->state;
    205 	struct timeval tv;
    206 
    207 	if (iface->arp_fd == -1) {
    208 		open_socket(iface, ETHERTYPE_ARP);
    209 		add_event(iface->arp_fd, handle_arp_packet, iface);
    210 	}
    211 	if (++state->claims < ANNOUNCE_NUM)
    212 		syslog(LOG_DEBUG,
    213 		    "%s: sending ARP announce (%d of %d), "
    214 		    "next in %d.00 seconds",
    215 		    iface->name, state->claims, ANNOUNCE_NUM, ANNOUNCE_WAIT);
    216 	else
    217 		syslog(LOG_DEBUG,
    218 		    "%s: sending ARP announce (%d of %d)",
    219 		    iface->name, state->claims, ANNOUNCE_NUM);
    220 	if (send_arp(iface, ARPOP_REQUEST,
    221 		state->new->yiaddr, state->new->yiaddr) == -1)
    222 		syslog(LOG_ERR, "send_arp: %m");
    223 	if (state->claims < ANNOUNCE_NUM) {
    224 		add_timeout_sec(ANNOUNCE_WAIT, send_arp_announce, iface);
    225 		return;
    226 	}
    227 	if (state->new->cookie != htonl(MAGIC_COOKIE)) {
    228 		/* We should pretend to be at the end
    229 		 * of the DHCP negotation cycle unless we rebooted */
    230 		if (state->interval != 0)
    231 			state->interval = 64;
    232 		state->probes = 0;
    233 		state->claims = 0;
    234 		tv.tv_sec = state->interval - DHCP_RAND_MIN;
    235 		tv.tv_usec = arc4random() % (DHCP_RAND_MAX_U - DHCP_RAND_MIN_U);
    236 		timernorm(&tv);
    237 		add_timeout_tv(&tv, start_discover, iface);
    238 	} else {
    239 		delete_event(iface->arp_fd);
    240 		close(iface->arp_fd);
    241 		iface->arp_fd = -1;
    242 	}
    243 }
    244 
    245 void
    246 send_arp_probe(void *arg)
    247 {
    248 	struct interface *iface = arg;
    249 	struct if_state *state = iface->state;
    250 	struct in_addr addr;
    251 	struct timeval tv;
    252 	int arping = 0;
    253 
    254 	if (state->arping_index < state->options->arping_len) {
    255 		addr.s_addr = state->options->arping[state->arping_index];
    256 		arping = 1;
    257 	} else if (state->offer) {
    258 		if (state->offer->yiaddr)
    259 			addr.s_addr = state->offer->yiaddr;
    260 		else
    261 			addr.s_addr = state->offer->ciaddr;
    262 	} else
    263 		addr.s_addr = iface->addr.s_addr;
    264 
    265 	if (iface->arp_fd == -1) {
    266 		open_socket(iface, ETHERTYPE_ARP);
    267 		add_event(iface->arp_fd, handle_arp_packet, iface);
    268 	}
    269 	if (state->probes == 0) {
    270 		if (arping)
    271 			syslog(LOG_INFO, "%s: searching for %s",
    272 			    iface->name, inet_ntoa(addr));
    273 		else
    274 			syslog(LOG_INFO, "%s: checking for %s",
    275 			    iface->name, inet_ntoa(addr));
    276 	}
    277 	if (++state->probes < PROBE_NUM) {
    278 		tv.tv_sec = PROBE_MIN;
    279 		tv.tv_usec = arc4random() % (PROBE_MAX_U - PROBE_MIN_U);
    280 		timernorm(&tv);
    281 		add_timeout_tv(&tv, send_arp_probe, iface);
    282 	} else {
    283 		tv.tv_sec = ANNOUNCE_WAIT;
    284 		tv.tv_usec = 0;
    285 		if (arping) {
    286 			state->probes = 0;
    287 			if (++state->arping_index < state->options->arping_len)
    288 				add_timeout_tv(&tv, send_arp_probe, iface);
    289 			else
    290 				add_timeout_tv(&tv, start_interface, iface);
    291 		} else
    292 			add_timeout_tv(&tv, bind_interface, iface);
    293 	}
    294 	syslog(LOG_DEBUG,
    295 	    "%s: sending ARP probe (%d of %d), next in %0.2f seconds",
    296 	    iface->name, state->probes ? state->probes : PROBE_NUM, PROBE_NUM,
    297 	    timeval_to_double(&tv));
    298 	if (send_arp(iface, ARPOP_REQUEST, 0, addr.s_addr) == -1)
    299 		syslog(LOG_ERR, "send_arp: %m");
    300 }
    301 
    302 void
    303 start_arping(struct interface *iface)
    304 {
    305 	iface->state->probes = 0;
    306 	iface->state->arping_index = 0;
    307 	send_arp_probe(iface);
    308 }
    309