1 /*
2 * dhcpcd - DHCP client daemon
3 * Copyright 2006-2008 Roy Marples <roy@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 <sys/types.h>
29 #include <sys/ioctl.h>
30 #include <sys/socket.h>
31 #include <sys/time.h>
32
33 #include <net/if.h>
34 #include <net/if_arp.h>
35 #include <arpa/inet.h>
36 #include <netinet/in_systm.h>
37 #ifdef __linux__
38 #include <netinet/ether.h>
39 #include <netpacket/packet.h>
40 #endif
41 #include <netinet/in.h>
42 #include <netinet/ip.h>
43 #define __FAVOR_BSD /* Nasty glibc hack so we can use BSD semantics for UDP */
44 #include <netinet/udp.h>
45 #undef __FAVOR_BSD
46 #ifdef SIOCGIFMEDIA
47 #include <net/if_media.h>
48 #endif
49 #include <arpa/inet.h>
50 #ifdef AF_LINK
51 # include <net/if_dl.h>
52 #endif
53
54 #include <ctype.h>
55 #include <errno.h>
56 #include <stddef.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <string.h>
60 #include <unistd.h>
61
62 #include "config.h"
63 #include "common.h"
64 #include "dhcp.h"
65 #include "logger.h"
66 #include "net.h"
67 #include "signals.h"
68
69 int
inet_ntocidr(struct in_addr address)70 inet_ntocidr(struct in_addr address)
71 {
72 int cidr = 0;
73 uint32_t mask = htonl(address.s_addr);
74
75 while (mask) {
76 cidr++;
77 mask <<= 1;
78 }
79
80 return cidr;
81 }
82
83 int
inet_cidrtoaddr(int cidr,struct in_addr * addr)84 inet_cidrtoaddr(int cidr, struct in_addr *addr)
85 {
86 int ocets;
87
88 if (cidr < 0 || cidr > 32) {
89 errno = EINVAL;
90 return -1;
91 }
92 ocets = (cidr + 7) / 8;
93
94 addr->s_addr = 0;
95 if (ocets > 0) {
96 memset(&addr->s_addr, 255, (size_t)ocets - 1);
97 memset((unsigned char *)&addr->s_addr + (ocets - 1),
98 (256 - (1 << (32 - cidr) % 8)), 1);
99 }
100
101 return 0;
102 }
103
104 uint32_t
get_netmask(uint32_t addr)105 get_netmask(uint32_t addr)
106 {
107 uint32_t dst;
108
109 if (addr == 0)
110 return 0;
111
112 dst = htonl(addr);
113 if (IN_CLASSA(dst))
114 return ntohl(IN_CLASSA_NET);
115 if (IN_CLASSB (dst))
116 return ntohl(IN_CLASSB_NET);
117 if (IN_CLASSC (dst))
118 return ntohl(IN_CLASSC_NET);
119
120 return 0;
121 }
122
123 char *
hwaddr_ntoa(const unsigned char * hwaddr,size_t hwlen)124 hwaddr_ntoa(const unsigned char *hwaddr, size_t hwlen)
125 {
126 static char buffer[(HWADDR_LEN * 3) + 1];
127 char *p = buffer;
128 size_t i;
129
130 for (i = 0; i < hwlen && i < HWADDR_LEN; i++) {
131 if (i > 0)
132 *p ++= ':';
133 p += snprintf(p, 3, "%.2x", hwaddr[i]);
134 }
135
136 *p ++= '\0';
137
138 return buffer;
139 }
140
141 size_t
hwaddr_aton(unsigned char * buffer,const char * addr)142 hwaddr_aton(unsigned char *buffer, const char *addr)
143 {
144 char c[3];
145 const char *p = addr;
146 unsigned char *bp = buffer;
147 size_t len = 0;
148
149 c[2] = '\0';
150 while (*p) {
151 c[0] = *p++;
152 c[1] = *p++;
153 /* Ensure that digits are hex */
154 if (isxdigit((unsigned char)c[0]) == 0 ||
155 isxdigit((unsigned char)c[1]) == 0)
156 {
157 errno = EINVAL;
158 return 0;
159 }
160 /* We should have at least two entries 00:01 */
161 if (len == 0 && *p == '\0') {
162 errno = EINVAL;
163 return 0;
164 }
165 /* Ensure that next data is EOL or a seperator with data */
166 if (!(*p == '\0' || (*p == ':' && *(p + 1) != '\0'))) {
167 errno = EINVAL;
168 return 0;
169 }
170 if (*p)
171 p++;
172 if (bp)
173 *bp++ = (unsigned char)strtol(c, NULL, 16);
174 len++;
175 }
176 return len;
177 }
178
179 int
do_interface(const char * ifname,_unused unsigned char * hwaddr,_unused size_t * hwlen,struct in_addr * addr,struct in_addr * net,int get)180 do_interface(const char *ifname,
181 _unused unsigned char *hwaddr, _unused size_t *hwlen,
182 struct in_addr *addr, struct in_addr *net, int get)
183 {
184 int s;
185 struct ifconf ifc;
186 int retval = 0, found = 0;
187 int len = 10 * sizeof(struct ifreq);
188 int lastlen = 0;
189 char *p;
190 union {
191 char *buffer;
192 struct ifreq *ifr;
193 } ifreqs;
194 struct sockaddr_in address;
195 struct ifreq *ifr;
196 struct sockaddr_in netmask;
197 #ifdef AF_LINK
198 struct sockaddr_dl *sdl;
199 #endif
200
201 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
202 return -1;
203
204 /* Not all implementations return the needed buffer size for
205 * SIOGIFCONF so we loop like so for all until it works */
206 memset(&ifc, 0, sizeof(ifc));
207 for (;;) {
208 ifc.ifc_len = len;
209 ifc.ifc_buf = xmalloc((size_t)len);
210 if (ioctl(s, SIOCGIFCONF, &ifc) == -1) {
211 if (errno != EINVAL || lastlen != 0) {
212 close(s);
213 free(ifc.ifc_buf);
214 return -1;
215 }
216 } else {
217 if (ifc.ifc_len == lastlen)
218 break;
219 lastlen = ifc.ifc_len;
220 }
221
222 free(ifc.ifc_buf);
223 ifc.ifc_buf = NULL;
224 len *= 2;
225 }
226
227 for (p = (char *)ifc.ifc_buf; p < (char *)ifc.ifc_buf + ifc.ifc_len;) {
228 /* Cast the ifc buffer to an ifreq cleanly */
229 ifreqs.buffer = p;
230 ifr = ifreqs.ifr;
231
232 #ifndef __linux__
233 if (ifr->ifr_addr.sa_len > sizeof(ifr->ifr_ifru))
234 p += offsetof(struct ifreq, ifr_ifru) +
235 ifr->ifr_addr.sa_len;
236 else
237 #endif
238 p += sizeof(*ifr);
239
240 if (strcmp(ifname, ifr->ifr_name) != 0)
241 continue;
242
243 found = 1;
244
245 #ifdef AF_LINK
246 if (hwaddr && hwlen && ifr->ifr_addr.sa_family == AF_LINK) {
247 sdl = xmalloc(ifr->ifr_addr.sa_len);
248 memcpy(sdl, &ifr->ifr_addr, ifr->ifr_addr.sa_len);
249 *hwlen = sdl->sdl_alen;
250 memcpy(hwaddr, LLADDR(sdl), *hwlen);
251 free(sdl);
252 retval = 1;
253 break;
254 }
255 #endif
256
257 if (ifr->ifr_addr.sa_family == AF_INET) {
258 memcpy(&address, &ifr->ifr_addr, sizeof(address));
259 if (ioctl(s, SIOCGIFNETMASK, ifr) == -1)
260 continue;
261 memcpy(&netmask, &ifr->ifr_addr, sizeof(netmask));
262 if (get) {
263 addr->s_addr = address.sin_addr.s_addr;
264 net->s_addr = netmask.sin_addr.s_addr;
265 retval = 1;
266 break;
267 } else {
268 if (address.sin_addr.s_addr == addr->s_addr &&
269 (!net ||
270 netmask.sin_addr.s_addr == net->s_addr))
271 {
272 retval = 1;
273 break;
274 }
275 }
276 }
277
278 }
279
280 if (!found)
281 errno = ENXIO;
282 close(s);
283 free(ifc.ifc_buf);
284 return retval;
285 }
286
287 int
up_interface(const char * ifname)288 up_interface(const char *ifname)
289 {
290 int s;
291 struct ifreq ifr;
292 int retval = -1;
293 #ifdef __linux__
294 char *p;
295 #endif
296
297 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
298 return -1;
299 memset(&ifr, 0, sizeof(ifr));
300 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
301 #ifdef __linux__
302 /* We can only bring the real interface up */
303 if ((p = strchr(ifr.ifr_name, ':')))
304 *p = '\0';
305 #endif
306 if (ioctl(s, SIOCGIFFLAGS, &ifr) == 0) {
307 if ((ifr.ifr_flags & IFF_UP))
308 retval = 0;
309 else {
310 ifr.ifr_flags |= IFF_UP;
311 if (ioctl(s, SIOCSIFFLAGS, &ifr) == 0)
312 retval = 0;
313 }
314 }
315 close(s);
316 return retval;
317 }
318
319 int
carrier_status(const char * ifname)320 carrier_status(const char *ifname)
321 {
322 int s;
323 struct ifreq ifr;
324 int retval = -1;
325 #ifdef SIOCGIFMEDIA
326 struct ifmediareq ifmr;
327 #endif
328 #ifdef __linux__
329 char *p;
330 #endif
331
332 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
333 return -1;
334 memset(&ifr, 0, sizeof(ifr));
335 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
336 #ifdef __linux__
337 /* We can only test the real interface up */
338 if ((p = strchr(ifr.ifr_name, ':')))
339 *p = '\0';
340 #endif
341 if ((retval = ioctl(s, SIOCGIFFLAGS, &ifr)) == 0) {
342 if (ifr.ifr_flags & IFF_UP && ifr.ifr_flags & IFF_RUNNING)
343 retval = 1;
344 else
345 retval = 0;
346 }
347
348 #ifdef SIOCGIFMEDIA
349 if (retval == 1) {
350 memset(&ifmr, 0, sizeof(ifmr));
351 strncpy(ifmr.ifm_name, ifr.ifr_name, sizeof(ifmr.ifm_name));
352 if (ioctl(s, SIOCGIFMEDIA, &ifmr) != -1 &&
353 ifmr.ifm_status & IFM_AVALID)
354 {
355 if (!(ifmr.ifm_status & IFM_ACTIVE))
356 retval = 0;
357 }
358 }
359 #endif
360 close(s);
361 return retval;
362 }
363
364 struct interface *
read_interface(const char * ifname,_unused int metric)365 read_interface(const char *ifname, _unused int metric)
366 {
367 int s;
368 struct ifreq ifr;
369 struct interface *iface = NULL;
370 unsigned char *hwaddr = NULL;
371 size_t hwlen = 0;
372 sa_family_t family = 0;
373
374 memset(&ifr, 0, sizeof(ifr));
375 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
376
377 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
378 return NULL;
379
380 #ifdef __linux__
381 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
382 if (ioctl(s, SIOCGIFHWADDR, &ifr) == -1)
383 goto eexit;
384
385 switch (ifr.ifr_hwaddr.sa_family) {
386 case ARPHRD_ETHER:
387 case ARPHRD_IEEE802:
388 hwlen = ETHER_ADDR_LEN;
389 break;
390 case ARPHRD_IEEE1394:
391 hwlen = EUI64_ADDR_LEN;
392 case ARPHRD_INFINIBAND:
393 hwlen = INFINIBAND_ADDR_LEN;
394 break;
395 }
396
397 hwaddr = xmalloc(sizeof(unsigned char) * HWADDR_LEN);
398 memcpy(hwaddr, ifr.ifr_hwaddr.sa_data, hwlen);
399 family = ifr.ifr_hwaddr.sa_family;
400 #else
401 ifr.ifr_metric = metric;
402 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
403 if (ioctl(s, SIOCSIFMETRIC, &ifr) == -1)
404 goto eexit;
405
406 hwaddr = xmalloc(sizeof(unsigned char) * HWADDR_LEN);
407 if (do_interface(ifname, hwaddr, &hwlen, NULL, NULL, 0) != 1)
408 goto eexit;
409
410 family = ARPHRD_ETHER;
411 #endif
412
413 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
414 if (ioctl(s, SIOCGIFMTU, &ifr) == -1)
415 goto eexit;
416
417 /* Ensure that the MTU is big enough for DHCP */
418 if (ifr.ifr_mtu < MTU_MIN) {
419 ifr.ifr_mtu = MTU_MIN;
420 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
421 if (ioctl(s, SIOCSIFMTU, &ifr) == -1)
422 goto eexit;
423 }
424
425 if (up_interface(ifname) != 0)
426 goto eexit;
427
428 iface = xzalloc(sizeof(*iface));
429 strlcpy(iface->name, ifname, IF_NAMESIZE);
430 snprintf(iface->leasefile, PATH_MAX, LEASEFILE, ifname);
431 memcpy(&iface->hwaddr, hwaddr, hwlen);
432 iface->hwlen = hwlen;
433
434 iface->family = family;
435 iface->arpable = !(ifr.ifr_flags & (IFF_NOARP | IFF_LOOPBACK));
436
437 /* 0 is a valid fd, so init to -1 */
438 iface->raw_fd = -1;
439 iface->udp_fd = -1;
440 iface->arp_fd = -1;
441 iface->link_fd = -1;
442
443 eexit:
444 close(s);
445 free(hwaddr);
446 return iface;
447 }
448
449 int
do_mtu(const char * ifname,short int mtu)450 do_mtu(const char *ifname, short int mtu)
451 {
452 struct ifreq ifr;
453 int r;
454 int s;
455
456 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
457 return -1;
458
459 memset(&ifr, 0, sizeof(ifr));
460 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
461 ifr.ifr_mtu = mtu;
462 r = ioctl(s, mtu ? SIOCSIFMTU : SIOCGIFMTU, &ifr);
463 close(s);
464 if (r == -1)
465 return -1;
466 return ifr.ifr_mtu;
467 }
468
469 void
free_routes(struct rt * routes)470 free_routes(struct rt *routes)
471 {
472 struct rt *r;
473
474 while (routes) {
475 r = routes->next;
476 free(routes);
477 routes = r;
478 }
479 }
480
481 int
open_udp_socket(struct interface * iface)482 open_udp_socket(struct interface *iface)
483 {
484 int s;
485 union sockunion {
486 struct sockaddr sa;
487 struct sockaddr_in sin;
488 } su;
489 int n;
490 #ifdef SO_BINDTODEVICE
491 struct ifreq ifr;
492 #endif
493
494 if ((s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
495 return -1;
496
497 n = 1;
498 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1)
499 goto eexit;
500 #ifdef SO_BINDTODEVICE
501 memset(&ifr, 0, sizeof(ifr));
502 strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
503 if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) == -1)
504 goto eexit;
505 #endif
506 /* As we don't use this socket for receiving, set the
507 * receive buffer to 1 */
508 n = 1;
509 if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n)) == -1)
510 goto eexit;
511 memset(&su, 0, sizeof(su));
512 su.sin.sin_family = AF_INET;
513 su.sin.sin_port = htons(DHCP_CLIENT_PORT);
514 su.sin.sin_addr.s_addr = iface->addr.s_addr;
515 if (bind(s, &su.sa, sizeof(su)) == -1)
516 goto eexit;
517
518 iface->udp_fd = s;
519 set_cloexec(s);
520 return 0;
521
522 eexit:
523 close(s);
524 return -1;
525 }
526
527 ssize_t
send_packet(const struct interface * iface,struct in_addr to,const uint8_t * data,ssize_t len)528 send_packet(const struct interface *iface, struct in_addr to,
529 const uint8_t *data, ssize_t len)
530 {
531 union sockunion {
532 struct sockaddr sa;
533 struct sockaddr_in sin;
534 } su;
535
536 memset(&su, 0, sizeof(su));
537 su.sin.sin_family = AF_INET;
538 su.sin.sin_addr.s_addr = to.s_addr;
539 su.sin.sin_port = htons(DHCP_SERVER_PORT);
540
541 return sendto(iface->udp_fd, data, len, 0, &su.sa, sizeof(su));
542 }
543
544 struct udp_dhcp_packet
545 {
546 struct ip ip;
547 struct udphdr udp;
548 struct dhcp_message dhcp;
549 };
550 const size_t udp_dhcp_len = sizeof(struct udp_dhcp_packet);
551
552 static uint16_t
checksum(const void * data,uint16_t len)553 checksum(const void *data, uint16_t len)
554 {
555 const uint8_t *addr = data;
556 uint32_t sum = 0;
557
558 while (len > 1) {
559 sum += addr[0] * 256 + addr[1];
560 addr += 2;
561 len -= 2;
562 }
563
564 if (len == 1)
565 sum += *addr * 256;
566
567 sum = (sum >> 16) + (sum & 0xffff);
568 sum += (sum >> 16);
569
570 sum = htons(sum);
571
572 return ~sum;
573 }
574
575 ssize_t
make_udp_packet(uint8_t ** packet,const uint8_t * data,size_t length,struct in_addr source,struct in_addr dest)576 make_udp_packet(uint8_t **packet, const uint8_t *data, size_t length,
577 struct in_addr source, struct in_addr dest)
578 {
579 struct udp_dhcp_packet *udpp;
580 struct ip *ip;
581 struct udphdr *udp;
582
583 udpp = xzalloc(sizeof(*udpp));
584 ip = &udpp->ip;
585 udp = &udpp->udp;
586
587 /* OK, this is important :)
588 * We copy the data to our packet and then create a small part of the
589 * ip structure and an invalid ip_len (basically udp length).
590 * We then fill the udp structure and put the checksum
591 * of the whole packet into the udp checksum.
592 * Finally we complete the ip structure and ip checksum.
593 * If we don't do the ordering like so then the udp checksum will be
594 * broken, so find another way of doing it! */
595
596 memcpy(&udpp->dhcp, data, length);
597
598 ip->ip_p = IPPROTO_UDP;
599 ip->ip_src.s_addr = source.s_addr;
600 if (dest.s_addr == 0)
601 ip->ip_dst.s_addr = INADDR_BROADCAST;
602 else
603 ip->ip_dst.s_addr = dest.s_addr;
604
605 udp->uh_sport = htons(DHCP_CLIENT_PORT);
606 udp->uh_dport = htons(DHCP_SERVER_PORT);
607 udp->uh_ulen = htons(sizeof(*udp) + length);
608 ip->ip_len = udp->uh_ulen;
609 udp->uh_sum = checksum(udpp, sizeof(*udpp));
610
611 ip->ip_v = IPVERSION;
612 ip->ip_hl = 5;
613 ip->ip_id = 0;
614 ip->ip_tos = IPTOS_LOWDELAY;
615 ip->ip_len = htons (sizeof(*ip) + sizeof(*udp) + length);
616 ip->ip_id = 0;
617 ip->ip_off = htons(IP_DF); /* Don't fragment */
618 ip->ip_ttl = IPDEFTTL;
619
620 ip->ip_sum = checksum(ip, sizeof(*ip));
621
622 *packet = (uint8_t *)udpp;
623 return sizeof(*ip) + sizeof(*udp) + length;
624 }
625
626 ssize_t
get_udp_data(const uint8_t ** data,const uint8_t * udp)627 get_udp_data(const uint8_t **data, const uint8_t *udp)
628 {
629 struct udp_dhcp_packet packet;
630
631 memcpy(&packet, udp, sizeof(packet));
632 *data = udp + offsetof(struct udp_dhcp_packet, dhcp);
633 return ntohs(packet.ip.ip_len) - sizeof(packet.ip) - sizeof(packet.udp);
634 }
635
636 int
valid_udp_packet(const uint8_t * data)637 valid_udp_packet(const uint8_t *data)
638 {
639 struct udp_dhcp_packet packet;
640 uint16_t bytes;
641 uint16_t ipsum;
642 uint16_t iplen;
643 uint16_t udpsum;
644 struct in_addr source;
645 struct in_addr dest;
646 int retval = 0;
647
648 memcpy(&packet, data, sizeof(packet));
649 bytes = ntohs(packet.ip.ip_len);
650 ipsum = packet.ip.ip_sum;
651 iplen = packet.ip.ip_len;
652 udpsum = packet.udp.uh_sum;
653
654 if (0 != checksum(&packet.ip, sizeof(packet.ip))) {
655 errno = EINVAL;
656 return -1;
657 }
658
659 packet.ip.ip_sum = 0;
660 memcpy(&source, &packet.ip.ip_src, sizeof(packet.ip.ip_src));
661 memcpy(&dest, &packet.ip.ip_dst, sizeof(packet.ip.ip_dst));
662 memset(&packet.ip, 0, sizeof(packet.ip));
663 packet.udp.uh_sum = 0;
664
665 packet.ip.ip_p = IPPROTO_UDP;
666 memcpy(&packet.ip.ip_src, &source, sizeof(packet.ip.ip_src));
667 memcpy(&packet.ip.ip_dst, &dest, sizeof(packet.ip.ip_dst));
668 packet.ip.ip_len = packet.udp.uh_ulen;
669 if (udpsum && udpsum != checksum(&packet, bytes)) {
670 errno = EINVAL;
671 retval = -1;
672 }
673
674 return retval;
675 }
676
677 int
send_arp(const struct interface * iface,int op,in_addr_t sip,in_addr_t tip)678 send_arp(const struct interface *iface, int op, in_addr_t sip, in_addr_t tip)
679 {
680 struct arphdr *arp;
681 size_t arpsize;
682 uint8_t *p;
683 int retval;
684
685 arpsize = sizeof(*arp) + 2 * iface->hwlen + 2 * sizeof(sip);
686 arp = xmalloc(arpsize);
687 arp->ar_hrd = htons(iface->family);
688 arp->ar_pro = htons(ETHERTYPE_IP);
689 arp->ar_hln = iface->hwlen;
690 arp->ar_pln = sizeof(sip);
691 arp->ar_op = htons(op);
692 p = (uint8_t *)arp;
693 p += sizeof(*arp);
694 memcpy(p, iface->hwaddr, iface->hwlen);
695 p += iface->hwlen;
696 memcpy(p, &sip, sizeof(sip));
697 p += sizeof(sip);
698 /* ARP requests should ignore this */
699 retval = iface->hwlen;
700 while (retval--)
701 *p++ = '\0';
702 memcpy(p, &tip, sizeof(tip));
703 p += sizeof(tip);
704 retval = send_raw_packet(iface, ETHERTYPE_ARP, arp, arpsize);
705 free(arp);
706 return retval;
707 }
708