dhcpcd/arp.c

/* 
 * 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/time.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in_systm.h>
#ifdef __linux__
#include <netinet/ether.h>
#include <netpacket/packet.h>
#endif
#include <net/if.h>
#include <net/if_arp.h>
#include <arpa/inet.h>
#include <errno.h>
#include <poll.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "config.h"
#include "common.h"
#include "arp.h"
#include "interface.h"
#include "logger.h"
#include "signal.h"
#include "socket.h"

/* These are really for IPV4LL */
#define NPROBES                 3
#define PROBE_INTERVAL          200
#define NCLAIMS                 2
#define CLAIM_INTERVAL          200

/* Linux does not seem to define these handy macros */
#ifndef ar_sha
#define ar_sha(ap) (((caddr_t) ((ap) + 1)) + 0)
#define ar_spa(ap) (((caddr_t) ((ap) + 1)) + (ap)->ar_hln)
#define ar_tha(ap) (((caddr_t) ((ap) + 1)) + (ap)->ar_hln + (ap)->ar_pln)
#define ar_tpa(ap) (((caddr_t) ((ap) + 1)) + 2 * (ap)->ar_hln + (ap)->ar_pln)
#endif

#ifndef arphdr_len
#define arphdr_len2(ar_hln, ar_pln) (sizeof (struct arphdr) + \
				     2 * (ar_hln) + 2 * (ar_pln))
#define arphdr_len(ap) (arphdr_len2 ((ap)->ar_hln, (ap)->ar_pln))
#endif

#ifdef ENABLE_ARP

static int send_arp (const interface_t *iface, int op, struct in_addr sip,
		     const unsigned char *taddr, struct in_addr tip)
{
	struct arphdr *arp;
	size_t arpsize = arphdr_len2 (iface->hwlen, sizeof (sip));
	caddr_t tha;
	int retval;

	arp = xzalloc (arpsize);
	arp->ar_hrd = htons (iface->family);
	arp->ar_pro = htons (ETHERTYPE_IP);
	arp->ar_hln = iface->hwlen;
	arp->ar_pln = sizeof (sip);
	arp->ar_op = htons (op);
	memcpy (ar_sha (arp), iface->hwaddr, (size_t) arp->ar_hln);
	memcpy (ar_spa (arp), &sip, (size_t) arp->ar_pln);
	if (taddr) {
		/* NetBSD can return NULL from ar_tha, which is probably wrong
		 * but we still need to deal with it */
		if (! (tha = ar_tha (arp))) {
			free (arp);
			errno = EINVAL;
			return (-1);
		}
		memcpy (tha, taddr, (size_t) arp->ar_hln);
	}
	memcpy (ar_tpa (arp), &tip, (size_t) arp->ar_pln);

	retval = send_packet (iface, ETHERTYPE_ARP,
			      (unsigned char *) arp, arphdr_len (arp));
	free (arp);
	return (retval);
}

int arp_claim (interface_t *iface, struct in_addr address)
{
	struct arphdr *reply = NULL;
	long timeout = 0;
	unsigned char *buffer;
	int retval = -1;
	int nprobes = 0;
	int nclaims = 0;
	struct in_addr null_address;
	struct pollfd fds[] = {
		{ -1, POLLIN, 0 },
		{ -1, POLLIN, 0 }
	};

	if (! iface)
		return (-1);

	if (! iface->arpable) {
		logger (LOG_DEBUG, "interface `%s' is not ARPable", iface->name);
		return (0);
	}

	if (! IN_LINKLOCAL (ntohl (iface->previous_address.s_addr)) &&
	    ! IN_LINKLOCAL (ntohl (address.s_addr)))
		logger (LOG_INFO,
			"checking %s is available on attached networks",
			inet_ntoa (address));

	if (! open_socket (iface, ETHERTYPE_ARP))
		return (-1);

	fds[0].fd = signal_fd ();
	fds[1].fd = iface->fd;

	memset (&null_address, 0, sizeof (null_address));

	buffer = xmalloc (iface->buffer_length);
	reply = xmalloc (iface->buffer_length);

	for (;;) {
		size_t bufpos = 0;
		size_t buflen = iface->buffer_length;
		int bytes;
		int s = 0;
		struct timeval stopat;
		struct timeval now;

		/* Only poll if we have a timeout */
		if (timeout > 0) {
			s = poll (fds, 2, timeout);
			if (s == -1) {
				if (errno == EINTR) {
					if (signal_exists (NULL) == -1) {
						errno = 0;
						continue;
					} else
						break;
				}

				logger (LOG_ERR, "poll: `%s'",
					strerror (errno));
				break;
			}
		}

		/* Timed out */
		if (s == 0) {
			if (nprobes < NPROBES) {
				nprobes ++;
				timeout = PROBE_INTERVAL;
				logger (LOG_DEBUG, "sending ARP probe #%d",
					nprobes);
				if (send_arp (iface, ARPOP_REQUEST,
					      null_address, NULL,
					      address) == -1)
					break;

				/* IEEE1394 cannot set ARP target address
				 * according to RFC2734 */
				if (nprobes >= NPROBES &&
				    iface->family == ARPHRD_IEEE1394)
					nclaims = NCLAIMS;
			} else if (nclaims < NCLAIMS) {
				nclaims ++;
				timeout = CLAIM_INTERVAL;
				logger (LOG_DEBUG, "sending ARP claim #%d",
					nclaims);
				if (send_arp (iface, ARPOP_REQUEST,
					      address, iface->hwaddr,
					      address) == -1)
					break;
			} else {
				/* No replies, so done */
				retval = 0;
				break;
			}

			/* Setup our stop time */
			if (get_time (&stopat) != 0)
				break;
			stopat.tv_usec += timeout;

			continue;
		}

		/* We maybe ARP flooded, so check our time */
		if (get_time (&now) != 0)
			break;
		if (timercmp (&now, &stopat, >)) {
			timeout = 0;
			continue;
		}

		if (! fds[1].revents & POLLIN)
			continue;

		memset (buffer, 0, buflen);
		do {
			union {
				unsigned char *c;
				struct in_addr *a;
			} rp;
			union {
				unsigned char *c;
				struct ether_addr *a;
			} rh;

			memset (reply, 0, iface->buffer_length);
			if ((bytes = get_packet (iface, (unsigned char *) reply,
						 buffer,
						 &buflen, &bufpos)) == -1)
				break;

			/* Only these types are recognised */
			if (reply->ar_op != htons (ARPOP_REPLY))
				continue;

			/* Protocol must be IP. */
			if (reply->ar_pro != htons (ETHERTYPE_IP))
				continue;
			if (reply->ar_pln != sizeof (address))
				continue;
			if ((unsigned) bytes < sizeof (reply) + 
			    2 * (4 + reply->ar_hln))
				continue;

			rp.c = (unsigned char *) ar_spa (reply);
			rh.c = (unsigned char *) ar_sha (reply);

			/* Ensure the ARP reply is for the our address */
			if (rp.a->s_addr != address.s_addr)
				continue;

			/* Some systems send a reply back from our hwaddress,
			 * which is wierd */
			if (reply->ar_hln == iface->hwlen &&
			    memcmp (rh.c, iface->hwaddr, iface->hwlen) == 0)
				continue;

			logger (LOG_ERR, "ARPOP_REPLY received from %s (%s)",
				inet_ntoa (*rp.a),
				hwaddr_ntoa (rh.c, (size_t) reply->ar_hln));
			retval = -1;
			goto eexit;
		} while (bufpos != 0);
	}

eexit:
	close (iface->fd);
	iface->fd = -1;
	free (buffer);
	free (reply);
	return (retval);
}
#endif