1/*
2 * dhcpcd - DHCP client daemon
3 * Copyright (c) 2006-2011 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/param.h>
31#include <sys/socket.h>
32#include <sys/time.h>
33
34#include <arpa/inet.h>
35#include <net/if.h>
36#include <net/if_arp.h>
37#ifdef AF_LINK
38#  include <net/if_dl.h>
39#  include <net/if_types.h>
40#endif
41#include <netinet/in_systm.h>
42#include <netinet/in.h>
43#include <netinet/ip.h>
44#define __FAVOR_BSD /* Nasty glibc hack so we can use BSD semantics for UDP */
45#include <netinet/udp.h>
46#undef __FAVOR_BSD
47#ifdef AF_PACKET
48#  include <netpacket/packet.h>
49#endif
50#ifdef SIOCGIFMEDIA
51#  include <net/if_media.h>
52#endif
53
54#include <ctype.h>
55#include <errno.h>
56#include <ifaddrs.h>
57#include <fnmatch.h>
58#include <stddef.h>
59#include <stdio.h>
60#include <stdlib.h>
61#include <string.h>
62#include <syslog.h>
63#include <unistd.h>
64
65#include "config.h"
66#include "common.h"
67#include "dhcp.h"
68#include "if-options.h"
69#include "ipv6rs.h"
70#include "net.h"
71#include "signals.h"
72
73static char hwaddr_buffer[(HWADDR_LEN * 3) + 1];
74
75int socket_afnet = -1;
76
77#if defined(__FreeBSD__) && defined(DEBUG_MEMORY)
78/* FreeBSD does not zero the struct, causing valgrind errors */
79unsigned int
80if_nametoindex(const char *ifname)
81{
82	struct ifreq ifr;
83
84	memset(&ifr, 0, sizeof(ifr));
85	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
86	if (ioctl(socket_afnet, SIOCGIFINDEX, &ifr) != -1)
87		return ifr.ifr_index;
88	return 0;
89}
90#endif
91
92int
93inet_ntocidr(struct in_addr address)
94{
95	int cidr = 0;
96	uint32_t mask = htonl(address.s_addr);
97
98	while (mask) {
99		cidr++;
100		mask <<= 1;
101	}
102	return cidr;
103}
104
105int
106inet_cidrtoaddr(int cidr, struct in_addr *addr)
107{
108	int ocets;
109
110	if (cidr < 1 || cidr > 32) {
111		errno = EINVAL;
112		return -1;
113	}
114	ocets = (cidr + 7) / 8;
115
116	addr->s_addr = 0;
117	if (ocets > 0) {
118		memset(&addr->s_addr, 255, (size_t)ocets - 1);
119		memset((unsigned char *)&addr->s_addr + (ocets - 1),
120		    (256 - (1 << (32 - cidr) % 8)), 1);
121	}
122
123	return 0;
124}
125
126uint32_t
127get_netmask(uint32_t addr)
128{
129	uint32_t dst;
130
131	if (addr == 0)
132		return 0;
133
134	dst = htonl(addr);
135	if (IN_CLASSA(dst))
136		return ntohl(IN_CLASSA_NET);
137	if (IN_CLASSB(dst))
138		return ntohl(IN_CLASSB_NET);
139	if (IN_CLASSC(dst))
140		return ntohl(IN_CLASSC_NET);
141
142	return 0;
143}
144
145char *
146hwaddr_ntoa(const unsigned char *hwaddr, size_t hwlen)
147{
148	char *p = hwaddr_buffer;
149	size_t i;
150
151	for (i = 0; i < hwlen && i < HWADDR_LEN; i++) {
152		if (i > 0)
153			*p ++= ':';
154		p += snprintf(p, 3, "%.2x", hwaddr[i]);
155	}
156
157	*p ++= '\0';
158
159	return hwaddr_buffer;
160}
161
162size_t
163hwaddr_aton(unsigned char *buffer, const char *addr)
164{
165	char c[3];
166	const char *p = addr;
167	unsigned char *bp = buffer;
168	size_t len = 0;
169
170	c[2] = '\0';
171	while (*p) {
172		c[0] = *p++;
173		c[1] = *p++;
174		/* Ensure that digits are hex */
175		if (isxdigit((unsigned char)c[0]) == 0 ||
176		    isxdigit((unsigned char)c[1]) == 0)
177		{
178			errno = EINVAL;
179			return 0;
180		}
181		/* We should have at least two entries 00:01 */
182		if (len == 0 && *p == '\0') {
183			errno = EINVAL;
184			return 0;
185		}
186		/* Ensure that next data is EOL or a seperator with data */
187		if (!(*p == '\0' || (*p == ':' && *(p + 1) != '\0'))) {
188			errno = EINVAL;
189			return 0;
190		}
191		if (*p)
192			p++;
193		if (bp)
194			*bp++ = (unsigned char)strtol(c, NULL, 16);
195		len++;
196	}
197	return len;
198}
199
200struct interface *
201init_interface(const char *ifname)
202{
203	struct ifreq ifr;
204	struct interface *iface = NULL;
205
206	memset(&ifr, 0, sizeof(ifr));
207	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
208	if (ioctl(socket_afnet, SIOCGIFFLAGS, &ifr) == -1)
209		goto eexit;
210
211	iface = xzalloc(sizeof(*iface));
212	strlcpy(iface->name, ifname, sizeof(iface->name));
213	iface->flags = ifr.ifr_flags;
214	/* We reserve the 100 range for virtual interfaces, if and when
215	 * we can work them out. */
216	iface->metric = 200 + if_nametoindex(iface->name);
217	if (getifssid(ifname, iface->ssid) != -1) {
218		iface->wireless = 1;
219		iface->metric += 100;
220	}
221
222	if (ioctl(socket_afnet, SIOCGIFMTU, &ifr) == -1)
223		goto eexit;
224	/* Ensure that the MTU is big enough for DHCP */
225	if (ifr.ifr_mtu < MTU_MIN) {
226		ifr.ifr_mtu = MTU_MIN;
227		strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
228		if (ioctl(socket_afnet, SIOCSIFMTU, &ifr) == -1)
229			goto eexit;
230	}
231
232	snprintf(iface->leasefile, sizeof(iface->leasefile),
233	    LEASEFILE, ifname);
234	/* 0 is a valid fd, so init to -1 */
235	iface->raw_fd = -1;
236	iface->udp_fd = -1;
237	iface->arp_fd = -1;
238	goto exit;
239
240eexit:
241	free(iface);
242	iface = NULL;
243exit:
244	return iface;
245}
246
247void
248free_interface(struct interface *iface)
249{
250	if (!iface)
251		return;
252	ipv6rs_free(iface);
253	if (iface->state) {
254		free_options(iface->state->options);
255		free(iface->state->old);
256		free(iface->state->new);
257		free(iface->state->offer);
258		free(iface->state);
259	}
260	free(iface->buffer);
261	free(iface->clientid);
262	free(iface);
263}
264
265int
266carrier_status(struct interface *iface)
267{
268	int ret;
269	struct ifreq ifr;
270#ifdef SIOCGIFMEDIA
271	struct ifmediareq ifmr;
272#endif
273#ifdef __linux__
274	char *p;
275#endif
276
277	memset(&ifr, 0, sizeof(ifr));
278	strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
279#ifdef __linux__
280	/* We can only test the real interface up */
281	if ((p = strchr(ifr.ifr_name, ':')))
282		*p = '\0';
283#endif
284
285	if (ioctl(socket_afnet, SIOCGIFFLAGS, &ifr) == -1)
286		return -1;
287	iface->flags = ifr.ifr_flags;
288
289	ret = -1;
290#ifdef SIOCGIFMEDIA
291	memset(&ifmr, 0, sizeof(ifmr));
292	strlcpy(ifmr.ifm_name, iface->name, sizeof(ifmr.ifm_name));
293	if (ioctl(socket_afnet, SIOCGIFMEDIA, &ifmr) != -1 &&
294	    ifmr.ifm_status & IFM_AVALID)
295		ret = (ifmr.ifm_status & IFM_ACTIVE) ? 1 : 0;
296#endif
297	if (ret == -1)
298		ret = (ifr.ifr_flags & IFF_RUNNING) ? 1 : 0;
299	return ret;
300}
301
302int
303up_interface(struct interface *iface)
304{
305	struct ifreq ifr;
306	int retval = -1;
307#ifdef __linux__
308	char *p;
309#endif
310
311	memset(&ifr, 0, sizeof(ifr));
312	strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
313#ifdef __linux__
314	/* We can only bring the real interface up */
315	if ((p = strchr(ifr.ifr_name, ':')))
316		*p = '\0';
317#endif
318	if (ioctl(socket_afnet, SIOCGIFFLAGS, &ifr) == 0) {
319		if ((ifr.ifr_flags & IFF_UP))
320			retval = 0;
321		else {
322			ifr.ifr_flags |= IFF_UP;
323			if (ioctl(socket_afnet, SIOCSIFFLAGS, &ifr) == 0)
324				retval = 0;
325		}
326		iface->flags = ifr.ifr_flags;
327	}
328	return retval;
329}
330
331struct interface *
332discover_interfaces(int argc, char * const *argv)
333{
334	struct ifaddrs *ifaddrs, *ifa;
335	char *p;
336	int i, sdl_type;
337	struct interface *ifp, *ifs, *ifl;
338#ifdef __linux__
339	char ifn[IF_NAMESIZE];
340#endif
341#ifdef AF_LINK
342	const struct sockaddr_dl *sdl;
343#ifdef IFLR_ACTIVE
344	struct if_laddrreq iflr;
345	int socket_aflink;
346
347	socket_aflink = socket(AF_LINK, SOCK_DGRAM, 0);
348	if (socket_aflink == -1)
349		return NULL;
350	memset(&iflr, 0, sizeof(iflr));
351#endif
352#elif AF_PACKET
353	const struct sockaddr_ll *sll;
354#endif
355
356	if (getifaddrs(&ifaddrs) == -1)
357		return NULL;
358
359	ifs = ifl = NULL;
360	for (ifa = ifaddrs; ifa; ifa = ifa->ifa_next) {
361		if (ifa->ifa_addr != NULL) {
362#ifdef AF_LINK
363			if (ifa->ifa_addr->sa_family != AF_LINK)
364				continue;
365#elif AF_PACKET
366			if (ifa->ifa_addr->sa_family != AF_PACKET)
367				continue;
368#endif
369		}
370
371		/* It's possible for an interface to have >1 AF_LINK.
372		 * For our purposes, we use the first one. */
373		for (ifp = ifs; ifp; ifp = ifp->next)
374			if (strcmp(ifp->name, ifa->ifa_name) == 0)
375				break;
376		if (ifp)
377			continue;
378		if (argc > 0) {
379			for (i = 0; i < argc; i++) {
380#ifdef __linux__
381				/* Check the real interface name */
382				strlcpy(ifn, argv[i], sizeof(ifn));
383				p = strchr(ifn, ':');
384				if (p)
385					*p = '\0';
386				if (strcmp(ifn, ifa->ifa_name) == 0)
387					break;
388#else
389				if (strcmp(argv[i], ifa->ifa_name) == 0)
390					break;
391#endif
392			}
393			if (i == argc)
394				continue;
395			p = argv[i];
396		} else {
397			/* -1 means we're discovering against a specific
398			 * interface, but we still need the below rules
399			 * to apply. */
400			if (argc == -1 && strcmp(argv[0], ifa->ifa_name) != 0)
401				continue;
402			for (i = 0; i < ifdc; i++)
403				if (!fnmatch(ifdv[i], ifa->ifa_name, 0))
404					break;
405			if (i < ifdc)
406				continue;
407			for (i = 0; i < ifac; i++)
408				if (!fnmatch(ifav[i], ifa->ifa_name, 0))
409					break;
410			if (ifac && i == ifac)
411				continue;
412			p = ifa->ifa_name;
413		}
414		if ((ifp = init_interface(p)) == NULL)
415			continue;
416
417		/* Bring the interface up if not already */
418		if (!(ifp->flags & IFF_UP)
419#ifdef SIOCGIFMEDIA
420		    && carrier_status(ifp) != -1
421#endif
422		   )
423		{
424			if (up_interface(ifp) == 0)
425				options |= DHCPCD_WAITUP;
426			else
427				syslog(LOG_ERR, "%s: up_interface: %m", ifp->name);
428		}
429
430		sdl_type = 0;
431		/* Don't allow loopback unless explicit */
432		if (ifp->flags & IFF_LOOPBACK) {
433			if (argc == 0 && ifac == 0) {
434				free_interface(ifp);
435				continue;
436			}
437		} else if (ifa->ifa_addr != NULL) {
438#ifdef AF_LINK
439			sdl = (const struct sockaddr_dl *)(void *)ifa->ifa_addr;
440
441#ifdef IFLR_ACTIVE
442			/* We need to check for active address */
443			strlcpy(iflr.iflr_name, ifp->name,
444			    sizeof(iflr.iflr_name));
445			memcpy(&iflr.addr, ifa->ifa_addr,
446			    MIN(ifa->ifa_addr->sa_len, sizeof(iflr.addr)));
447			iflr.flags = IFLR_PREFIX;
448			iflr.prefixlen = sdl->sdl_alen * NBBY;
449			if (ioctl(socket_aflink, SIOCGLIFADDR, &iflr) == -1 ||
450			    !(iflr.flags & IFLR_ACTIVE))
451			{
452				free_interface(ifp);
453				continue;
454			}
455#endif
456
457			sdl_type = sdl->sdl_type;
458			switch(sdl->sdl_type) {
459			case IFT_BRIDGE: /* FALLTHROUGH */
460			case IFT_L2VLAN: /* FALLTHOUGH */
461			case IFT_L3IPVLAN: /* FALLTHROUGH */
462			case IFT_ETHER:
463				ifp->family = ARPHRD_ETHER;
464				break;
465			case IFT_IEEE1394:
466				ifp->family = ARPHRD_IEEE1394;
467				break;
468#ifdef IFT_INFINIBAND
469			case IFT_INFINIBAND:
470				ifp->family = ARPHRD_INFINIBAND;
471				break;
472#endif
473			}
474			ifp->hwlen = sdl->sdl_alen;
475#ifndef CLLADDR
476#  define CLLADDR(s) ((const char *)((s)->sdl_data + (s)->sdl_nlen))
477#endif
478			memcpy(ifp->hwaddr, CLLADDR(sdl), ifp->hwlen);
479#elif AF_PACKET
480			sll = (const struct sockaddr_ll *)(void *)ifa->ifa_addr;
481			ifp->family = sdl_type = sll->sll_hatype;
482			ifp->hwlen = sll->sll_halen;
483			if (ifp->hwlen != 0)
484				memcpy(ifp->hwaddr, sll->sll_addr, ifp->hwlen);
485#endif
486		}
487
488		/* We only work on ethernet by default */
489		if (!(ifp->flags & IFF_POINTOPOINT) &&
490		    ifp->family != ARPHRD_ETHER)
491		{
492			if (argc == 0 && ifac == 0) {
493				free_interface(ifp);
494				continue;
495			}
496			switch (ifp->family) {
497			case ARPHRD_IEEE1394: /* FALLTHROUGH */
498			case ARPHRD_INFINIBAND:
499				/* We don't warn for supported families */
500				break;
501			default:
502				syslog(LOG_WARNING,
503				    "%s: unsupported interface type %.2x"
504				    ", falling back to ethernet",
505				    ifp->name, sdl_type);
506				ifp->family = ARPHRD_ETHER;
507				break;
508			}
509		}
510
511		/* Handle any platform init for the interface */
512		if (if_init(ifp) == -1) {
513			syslog(LOG_ERR, "%s: if_init: %m", p);
514			free_interface(ifp);
515			continue;
516		}
517
518		if (ifl)
519			ifl->next = ifp;
520		else
521			ifs = ifp;
522		ifl = ifp;
523	}
524	freeifaddrs(ifaddrs);
525
526#ifdef IFLR_ACTIVE
527	close(socket_aflink);
528#endif
529
530	return ifs;
531}
532
533int
534do_address(const char *ifname,
535    struct in_addr *addr, struct in_addr *net, struct in_addr *dst, int act)
536{
537	struct ifaddrs *ifaddrs, *ifa;
538	const struct sockaddr_in *a, *n, *d;
539	int retval;
540
541	if (getifaddrs(&ifaddrs) == -1)
542		return -1;
543
544	retval = 0;
545	for (ifa = ifaddrs; ifa; ifa = ifa->ifa_next) {
546		if (ifa->ifa_addr == NULL ||
547		    ifa->ifa_addr->sa_family != AF_INET ||
548		    strcmp(ifa->ifa_name, ifname) != 0)
549			continue;
550		a = (const struct sockaddr_in *)(void *)ifa->ifa_addr;
551		n = (const struct sockaddr_in *)(void *)ifa->ifa_netmask;
552		if (ifa->ifa_flags & IFF_POINTOPOINT)
553			d = (const struct sockaddr_in *)(void *)
554			    ifa->ifa_dstaddr;
555		else
556			d = NULL;
557		if (act == 1) {
558			addr->s_addr = a->sin_addr.s_addr;
559			net->s_addr = n->sin_addr.s_addr;
560			if (dst) {
561				/* TODO: Fix getifaddrs() */
562				if ((ifa->ifa_flags & IFF_POINTOPOINT) && d)
563					dst->s_addr = d->sin_addr.s_addr;
564				else
565					dst->s_addr = INADDR_ANY;
566			}
567			retval = 1;
568			break;
569		}
570		if (addr->s_addr == a->sin_addr.s_addr &&
571		    (net == NULL || net->s_addr == n->sin_addr.s_addr))
572		{
573			retval = 1;
574			break;
575		}
576	}
577	freeifaddrs(ifaddrs);
578	return retval;
579}
580
581int
582do_mtu(const char *ifname, short int mtu)
583{
584	struct ifreq ifr;
585	int r;
586
587	memset(&ifr, 0, sizeof(ifr));
588	strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
589	ifr.ifr_mtu = mtu;
590	r = ioctl(socket_afnet, mtu ? SIOCSIFMTU : SIOCGIFMTU, &ifr);
591	if (r == -1)
592		return -1;
593	return ifr.ifr_mtu;
594}
595
596void
597free_routes(struct rt *routes)
598{
599	struct rt *r;
600
601	while (routes) {
602		r = routes->next;
603		free(routes);
604		routes = r;
605	}
606}
607
608int
609open_udp_socket(struct interface *iface)
610{
611	int s;
612	struct sockaddr_in sin;
613	int n;
614#ifdef SO_BINDTODEVICE
615	struct ifreq ifr;
616	char *p;
617#endif
618
619	if ((s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
620		return -1;
621
622	n = 1;
623	if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1)
624		goto eexit;
625#ifdef SO_BINDTODEVICE
626	memset(&ifr, 0, sizeof(ifr));
627	strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
628	/* We can only bind to the real device */
629	p = strchr(ifr.ifr_name, ':');
630	if (p)
631		*p = '\0';
632	if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, &ifr,
633		sizeof(ifr)) == -1)
634		goto eexit;
635#endif
636	/* As we don't use this socket for receiving, set the
637	 * receive buffer to 1 */
638	n = 1;
639	if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n)) == -1)
640		goto eexit;
641	memset(&sin, 0, sizeof(sin));
642	sin.sin_family = AF_INET;
643	sin.sin_port = htons(DHCP_CLIENT_PORT);
644	sin.sin_addr.s_addr = iface->addr.s_addr;
645	if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) == -1)
646		goto eexit;
647
648	iface->udp_fd = s;
649	set_cloexec(s);
650	return 0;
651
652eexit:
653	close(s);
654	return -1;
655}
656
657ssize_t
658send_packet(const struct interface *iface, struct in_addr to,
659    const uint8_t *data, ssize_t len)
660{
661	struct sockaddr_in sin;
662
663	memset(&sin, 0, sizeof(sin));
664	sin.sin_family = AF_INET;
665	sin.sin_addr.s_addr = to.s_addr;
666	sin.sin_port = htons(DHCP_SERVER_PORT);
667	return sendto(iface->udp_fd, data, len, 0,
668	    (struct sockaddr *)&sin, sizeof(sin));
669}
670
671struct udp_dhcp_packet
672{
673	struct ip ip;
674	struct udphdr udp;
675	struct dhcp_message dhcp;
676};
677const size_t udp_dhcp_len = sizeof(struct udp_dhcp_packet);
678
679static uint16_t
680checksum(const void *data, uint16_t len)
681{
682	const uint8_t *addr = data;
683	uint32_t sum = 0;
684
685	while (len > 1) {
686		sum += addr[0] * 256 + addr[1];
687		addr += 2;
688		len -= 2;
689	}
690
691	if (len == 1)
692		sum += *addr * 256;
693
694	sum = (sum >> 16) + (sum & 0xffff);
695	sum += (sum >> 16);
696
697	sum = htons(sum);
698
699	return ~sum;
700}
701
702ssize_t
703make_udp_packet(uint8_t **packet, const uint8_t *data, size_t length,
704    struct in_addr source, struct in_addr dest)
705{
706	struct udp_dhcp_packet *udpp;
707	struct ip *ip;
708	struct udphdr *udp;
709
710	udpp = xzalloc(sizeof(*udpp));
711	ip = &udpp->ip;
712	udp = &udpp->udp;
713
714	/* OK, this is important :)
715	 * We copy the data to our packet and then create a small part of the
716	 * ip structure and an invalid ip_len (basically udp length).
717	 * We then fill the udp structure and put the checksum
718	 * of the whole packet into the udp checksum.
719	 * Finally we complete the ip structure and ip checksum.
720	 * If we don't do the ordering like so then the udp checksum will be
721	 * broken, so find another way of doing it! */
722
723	memcpy(&udpp->dhcp, data, length);
724
725	ip->ip_p = IPPROTO_UDP;
726	ip->ip_src.s_addr = source.s_addr;
727	if (dest.s_addr == 0)
728		ip->ip_dst.s_addr = INADDR_BROADCAST;
729	else
730		ip->ip_dst.s_addr = dest.s_addr;
731
732	udp->uh_sport = htons(DHCP_CLIENT_PORT);
733	udp->uh_dport = htons(DHCP_SERVER_PORT);
734	udp->uh_ulen = htons(sizeof(*udp) + length);
735	ip->ip_len = udp->uh_ulen;
736	udp->uh_sum = checksum(udpp, sizeof(*udpp));
737
738	ip->ip_v = IPVERSION;
739	ip->ip_hl = sizeof(*ip) >> 2;
740	ip->ip_id = arc4random() & UINT16_MAX;
741	ip->ip_ttl = IPDEFTTL;
742	ip->ip_len = htons(sizeof(*ip) + sizeof(*udp) + length);
743	ip->ip_sum = checksum(ip, sizeof(*ip));
744
745	*packet = (uint8_t *)udpp;
746	return sizeof(*ip) + sizeof(*udp) + length;
747}
748
749ssize_t
750get_udp_data(const uint8_t **data, const uint8_t *udp)
751{
752	struct udp_dhcp_packet packet;
753
754	memcpy(&packet, udp, sizeof(packet));
755	*data = udp + offsetof(struct udp_dhcp_packet, dhcp);
756	return ntohs(packet.ip.ip_len) -
757	    sizeof(packet.ip) -
758	    sizeof(packet.udp);
759}
760
761int
762valid_udp_packet(const uint8_t *data, size_t data_len, struct in_addr *from,
763    int noudpcsum)
764{
765	struct udp_dhcp_packet packet;
766	uint16_t bytes, udpsum;
767
768	if (data_len < sizeof(packet.ip)) {
769		if (from)
770			from->s_addr = INADDR_ANY;
771		errno = EINVAL;
772		return -1;
773	}
774	memcpy(&packet, data, MIN(data_len, sizeof(packet)));
775	if (from)
776		from->s_addr = packet.ip.ip_src.s_addr;
777	if (data_len > sizeof(packet)) {
778		errno = EINVAL;
779		return -1;
780	}
781	if (checksum(&packet.ip, sizeof(packet.ip)) != 0) {
782		errno = EINVAL;
783		return -1;
784	}
785
786	bytes = ntohs(packet.ip.ip_len);
787	if (data_len < bytes) {
788		errno = EINVAL;
789		return -1;
790	}
791
792	if (noudpcsum == 0) {
793		udpsum = packet.udp.uh_sum;
794		packet.udp.uh_sum = 0;
795		packet.ip.ip_hl = 0;
796		packet.ip.ip_v = 0;
797		packet.ip.ip_tos = 0;
798		packet.ip.ip_len = packet.udp.uh_ulen;
799		packet.ip.ip_id = 0;
800		packet.ip.ip_off = 0;
801		packet.ip.ip_ttl = 0;
802		packet.ip.ip_sum = 0;
803		if (udpsum && checksum(&packet, bytes) != udpsum) {
804			errno = EINVAL;
805			return -1;
806		}
807	}
808
809	return 0;
810}
811