diff --git a/tools/send_arp.linux.c b/tools/send_arp.linux.c

index e1c1960..477100a 100644

--- a/tools/send_arp.linux.c

+++ b/tools/send_arp.linux.c

@@ -7,6 +7,23 @@

  *		2 of the License, or (at your option) any later version.

  *

  * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

+ * 		YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>

+ */

+

+/* Andrew Beekhof, Lars Ellenberg:

+ * Based on arping from iputils,

+ * adapted to the command line conventions established by the libnet based

+ * send_arp tool as used by the IPaddr and IPaddr2 resource agents.

+ * The libnet based send_arp, and its command line argument convention,

+ * was first added to the heartbeat project by Matt Soffen.

+ *

+ * Latest "resync" with iputils as of:

+ *   git://git.linux-ipv6.org/gitroot/iputils.git

+ *   511f8356e22615479c3cc16bca64d72d204f6df3

+ *   Fri Jul 24 10:48:47 2015

+ * To get various bugfixes and support for infiniband and other link layer

+ * addresses which do not fit into plain "sockaddr_ll", and broadcast addresses

+ * that may be different from memset(,0xff,).

  */

 #include <stdlib.h>

@@ -16,12 +33,17 @@

 #include <sys/file.h>

 #include <sys/time.h>

 #include <sys/signal.h>

+#include <signal.h>

 #include <sys/ioctl.h>

-#include <linux/if.h>

+#include <net/if.h>

 #include <linux/if_packet.h>

 #include <linux/if_ether.h>

 #include <net/if_arp.h>

 #include <sys/uio.h>

+#ifdef CAPABILITIES

+#include <sys/prctl.h>

+#include <sys/capability.h>

+#endif

 #include <netdb.h>

 #include <unistd.h>

@@ -32,40 +54,85 @@

 #include <netinet/in.h>

 #include <arpa/inet.h>

-static void usage(void) __attribute__((noreturn));

+#ifdef USE_SYSFS

+#include <sysfs/libsysfs.h>

+struct sysfs_devattr_values;

+#endif

-static int quit_on_reply;

-static char *device;

-static int ifindex;

-static char *source;

-static struct in_addr src, dst;

-static char *target;

-static int dad = 0, unsolicited = 0, advert = 0;

-static int quiet = 0;

-static int count = -1;

-static int timeout = 0;

-static int unicasting = 0;

-static int s = 0;

-static int broadcast_only = 0;

+#ifndef WITHOUT_IFADDRS

+#include <ifaddrs.h>

+#endif

-static struct sockaddr_ll me;

-static struct sockaddr_ll he;

+#ifdef USE_IDN

+#include <idna.h>

+#include <locale.h>

+#endif

-static struct timeval start, last;

+static char SNAPSHOT[] = "s20121221";

-static int sent, brd_sent;

-static int received, brd_recv, req_recv;

+static void usage(void) __attribute__((noreturn));

+

+#ifndef DEFAULT_DEVICE

+#define DEFAULT_DEVICE "eth0"

+#endif

+#ifdef DEFAULT_DEVICE

+# define DEFAULT_DEVICE_STR	DEFAULT_DEVICE

+#else

+# define DEFAULT_DEVICE		NULL

+#endif

+

+struct device {

+	const char *name;

+	int ifindex;

+#ifndef WITHOUT_IFADDRS

+	struct ifaddrs *ifa;

+#endif

+#ifdef USE_SYSFS

+	struct sysfs_devattr_values *sysfs;

+#endif

+};

+

+int quit_on_reply=0;

+struct device device = {

+	.name = DEFAULT_DEVICE,

+};

+char *source;

+struct in_addr src, dst;

+char *target;

+int dad, unsolicited, advert;

+int quiet;

+int count=-1;

+int timeout;

+int unicasting;

+int s;

+int broadcast_only;

+

+struct sockaddr_storage me;

+struct sockaddr_storage he;

+

+struct timeval start, last;

+

+int sent, brd_sent;

+int received, brd_recv, req_recv;

+

+#ifndef CAPABILITIES

+static uid_t euid;

+#endif

 #define MS_TDIFF(tv1,tv2) ( ((tv1).tv_sec-(tv2).tv_sec)*1000 + \

 			   ((tv1).tv_usec-(tv2).tv_usec)/1000 )

-static void print_hex(unsigned char *p, int len);

-static int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM);

-static void set_signal(int signo, void (*handler)(void));

-static int send_pack(int s, struct in_addr src, struct in_addr dst,

-	      struct sockaddr_ll *ME, struct sockaddr_ll *HE);

-static void finish(void);

-static void catcher(void);

+#define OFFSET_OF(name,ele)	((size_t)&((name *)0)->ele)

+

+static socklen_t sll_len(size_t halen)

+{

+	socklen_t len = OFFSET_OF(struct sockaddr_ll, sll_addr) + halen;

+	if (len < sizeof(struct sockaddr_ll))

+		len = sizeof(struct sockaddr_ll);

+	return len;

+}

+

+#define SLL_LEN(hln)		sll_len(hln)

 void usage(void)

 {

@@ -80,14 +147,18 @@ void usage(void)

 		"  -V : print version and exit\n"

 		"  -c count : how many packets to send\n"

 		"  -w timeout : how long to wait for a reply\n"

-		"  -I device : which ethernet device to use (eth0)\n"

+		"  -I device : which ethernet device to use"

+#ifdef DEFAULT_DEVICE_STR

+			" (" DEFAULT_DEVICE_STR ")"

+#endif

+			"\n"

 		"  -s source : source ip address\n"

 		"  destination : ask for what ip address\n"

 		);

 	exit(2);

 }

-void set_signal(int signo, void (*handler)(void))

+static void set_signal(int signo, void (*handler)(void))

 {

 	struct sigaction sa;

@@ -97,7 +168,126 @@ void set_signal(int signo, void (*handler)(void))

 	sigaction(signo, &sa, NULL);

 }

-int send_pack(int s, struct in_addr src, struct in_addr dst,

+#ifdef CAPABILITIES

+static const cap_value_t caps[] = { CAP_NET_RAW, };

+static cap_flag_value_t cap_raw = CAP_CLEAR;

+#endif

+

+static void limit_capabilities(void)

+{

+#ifdef CAPABILITIES

+	cap_t cap_p;

+

+	cap_p = cap_get_proc();

+	if (!cap_p) {

+		perror("arping: cap_get_proc");

+		exit(-1);

+	}

+

+	cap_get_flag(cap_p, CAP_NET_RAW, CAP_PERMITTED, &cap_raw);

+

+	if (cap_raw != CAP_CLEAR) {

+		if (cap_clear(cap_p) < 0) {

+			perror("arping: cap_clear");

+			exit(-1);

+		}

+

+		cap_set_flag(cap_p, CAP_PERMITTED, 1, caps, CAP_SET);

+

+		if (cap_set_proc(cap_p) < 0) {

+			perror("arping: cap_set_proc");

+			if (errno != EPERM)

+				exit(-1);

+		}

+	}

+

+	if (prctl(PR_SET_KEEPCAPS, 1) < 0) {

+		perror("arping: prctl");

+		exit(-1);

+	}

+

+	if (setuid(getuid()) < 0) {

+		perror("arping: setuid");

+		exit(-1);

+	}

+

+	if (prctl(PR_SET_KEEPCAPS, 0) < 0) {

+		perror("arping: prctl");

+		exit(-1);

+	}

+

+	cap_free(cap_p);

+#else

+	euid = geteuid();

+#endif

+}

+

+static int modify_capability_raw(int on)

+{

+#ifdef CAPABILITIES

+	cap_t cap_p;

+

+	if (cap_raw != CAP_SET)

+		return on ? -1 : 0;

+

+	cap_p = cap_get_proc();

+	if (!cap_p) {

+		perror("arping: cap_get_proc");

+		return -1;

+	}

+

+	cap_set_flag(cap_p, CAP_EFFECTIVE, 1, caps, on ? CAP_SET : CAP_CLEAR);

+

+	if (cap_set_proc(cap_p) < 0) {

+		perror("arping: cap_set_proc");

+		return -1;

+	}

+

+	cap_free(cap_p);

+#else

+	if (setuid(on ? euid : getuid())) {

+		perror("arping: setuid");

+		return -1;

+	}

+#endif

+	return 0;

+}

+

+static int enable_capability_raw(void)

+{

+	return modify_capability_raw(1);

+}

+

+static int disable_capability_raw(void)

+{

+	return modify_capability_raw(0);

+}

+

+static void drop_capabilities(void)

+{

+#ifdef CAPABILITIES

+	cap_t cap_p = cap_init();

+

+	if (!cap_p) {

+		perror("arping: cap_init");

+		exit(-1);

+	}

+

+	if (cap_set_proc(cap_p) < 0) {

+		perror("arping: cap_set_proc");

+		exit(-1);

+	}

+

+	cap_free(cap_p);

+#else

+	if (setuid(getuid()) < 0) {

+		perror("arping: setuid");

+		exit(-1);

+	}

+#endif

+}

+

+static int send_pack(int s, struct in_addr src, struct in_addr dst,

 	      struct sockaddr_ll *ME, struct sockaddr_ll *HE)

 {

 	int err;

@@ -130,7 +320,7 @@ int send_pack(int s, struct in_addr src, struct in_addr dst,

 	p+=4;

 	gettimeofday(&now, NULL);

-	err = sendto(s, buf, p-buf, 0, (struct sockaddr*)HE, sizeof(*HE));

+	err = sendto(s, buf, p-buf, 0, (struct sockaddr*)HE, SLL_LEN(ah->ar_hln));

 	if (err == p-buf) {

 		last = now;

 		sent++;

@@ -140,7 +330,7 @@ int send_pack(int s, struct in_addr src, struct in_addr dst,

 	return err;

 }

-void finish(void)

+static void finish(void)

 {

 	if (!quiet) {

 		printf("Sent %d probes (%d broadcast(s))\n", sent, brd_sent);

@@ -158,40 +348,43 @@ void finish(void)

 		printf("\n");

 		fflush(stdout);

 	}

-

-	if (dad) {

-	    fflush(stdout);

-	    exit(!!received);

-	}

-	

+	fflush(stdout);

+	if (dad)

+		exit(!!received);

 	if (unsolicited)

 		exit(0);

-

-	fflush(stdout);

 	exit(!received);

 }

-void catcher(void)

+static void catcher(void)

 {

-	struct timeval tv;

+	struct timeval tv, tv_s, tv_o;

 	gettimeofday(&tv, NULL);

 	if (start.tv_sec==0)

 		start = tv;

-	if (count-- == 0 || (timeout && MS_TDIFF(tv,start) > timeout*1000 + 500))

+	timersub(&tv, &start, &tv_s);

+	tv_o.tv_sec = timeout;

+	tv_o.tv_usec = 500 * 1000;

+

+	if (count-- == 0 || (timeout && timercmp(&tv_s, &tv_o, >)))

 		finish();

-	if (last.tv_sec==0 || MS_TDIFF(tv,last) > 500) {

-		send_pack(s, src, dst, &me, &he);

+	timersub(&tv, &last, &tv_s);

+	tv_o.tv_sec = 0;

+

+	if (last.tv_sec==0 || timercmp(&tv_s, &tv_o, >)) {

+		send_pack(s, src, dst,

+			  (struct sockaddr_ll *)&me, (struct sockaddr_ll *)&he);

 		if (count == 0 && unsolicited)

 			finish();

 	}

 	alarm(1);

 }

-void print_hex(unsigned char *p, int len)

+static void print_hex(unsigned char *p, int len)

 {

 	int i;

 	for (i=0; i

@@ -201,7 +394,7 @@ void print_hex(unsigned char *p, int len)

 	}

 }

-int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

+static int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

 {

 	struct timeval tv;

 	struct arphdr *ah = (struct arphdr*)buf;

@@ -231,7 +424,7 @@ int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

 		return 0;

 	if (ah->ar_pln != 4)

 		return 0;

-	if (ah->ar_hln != me.sll_halen)

+	if (ah->ar_hln != ((struct sockaddr_ll *)&me)->sll_halen)

 		return 0;

 	if (len < sizeof(*ah) + 2*(4 + ah->ar_hln))

 		return 0;

@@ -242,7 +435,7 @@ int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

 			return 0;

 		if (src.s_addr != dst_ip.s_addr)

 			return 0;

-		if (memcmp(p+ah->ar_hln+4, &me.sll_addr, ah->ar_hln))

+		if (memcmp(p+ah->ar_hln+4, ((struct sockaddr_ll *)&me)->sll_addr, ah->ar_hln))

 			return 0;

 	} else {

 		/* DAD packet was:

@@ -260,7 +453,7 @@ int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

 		 */

 		if (src_ip.s_addr != dst.s_addr)

 			return 0;

-		if (memcmp(p, &me.sll_addr, me.sll_halen) == 0)

+		if (memcmp(p, ((struct sockaddr_ll *)&me)->sll_addr, ((struct sockaddr_ll *)&me)->sll_halen) == 0)

 			return 0;

 		if (src.s_addr && src.s_addr != dst_ip.s_addr)

 			return 0;

@@ -276,7 +469,7 @@ int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

 			printf("for %s ", inet_ntoa(dst_ip));

 			s_printed = 1;

 		}

-		if (memcmp(p+ah->ar_hln+4, me.sll_addr, ah->ar_hln)) {

+		if (memcmp(p+ah->ar_hln+4, ((struct sockaddr_ll *)&me)->sll_addr, ah->ar_hln)) {

 			if (!s_printed)

 				printf("for ");

 			printf("[");

@@ -299,16 +492,78 @@ int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)

 		brd_recv++;

 	if (ah->ar_op == htons(ARPOP_REQUEST))

 		req_recv++;

-	if (quit_on_reply)

+	if (quit_on_reply || (count == 0 && received == sent))

 		finish();

 	if(!broadcast_only) {

-		memcpy(he.sll_addr, p, me.sll_halen);

+		memcpy(((struct sockaddr_ll *)&he)->sll_addr, p, ((struct sockaddr_ll *)&me)->sll_halen);

 		unicasting=1;

 	}

 	return 1;

 }

-#include <signal.h>

+#ifdef USE_SYSFS

+union sysfs_devattr_value {

+	unsigned long	ulong;

+	void		*ptr;

+};

+

+enum {

+	SYSFS_DEVATTR_IFINDEX,

+	SYSFS_DEVATTR_FLAGS,

+	SYSFS_DEVATTR_ADDR_LEN,

+#if 0

+	SYSFS_DEVATTR_TYPE,

+	SYSFS_DEVATTR_ADDRESS,

+#endif

+	SYSFS_DEVATTR_BROADCAST,

+	SYSFS_DEVATTR_NUM

+};

+

+struct sysfs_devattr_values

+{

+	char *ifname;

+	union sysfs_devattr_value	value[SYSFS_DEVATTR_NUM];

+};

+

+static int sysfs_devattr_ulong_dec(char *ptr, struct sysfs_devattr_values *v, unsigned idx);

+static int sysfs_devattr_ulong_hex(char *ptr, struct sysfs_devattr_values *v, unsigned idx);

+static int sysfs_devattr_macaddr(char *ptr, struct sysfs_devattr_values *v, unsigned idx);

+

+struct sysfs_devattrs {

+	const char *name;

+	int (*handler)(char *ptr, struct sysfs_devattr_values *v, unsigned int idx);

+	int free;

+} sysfs_devattrs[SYSFS_DEVATTR_NUM] = {

+	[SYSFS_DEVATTR_IFINDEX] = {

+		.name		= "ifindex",

+		.handler	= sysfs_devattr_ulong_dec,

+	},

+	[SYSFS_DEVATTR_ADDR_LEN] = {

+		.name		= "addr_len",

+		.handler	= sysfs_devattr_ulong_dec,

+	},

+	[SYSFS_DEVATTR_FLAGS] = {

+		.name		= "flags",

+		.handler	= sysfs_devattr_ulong_hex,

+	},

+#if 0

+	[SYSFS_DEVATTR_TYPE] = {

+		.name		= "type",

+		.handler	= sysfs_devattr_ulong_dec,

+	},

+	[SYSFS_DEVATTR_ADDRESS] = {

+		.name		= "address",

+		.handler	= sysfs_devattr_macaddr,

+		.free		= 1,

+	},

+#endif

+	[SYSFS_DEVATTR_BROADCAST] = {

+		.name		= "broadcast",

+		.handler	= sysfs_devattr_macaddr,

+		.free		= 1,

+	},

+};

+#endif

 static void byebye(int nsig)

 {

@@ -317,26 +572,477 @@ static void byebye(int nsig)

     exit(nsig);

 }

+/*

+ * find_device()

+ *

+ * This function checks 1) if the device (if given) is okay for ARP,

+ * or 2) find fist appropriate device on the system.

+ *

+ * Return value:

+ *	>0	: Succeeded, and appropriate device not found.

+ *		  device.ifindex remains 0.

+ *	0	: Succeeded, and approptiate device found.

+ *		  device.ifindex is set.

+ *	<0	: Failed.  Support not found, or other

+ *		: system error.  Try other method.

+ *

+ * If an appropriate device found, it is recorded inside the

+ * "device" variable for later reference.

+ *

+ * We have several implementations for this.

+ *	by_ifaddrs():	requires getifaddr() in glibc, and rtnetlink in

+ *			kernel. default and recommended for recent systems.

+ *	by_sysfs():	requires libsysfs , and sysfs in kernel.

+ *	by_ioctl():	unable to list devices without ipv4 address; this

+ *			means, you need to supply the device name for

+ *			DAD purpose.

+ */

+/* Common check for ifa->ifa_flags */

+static int check_ifflags(unsigned int ifflags, int fatal)

+{

+	if (!(ifflags & IFF_UP)) {

+		if (fatal) {

+			if (!quiet)

+				printf("Interface \"%s\" is down\n", device.name);

+			exit(2);

+		}

+		return -1;

+	}

+	if (ifflags & (IFF_NOARP | IFF_LOOPBACK)) {

+		if (fatal) {

+			if (!quiet)

+				printf("Interface \"%s\" is not ARPable\n", device.name);

+			exit(dad ? 0 : 2);

+		}

+		return -1;

+	}

+	return 0;

+}

+

+static int find_device_by_ifaddrs(void)

+{

+#ifndef WITHOUT_IFADDRS

+	int rc;

+	struct ifaddrs *ifa0, *ifa;

+	int count = 0;

+

+	rc = getifaddrs(&ifa0);

+	if (rc) {

+		perror("getifaddrs");

+		return -1;

+	}

+

+	for (ifa = ifa0; ifa; ifa = ifa->ifa_next) {

+		if (!ifa->ifa_addr)

+			continue;

+		if (ifa->ifa_addr->sa_family != AF_PACKET)

+			continue;

+		if (device.name && ifa->ifa_name && strcmp(ifa->ifa_name, device.name))

+			continue;

+

+		if (check_ifflags(ifa->ifa_flags, device.name != NULL) < 0)

+			continue;

+

+		if (!((struct sockaddr_ll *)ifa->ifa_addr)->sll_halen)

+			continue;

+		if (!ifa->ifa_broadaddr)

+			continue;

+

+		device.ifa = ifa;

+

+		if (count++)

+			break;

+	}

+

+	if (count == 1 && device.ifa) {

+		device.ifindex = if_nametoindex(device.ifa->ifa_name);

+		if (!device.ifindex) {

+			perror("arping: if_nametoindex");

+			freeifaddrs(ifa0);

+			return -1;

+		}

+		device.name  = device.ifa->ifa_name;

+		return 0;

+	}

+	return 1;

+#else

+	return -1;

+#endif

+}

+

+#ifdef USE_SYSFS

+static void sysfs_devattr_values_init(struct sysfs_devattr_values *v, int do_free)

+{

+	int i;

+	if (do_free) {

+		free(v->ifname);

+		for (i = 0; i < SYSFS_DEVATTR_NUM; i++) {

+			if (sysfs_devattrs[i].free)

+				free(v->value[i].ptr);

+		}

+	}

+	memset(v, 0, sizeof(*v));

+}

+

+static int sysfs_devattr_ulong(char *ptr, struct sysfs_devattr_values *v, unsigned int idx,

+				     unsigned int base)

+{

+	unsigned long *p;

+	char *ep;

+

+	if (!ptr || !v)

+		return -1;

+

+	p = &v->value[idx].ulong;

+	errno = 0;

+	*p = strtoul(ptr, &ep, base);

+	if ((*ptr && isspace(*ptr & 0xff)) || errno || (*ep != '\0' && *ep != '\n'))

+		goto out;

+

+	return 0;

+out:

+	return -1;

+}

+

+static int sysfs_devattr_ulong_dec(char *ptr, struct sysfs_devattr_values *v, unsigned int idx)

+{

+	int rc = sysfs_devattr_ulong(ptr, v, idx, 10);

+	return rc;

+}

+

+static int sysfs_devattr_ulong_hex(char *ptr, struct sysfs_devattr_values *v, unsigned int idx)

+{

+	int rc = sysfs_devattr_ulong(ptr, v, idx, 16);

+	return rc;

+}

+

+static int sysfs_devattr_macaddr(char *ptr, struct sysfs_devattr_values *v, unsigned int idx)

+{

+	unsigned char *m;

+	int i;

+	unsigned int addrlen;

+

+	if (!ptr || !v)

+		return -1;

+

+	addrlen = v->value[SYSFS_DEVATTR_ADDR_LEN].ulong;

+	m = malloc(addrlen);

+

+	for (i = 0; i < addrlen; i++) {

+		if (i && *(ptr + i * 3 - 1) != ':')

+			goto out;

+		if (sscanf(ptr + i * 3, "%02hhx", &m[i]) != 1)

+			goto out;

+	}

+

+	v->value[idx].ptr = m;

+	return 0;

+out:

+	free(m);

+	return -1;

+}

+#endif

+

+static int find_device_by_sysfs(void)

+{

+	int rc = -1;

+#ifdef USE_SYSFS

+	struct sysfs_class *cls_net;

+	struct dlist *dev_list;

+	struct sysfs_class_device *dev;

+	struct sysfs_attribute *dev_attr;

+	struct sysfs_devattr_values sysfs_devattr_values;

+	int count = 0;

+

+	if (!device.sysfs) {

+		device.sysfs = malloc(sizeof(*device.sysfs));

+		sysfs_devattr_values_init(device.sysfs, 0);

+	}

+

+	cls_net = sysfs_open_class("net");

+	if (!cls_net) {

+		perror("sysfs_open_class");

+		return -1;

+	}

+

+	dev_list = sysfs_get_class_devices(cls_net);

+	if (!dev_list) {

+		perror("sysfs_get_class_devices");

+		goto out;

+	}

+

+	sysfs_devattr_values_init(&sysfs_devattr_values, 0);

+

+	dlist_for_each_data(dev_list, dev, struct sysfs_class_device) {

+		int i;

+		int rc = -1;