1 /* SPDX-License-Identifier: BSD-2-Clause */
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2019 Roy Marples <roy@marples.name>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/param.h>
30 #include <sys/socket.h>
33 #include <arpa/inet.h>
35 #include <net/route.h>
36 #include <netinet/if_ether.h>
37 #include <netinet/in_systm.h>
38 #include <netinet/in.h>
39 #include <netinet/ip.h>
40 #define __FAVOR_BSD /* Nasty glibc hack so we can use BSD semantics for UDP */
41 #include <netinet/udp.h>
63 #include "dhcp-common.h"
73 #define DAD "Duplicate address detected"
74 #define DHCP_MIN_LEASE 20
76 #define IPV4A ADDRIPV4 | ARRAY
77 #define IPV4R ADDRIPV4 | REQUEST
79 /* We should define a maximum for the NAK exponential backoff */
82 /* Wait N nanoseconds between sending a RELEASE and dropping the address.
83 * This gives the kernel enough time to actually send it. */
84 #define RELEASE_DELAY_S 0
85 #define RELEASE_DELAY_NS 10000000
88 #define IPDEFTTL 64 /* RFC1340 */
91 /* Support older systems with different defines */
92 #if !defined(IP_RECVPKTINFO) && defined(IP_PKTINFO)
93 #define IP_RECVPKTINFO IP_PKTINFO
96 /* Assert the correct structure size for on wire */
97 __CTASSERT(sizeof(struct ip
) == 20);
98 __CTASSERT(sizeof(struct udphdr
) == 8);
99 __CTASSERT(sizeof(struct bootp
) == 300);
106 static const struct dhcp_op dhcp_ops
[] = {
107 { DHCP_DISCOVER
, "DISCOVER" },
108 { DHCP_OFFER
, "OFFER" },
109 { DHCP_REQUEST
, "REQUEST" },
110 { DHCP_DECLINE
, "DECLINE" },
113 { DHCP_RELEASE
, "RELEASE" },
114 { DHCP_INFORM
, "INFORM" },
115 { DHCP_FORCERENEW
, "FORCERENEW"},
119 static const char * const dhcp_params
[] = {
128 static int dhcp_openbpf(struct interface
*);
129 static void dhcp_start1(void *);
130 #if defined(ARP) && (!defined(KERNEL_RFC5227) || defined(ARPING))
131 static void dhcp_arp_found(struct arp_state
*, const struct arp_msg
*);
133 static void dhcp_handledhcp(struct interface
*, struct bootp
*, size_t,
134 const struct in_addr
*);
136 static void dhcp_handleifudp(void *);
138 static int dhcp_initstate(struct interface
*);
141 dhcp_printoptions(const struct dhcpcd_ctx
*ctx
,
142 const struct dhcp_opt
*opts
, size_t opts_len
)
144 const char * const *p
;
146 const struct dhcp_opt
*opt
, *opt2
;
149 for (p
= dhcp_params
; *p
; p
++)
152 for (i
= 0, opt
= ctx
->dhcp_opts
; i
< ctx
->dhcp_opts_len
; i
++, opt
++) {
153 for (j
= 0, opt2
= opts
; j
< opts_len
; j
++, opt2
++)
154 if (opt
->option
== opt2
->option
)
157 cols
= printf("%03d %s", opt
->option
, opt
->var
);
158 dhcp_print_option_encoding(opt
, cols
);
161 for (i
= 0, opt
= opts
; i
< opts_len
; i
++, opt
++) {
162 cols
= printf("%03d %s", opt
->option
, opt
->var
);
163 dhcp_print_option_encoding(opt
, cols
);
167 #define get_option_raw(ctx, bootp, bootp_len, opt) \
168 get_option((ctx), (bootp), (bootp_len), NULL)
169 static const uint8_t *
170 get_option(struct dhcpcd_ctx
*ctx
,
171 const struct bootp
*bootp
, size_t bootp_len
,
172 unsigned int opt
, size_t *opt_len
)
174 const uint8_t *p
, *e
;
175 uint8_t l
, o
, ol
, overl
, *bp
;
179 /* Check we have the magic cookie */
180 if (!IS_DHCP(bootp
)) {
185 p
= bootp
->vend
+ 4; /* options after the 4 byte cookie */
186 e
= (const uint8_t *)bootp
+ bootp_len
;
195 /* No length to read */
199 /* bit 1 set means parse boot file */
200 overl
= (uint8_t)(overl
& ~1);
202 e
= p
+ sizeof(bootp
->file
);
203 } else if (overl
& 2) {
204 /* bit 2 set means parse server name */
205 overl
= (uint8_t)(overl
& ~2);
207 e
= p
+ sizeof(bootp
->sname
);
210 /* No length to read */
214 /* Check we can read the length */
221 /* Check we can read the option data, if present */
227 if (o
== DHO_OPTSOVERLOADED
) {
228 /* Ensure we only get this option once by setting
229 * the last bit as well as the value.
230 * This is valid because only the first two bits
231 * actually mean anything in RFC2132 Section 9.3 */
232 if (l
== 1 && !overl
)
238 /* We must concatonate the options. */
239 if (bl
+ l
> ctx
->opt_buffer_len
) {
245 (bp
- ctx
->opt_buffer
);
248 nb
= realloc(ctx
->opt_buffer
, bl
+ l
);
251 ctx
->opt_buffer
= nb
;
252 ctx
->opt_buffer_len
= bl
+ l
;
253 bp
= ctx
->opt_buffer
+ pos
;
256 bp
= ctx
->opt_buffer
;
272 return (const uint8_t *)ctx
->opt_buffer
;
281 get_option_addr(struct dhcpcd_ctx
*ctx
,
282 struct in_addr
*a
, const struct bootp
*bootp
, size_t bootp_len
,
288 p
= get_option(ctx
, bootp
, bootp_len
, option
, &len
);
289 if (!p
|| len
< (ssize_t
)sizeof(a
->s_addr
))
291 memcpy(&a
->s_addr
, p
, sizeof(a
->s_addr
));
296 get_option_uint32(struct dhcpcd_ctx
*ctx
,
297 uint32_t *i
, const struct bootp
*bootp
, size_t bootp_len
, uint8_t option
)
303 p
= get_option(ctx
, bootp
, bootp_len
, option
, &len
);
304 if (!p
|| len
< (ssize_t
)sizeof(d
))
306 memcpy(&d
, p
, sizeof(d
));
313 get_option_uint16(struct dhcpcd_ctx
*ctx
,
314 uint16_t *i
, const struct bootp
*bootp
, size_t bootp_len
, uint8_t option
)
320 p
= get_option(ctx
, bootp
, bootp_len
, option
, &len
);
321 if (!p
|| len
< (ssize_t
)sizeof(d
))
323 memcpy(&d
, p
, sizeof(d
));
330 get_option_uint8(struct dhcpcd_ctx
*ctx
,
331 uint8_t *i
, const struct bootp
*bootp
, size_t bootp_len
, uint8_t option
)
336 p
= get_option(ctx
, bootp
, bootp_len
, option
, &len
);
337 if (!p
|| len
< (ssize_t
)sizeof(*p
))
345 print_rfc3442(FILE *fp
, const uint8_t *data
, size_t data_len
)
347 const uint8_t *p
= data
, *e
;
352 /* Minimum is 5 -first is CIDR and a router length of 4 */
361 if (fputc(' ', fp
) == EOF
)
369 ocets
= (size_t)(cidr
+ 7) / NBBY
;
370 if (p
+ 4 + ocets
> e
) {
374 /* If we have ocets then we have a destination and netmask */
377 memcpy(&addr
.s_addr
, p
, ocets
);
380 if (fprintf(fp
, "%s/%d", inet_ntoa(addr
), cidr
) == -1)
383 /* Finally, snag the router */
384 memcpy(&addr
.s_addr
, p
, 4);
386 if (fprintf(fp
, " %s", inet_ntoa(addr
)) == -1)
390 if (fputc('\0', fp
) == EOF
)
396 decode_rfc3442_rt(rb_tree_t
*routes
, struct interface
*ifp
,
397 const uint8_t *data
, size_t dl
, const struct bootp
*bootp
)
399 const uint8_t *p
= data
;
403 struct rt
*rt
= NULL
;
404 struct in_addr dest
, netmask
, gateway
;
407 /* Minimum is 5 -first is CIDR and a router length of 4 */
422 ocets
= (size_t)(cidr
+ 7) / NBBY
;
423 if (p
+ 4 + ocets
> e
) {
428 if ((rt
= rt_new(ifp
)) == NULL
)
431 /* If we have ocets then we have a destination and netmask */
434 memcpy(&dest
.s_addr
, p
, ocets
);
436 netmask
.s_addr
= htonl(~0U << (32 - cidr
));
440 /* Finally, snag the router */
441 memcpy(&gateway
.s_addr
, p
, 4);
444 /* An on-link host route is normally set by having the
445 * gateway match the destination or assigned address */
446 if (gateway
.s_addr
== dest
.s_addr
||
447 (gateway
.s_addr
== bootp
->yiaddr
||
448 gateway
.s_addr
== bootp
->ciaddr
))
450 gateway
.s_addr
= INADDR_ANY
;
451 netmask
.s_addr
= INADDR_BROADCAST
;
453 if (netmask
.s_addr
== INADDR_BROADCAST
)
454 rt
->rt_flags
= RTF_HOST
;
456 sa_in_init(&rt
->rt_dest
, &dest
);
457 sa_in_init(&rt
->rt_netmask
, &netmask
);
458 sa_in_init(&rt
->rt_gateway
, &gateway
);
459 if (rt_proto_add(routes
, rt
))
466 print_rfc3361(FILE *fp
, const uint8_t *data
, size_t dl
)
469 char sip
[NS_MAXDNAME
];
481 if (decode_rfc1035(sip
, sizeof(sip
), data
, dl
) == -1)
483 if (efprintf(fp
, "%s", sip
) == -1)
487 if (dl
== 0 || dl
% 4 != 0) {
491 addr
.s_addr
= INADDR_BROADCAST
;
494 data
+= sizeof(addr
.s_addr
), dl
-= sizeof(addr
.s_addr
))
496 memcpy(&addr
.s_addr
, data
, sizeof(addr
.s_addr
));
497 if (fprintf(fp
, "%s", inet_ntoa(addr
)) == -1)
500 if (fputc(' ', fp
) == EOF
)
504 if (fputc('\0', fp
) == EOF
)
516 get_option_string(struct dhcpcd_ctx
*ctx
,
517 const struct bootp
*bootp
, size_t bootp_len
, uint8_t option
)
523 p
= get_option(ctx
, bootp
, bootp_len
, option
, &len
);
524 if (!p
|| len
== 0 || *p
== '\0')
527 s
= malloc(sizeof(char) * (len
+ 1));
535 /* This calculates the netmask that we should use for static routes.
536 * This IS different from the calculation used to calculate the netmask
537 * for an interface address. */
539 route_netmask(uint32_t ip_in
)
541 /* used to be unsigned long - check if error */
542 uint32_t p
= ntohl(ip_in
);
564 /* We need to obey routing options.
565 * If we have a CSR then we only use that.
566 * Otherwise we add static routes and then routers. */
568 get_option_routes(rb_tree_t
*routes
, struct interface
*ifp
,
569 const struct bootp
*bootp
, size_t bootp_len
)
571 struct if_options
*ifo
= ifp
->options
;
574 struct rt
*rt
= NULL
;
575 struct in_addr dest
, netmask
, gateway
;
577 const char *csr
= "";
580 /* If we have CSR's then we MUST use these only */
581 if (!has_option_mask(ifo
->nomask
, DHO_CSR
))
582 p
= get_option(ifp
->ctx
, bootp
, bootp_len
, DHO_CSR
, &len
);
585 /* Check for crappy MS option */
586 if (!p
&& !has_option_mask(ifo
->nomask
, DHO_MSCSR
)) {
587 p
= get_option(ifp
->ctx
, bootp
, bootp_len
, DHO_MSCSR
, &len
);
591 if (p
&& (n
= decode_rfc3442_rt(routes
, ifp
, p
, len
, bootp
)) != -1) {
592 const struct dhcp_state
*state
;
594 state
= D_CSTATE(ifp
);
595 if (!(ifo
->options
& DHCPCD_CSR_WARNED
) &&
596 !(state
->added
& STATE_FAKE
))
598 logdebugx("%s: using %sClassless Static Routes",
600 ifo
->options
|= DHCPCD_CSR_WARNED
;
606 /* OK, get our static routes first. */
607 if (!has_option_mask(ifo
->nomask
, DHO_STATICROUTE
))
608 p
= get_option(ifp
->ctx
, bootp
, bootp_len
,
609 DHO_STATICROUTE
, &len
);
612 /* RFC 2131 Section 5.8 states length MUST be in multiples of 8 */
613 if (p
&& len
% 8 == 0) {
616 memcpy(&dest
.s_addr
, p
, sizeof(dest
.s_addr
));
618 memcpy(&gateway
.s_addr
, p
, sizeof(gateway
.s_addr
));
620 /* RFC 2131 Section 5.8 states default route is
622 if (gateway
.s_addr
== INADDR_ANY
)
624 if ((rt
= rt_new(ifp
)) == NULL
)
627 /* A on-link host route is normally set by having the
628 * gateway match the destination or assigned address */
629 if (gateway
.s_addr
== dest
.s_addr
||
630 (gateway
.s_addr
== bootp
->yiaddr
||
631 gateway
.s_addr
== bootp
->ciaddr
))
633 gateway
.s_addr
= INADDR_ANY
;
634 netmask
.s_addr
= INADDR_BROADCAST
;
636 netmask
.s_addr
= route_netmask(dest
.s_addr
);
637 if (netmask
.s_addr
== INADDR_BROADCAST
)
638 rt
->rt_flags
= RTF_HOST
;
640 sa_in_init(&rt
->rt_dest
, &dest
);
641 sa_in_init(&rt
->rt_netmask
, &netmask
);
642 sa_in_init(&rt
->rt_gateway
, &gateway
);
643 if (rt_proto_add(routes
, rt
))
648 /* Now grab our routers */
649 if (!has_option_mask(ifo
->nomask
, DHO_ROUTER
))
650 p
= get_option(ifp
->ctx
, bootp
, bootp_len
, DHO_ROUTER
, &len
);
653 if (p
&& len
% 4 == 0) {
655 dest
.s_addr
= INADDR_ANY
;
656 netmask
.s_addr
= INADDR_ANY
;
658 if ((rt
= rt_new(ifp
)) == NULL
)
660 memcpy(&gateway
.s_addr
, p
, sizeof(gateway
.s_addr
));
662 sa_in_init(&rt
->rt_dest
, &dest
);
663 sa_in_init(&rt
->rt_netmask
, &netmask
);
664 sa_in_init(&rt
->rt_gateway
, &gateway
);
665 if (rt_proto_add(routes
, rt
))
674 dhcp_get_mtu(const struct interface
*ifp
)
676 const struct dhcp_state
*state
;
679 if (ifp
->options
->mtu
)
680 return (uint16_t)ifp
->options
->mtu
;
681 mtu
= 0; /* bogus gcc warning */
682 if ((state
= D_CSTATE(ifp
)) == NULL
||
683 has_option_mask(ifp
->options
->nomask
, DHO_MTU
) ||
684 get_option_uint16(ifp
->ctx
, &mtu
,
685 state
->new, state
->new_len
, DHO_MTU
) == -1)
690 /* Grab our routers from the DHCP message and apply any MTU value
691 * the message contains */
693 dhcp_get_routes(rb_tree_t
*routes
, struct interface
*ifp
)
695 const struct dhcp_state
*state
;
697 if ((state
= D_CSTATE(ifp
)) == NULL
|| !(state
->added
& STATE_ADDED
))
699 return get_option_routes(routes
, ifp
, state
->new, state
->new_len
);
702 /* Assumes DHCP options */
704 dhcp_message_add_addr(struct bootp
*bootp
,
705 uint8_t type
, struct in_addr addr
)
711 while (*p
!= DHO_END
) {
716 len
= (size_t)(p
- bootp
->vend
);
717 if (len
+ 6 > sizeof(bootp
->vend
)) {
724 memcpy(p
, &addr
.s_addr
, 4);
731 make_message(struct bootp
**bootpm
, const struct interface
*ifp
, uint8_t type
)
735 uint8_t *n_params
= NULL
;
739 const struct dhcp_opt
*opt
;
740 struct if_options
*ifo
= ifp
->options
;
741 const struct dhcp_state
*state
= D_CSTATE(ifp
);
742 const struct dhcp_lease
*lease
= &state
->lease
;
743 char hbuf
[HOSTNAME_MAX_LEN
+ 1];
744 const char *hostname
;
745 const struct vivco
*vivco
;
748 uint8_t *auth
, auth_len
;
751 if ((mtu
= if_getmtu(ifp
)) == -1)
752 logerr("%s: if_getmtu", ifp
->name
);
753 else if (mtu
< MTU_MIN
) {
754 if (if_setmtu(ifp
, MTU_MIN
) == -1)
755 logerr("%s: if_setmtu", ifp
->name
);
759 if (ifo
->options
& DHCPCD_BOOTP
)
760 bootp
= calloc(1, sizeof (*bootp
));
762 /* Make the maximal message we could send */
763 bootp
= calloc(1, (size_t)(mtu
- IP_UDP_SIZE
));
769 if (state
->addr
!= NULL
&&
770 (type
== DHCP_INFORM
|| type
== DHCP_RELEASE
||
771 (type
== DHCP_REQUEST
&&
772 state
->addr
->mask
.s_addr
== lease
->mask
.s_addr
&&
773 (state
->new == NULL
|| IS_DHCP(state
->new)) &&
774 !(state
->added
& STATE_FAKE
))))
775 bootp
->ciaddr
= state
->addr
->addr
.s_addr
;
777 bootp
->op
= BOOTREQUEST
;
778 bootp
->htype
= (uint8_t)ifp
->family
;
779 switch (ifp
->family
) {
782 bootp
->hlen
= (uint8_t)ifp
->hwlen
;
783 memcpy(&bootp
->chaddr
, &ifp
->hwaddr
, ifp
->hwlen
);
787 if (ifo
->options
& DHCPCD_BROADCAST
&&
788 bootp
->ciaddr
== 0 &&
789 type
!= DHCP_DECLINE
&&
790 type
!= DHCP_RELEASE
)
791 bootp
->flags
= htons(BROADCAST_FLAG
);
793 if (type
!= DHCP_DECLINE
&& type
!= DHCP_RELEASE
) {
796 clock_gettime(CLOCK_MONOTONIC
, &tv
);
797 timespecsub(&tv
, &state
->started
, &tv
);
798 if (tv
.tv_sec
< 0 || tv
.tv_sec
> (time_t)UINT16_MAX
)
799 bootp
->secs
= htons((uint16_t)UINT16_MAX
);
801 bootp
->secs
= htons((uint16_t)tv
.tv_sec
);
804 bootp
->xid
= htonl(state
->xid
);
806 if (ifo
->options
& DHCPCD_BOOTP
)
807 return sizeof(*bootp
);
810 e
= (uint8_t *)bootp
+ (mtu
- IP_UDP_SIZE
) - 1; /* -1 for DHO_END */
812 ul
= htonl(MAGIC_COOKIE
);
813 memcpy(p
, &ul
, sizeof(ul
));
816 *p
++ = DHO_MESSAGETYPE
;
820 #define AREA_LEFT (size_t)(e - p)
821 #define AREA_FIT(s) if ((s) > AREA_LEFT) goto toobig
822 #define AREA_CHECK(s) if ((s) + 2UL > AREA_LEFT) goto toobig
823 #define PUT_ADDR(o, a) do { \
827 memcpy(p, &(a)->s_addr, 4); \
829 } while (0 /* CONSTCOND */)
831 if (state
->clientid
) {
832 AREA_CHECK(state
->clientid
[0]);
834 memcpy(p
, state
->clientid
, (size_t)state
->clientid
[0] + 1);
835 p
+= state
->clientid
[0] + 1;
838 if (lease
->addr
.s_addr
&& lease
->cookie
== htonl(MAGIC_COOKIE
)) {
839 if (type
== DHCP_DECLINE
||
840 (type
== DHCP_REQUEST
&&
841 (state
->addr
== NULL
||
842 state
->added
& STATE_FAKE
||
843 lease
->addr
.s_addr
!= state
->addr
->addr
.s_addr
)))
845 PUT_ADDR(DHO_IPADDRESS
, &lease
->addr
);
846 if (lease
->server
.s_addr
)
847 PUT_ADDR(DHO_SERVERID
, &lease
->server
);
850 if (type
== DHCP_RELEASE
) {
851 if (lease
->server
.s_addr
)
852 PUT_ADDR(DHO_SERVERID
, &lease
->server
);
856 if (type
== DHCP_DECLINE
) {
858 if (len
> AREA_LEFT
) {
866 if (type
== DHCP_DISCOVER
&&
867 !(ifp
->ctx
->options
& DHCPCD_TEST
) &&
868 has_option_mask(ifo
->requestmask
, DHO_RAPIDCOMMIT
))
870 /* RFC 4039 Section 3 */
872 *p
++ = DHO_RAPIDCOMMIT
;
876 if (type
== DHCP_DISCOVER
&& ifo
->options
& DHCPCD_REQUEST
)
877 PUT_ADDR(DHO_IPADDRESS
, &ifo
->req_addr
);
879 /* RFC 2563 Auto Configure */
880 if (type
== DHCP_DISCOVER
&& ifo
->options
& DHCPCD_IPV4LL
) {
882 *p
++ = DHO_AUTOCONFIGURE
;
887 if (type
== DHCP_DISCOVER
||
888 type
== DHCP_INFORM
||
889 type
== DHCP_REQUEST
)
893 *p
++ = DHO_MAXMESSAGESIZE
;
895 sz
= htons((uint16_t)(mtu
- IP_UDP_SIZE
));
900 if (ifo
->userclass
[0]) {
901 AREA_CHECK(ifo
->userclass
[0]);
902 *p
++ = DHO_USERCLASS
;
903 memcpy(p
, ifo
->userclass
,
904 (size_t)ifo
->userclass
[0] + 1);
905 p
+= ifo
->userclass
[0] + 1;
908 if (ifo
->vendorclassid
[0]) {
909 AREA_CHECK(ifo
->vendorclassid
[0]);
910 *p
++ = DHO_VENDORCLASSID
;
911 memcpy(p
, ifo
->vendorclassid
,
912 (size_t)ifo
->vendorclassid
[0] + 1);
913 p
+= ifo
->vendorclassid
[0] + 1;
916 if (ifo
->mudurl
[0]) {
917 AREA_CHECK(ifo
->mudurl
[0]);
919 memcpy(p
, ifo
->mudurl
, (size_t)ifo
->mudurl
[0] + 1);
920 p
+= ifo
->mudurl
[0] + 1;
923 if (type
!= DHCP_INFORM
) {
924 if (ifo
->leasetime
!= 0) {
926 *p
++ = DHO_LEASETIME
;
928 ul
= htonl(ifo
->leasetime
);
934 hostname
= dhcp_get_hostname(hbuf
, sizeof(hbuf
), ifo
);
937 * RFC4702 3.1 States that if we send the Client FQDN option
938 * then we MUST NOT also send the Host Name option.
939 * Technically we could, but that is not RFC conformant and
940 * also seems to break some DHCP server implemetations such as
941 * Windows. On the other hand, ISC dhcpd is just as non RFC
942 * conformant by not accepting a partially qualified FQDN.
944 if (ifo
->fqdn
!= FQDN_DISABLE
) {
945 /* IETF DHC-FQDN option (81), RFC4702 */
948 i
+= encode_rfc1035(hostname
, NULL
);
954 * S: 1 => Client requests Server to update
955 * a RR in DNS as well as PTR
956 * O: 1 => Server indicates to client that
957 * DNS has been updated
958 * E: 1 => Name data is DNS format
959 * N: 1 => Client requests Server to not
963 *p
++ = (uint8_t)((ifo
->fqdn
& 0x09) | 0x04);
965 *p
++ = (FQDN_NONE
& 0x09) | 0x04;
966 *p
++ = 0; /* from server for PTR RR */
967 *p
++ = 0; /* from server for A RR if S=1 */
969 i
= encode_rfc1035(hostname
, p
);
972 } else if (ifo
->options
& DHCPCD_HOSTNAME
&& hostname
) {
973 len
= strlen(hostname
);
977 memcpy(p
, hostname
, len
);
981 /* vendor is already encoded correctly, so just add it */
982 if (ifo
->vendor
[0]) {
983 AREA_CHECK(ifo
->vendor
[0]);
985 memcpy(p
, ifo
->vendor
, (size_t)ifo
->vendor
[0] + 1);
986 p
+= ifo
->vendor
[0] + 1;
990 if ((ifo
->auth
.options
& DHCPCD_AUTH_SENDREQUIRE
) !=
991 DHCPCD_AUTH_SENDREQUIRE
)
993 /* We support HMAC-MD5 */
995 *p
++ = DHO_FORCERENEW_NONCE
;
997 *p
++ = AUTH_ALG_HMAC_MD5
;
1001 if (ifo
->vivco_len
) {
1002 AREA_CHECK(sizeof(ul
));
1006 ul
= htonl(ifo
->vivco_en
);
1007 memcpy(p
, &ul
, sizeof(ul
));
1009 for (i
= 0, vivco
= ifo
->vivco
;
1013 AREA_FIT(vivco
->len
);
1014 if (vivco
->len
+ 2 + *lp
> 255) {
1015 logerrx("%s: VIVCO option too big",
1020 *p
++ = (uint8_t)vivco
->len
;
1021 memcpy(p
, vivco
->data
, vivco
->len
);
1023 *lp
= (uint8_t)(*lp
+ vivco
->len
+ 1);
1028 *p
++ = DHO_PARAMETERREQUESTLIST
;
1031 for (i
= 0, opt
= ifp
->ctx
->dhcp_opts
;
1032 i
< ifp
->ctx
->dhcp_opts_len
;
1035 if (!(opt
->type
& OT_REQUEST
||
1036 has_option_mask(ifo
->requestmask
, opt
->option
)))
1038 if (opt
->type
& OT_NOREQ
)
1040 if (type
== DHCP_INFORM
&&
1041 (opt
->option
== DHO_RENEWALTIME
||
1042 opt
->option
== DHO_REBINDTIME
))
1045 *p
++ = (uint8_t)opt
->option
;
1047 for (i
= 0, opt
= ifo
->dhcp_override
;
1048 i
< ifo
->dhcp_override_len
;
1051 /* Check if added above */
1052 for (lp
= n_params
+ 1; lp
< p
; lp
++)
1053 if (*lp
== (uint8_t)opt
->option
)
1057 if (!(opt
->type
& OT_REQUEST
||
1058 has_option_mask(ifo
->requestmask
, opt
->option
)))
1060 if (opt
->type
& OT_NOREQ
)
1062 if (type
== DHCP_INFORM
&&
1063 (opt
->option
== DHO_RENEWALTIME
||
1064 opt
->option
== DHO_REBINDTIME
))
1067 *p
++ = (uint8_t)opt
->option
;
1069 *n_params
= (uint8_t)(p
- n_params
- 1);
1073 auth
= NULL
; /* appease GCC */
1075 if (ifo
->auth
.options
& DHCPCD_AUTH_SEND
) {
1076 ssize_t alen
= dhcp_auth_encode(&ifo
->auth
,
1078 NULL
, 0, 4, type
, NULL
, 0);
1079 if (alen
!= -1 && alen
> UINT8_MAX
) {
1084 logerr("%s: dhcp_auth_encode", ifp
->name
);
1085 else if (alen
!= 0) {
1086 auth_len
= (uint8_t)alen
;
1087 AREA_CHECK(auth_len
);
1088 *p
++ = DHO_AUTHENTICATION
;
1097 len
= (size_t)(p
- (uint8_t *)bootp
);
1099 /* Pad out to the BOOTP message length.
1100 * Even if we send a DHCP packet with a variable length vendor area,
1101 * some servers / relay agents don't like packets smaller than
1102 * a BOOTP message which is fine because that's stipulated
1103 * in RFC1542 section 2.1. */
1104 while (len
< sizeof(*bootp
)) {
1110 if (ifo
->auth
.options
& DHCPCD_AUTH_SEND
&& auth_len
!= 0)
1111 dhcp_auth_encode(&ifo
->auth
, state
->auth
.token
,
1112 (uint8_t *)bootp
, len
, 4, type
, auth
, auth_len
);
1115 return (ssize_t
)len
;
1118 logerrx("%s: DHCP message too big", ifp
->name
);
1124 write_lease(const struct interface
*ifp
, const struct bootp
*bootp
, size_t len
)
1128 const struct dhcp_state
*state
= D_CSTATE(ifp
);
1130 logdebugx("%s: writing lease `%s'", ifp
->name
, state
->leasefile
);
1132 fd
= open(state
->leasefile
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
1135 bytes
= write(fd
, bootp
, len
);
1141 read_lease(struct interface
*ifp
, struct bootp
**bootp
)
1145 struct dhcp_state
*state
= D_STATE(ifp
);
1146 struct bootp
*lease
;
1150 const uint8_t *auth
;
1157 if (state
->leasefile
[0] == '\0') {
1161 fd
= open(state
->leasefile
, O_RDONLY
);
1165 if (errno
!= ENOENT
)
1166 logerr("%s: open `%s'",
1167 ifp
->name
, state
->leasefile
);
1170 if (state
->leasefile
[0] == '\0')
1171 logdebugx("reading standard input");
1173 logdebugx("%s: reading lease `%s'",
1174 ifp
->name
, state
->leasefile
);
1176 bytes
= dhcp_read_lease_fd(fd
, (void **)&lease
);
1182 /* Ensure the packet is at lease BOOTP sized
1183 * with a vendor area of 4 octets
1184 * (it should be more, and our read packet enforces this so this
1185 * code should not be needed, but of course people could
1186 * scribble whatever in the stored lease file. */
1187 if (bytes
< offsetof(struct bootp
, vend
) + 4) {
1189 logerrx("%s: %s: truncated lease", ifp
->name
, __func__
);
1193 if (ifp
->ctx
->options
& DHCPCD_DUMPLEASE
)
1196 /* We may have found a BOOTP server */
1197 if (get_option_uint8(ifp
->ctx
, &type
, (struct bootp
*)lease
, bytes
,
1198 DHO_MESSAGETYPE
) == -1)
1202 /* Authenticate the message */
1203 auth
= get_option(ifp
->ctx
, (struct bootp
*)lease
, bytes
,
1204 DHO_AUTHENTICATION
, &auth_len
);
1206 if (dhcp_auth_validate(&state
->auth
, &ifp
->options
->auth
,
1207 lease
, bytes
, 4, type
, auth
, auth_len
) == NULL
)
1209 logerr("%s: authentication failed", ifp
->name
);
1213 if (state
->auth
.token
)
1214 logdebugx("%s: validated using 0x%08" PRIu32
,
1215 ifp
->name
, state
->auth
.token
->secretid
);
1217 logdebugx("%s: accepted reconfigure key", ifp
->name
);
1218 } else if ((ifp
->options
->auth
.options
& DHCPCD_AUTH_SENDREQUIRE
) ==
1219 DHCPCD_AUTH_SENDREQUIRE
)
1221 logerrx("%s: authentication now required", ifp
->name
);
1228 *bootp
= (struct bootp
*)lease
;
1232 static const struct dhcp_opt
*
1233 dhcp_getoverride(const struct if_options
*ifo
, unsigned int o
)
1236 const struct dhcp_opt
*opt
;
1238 for (i
= 0, opt
= ifo
->dhcp_override
;
1239 i
< ifo
->dhcp_override_len
;
1242 if (opt
->option
== o
)
1248 static const uint8_t *
1249 dhcp_getoption(struct dhcpcd_ctx
*ctx
,
1250 size_t *os
, unsigned int *code
, size_t *len
,
1251 const uint8_t *od
, size_t ol
, struct dhcp_opt
**oopt
)
1254 struct dhcp_opt
*opt
;
1261 *os
= 2; /* code + len */
1262 *code
= (unsigned int)*od
++;
1263 *len
= (size_t)*od
++;
1264 if (*len
> ol
- *os
) {
1271 for (i
= 0, opt
= ctx
->dhcp_opts
; i
< ctx
->dhcp_opts_len
; i
++, opt
++) {
1272 if (opt
->option
== *code
) {
1282 dhcp_env(FILE *fenv
, const char *prefix
, const struct interface
*ifp
,
1283 const struct bootp
*bootp
, size_t bootp_len
)
1285 const struct if_options
*ifo
;
1287 struct in_addr addr
;
1290 struct dhcp_opt
*opt
, *vo
;
1292 char safe
[(BOOTP_FILE_LEN
* 4) + 1];
1297 if (get_option_uint8(ifp
->ctx
, &overl
, bootp
, bootp_len
,
1298 DHO_OPTSOVERLOADED
) == -1)
1301 if (bootp
->yiaddr
|| bootp
->ciaddr
) {
1302 /* Set some useful variables that we derive from the DHCP
1303 * message but are not necessarily in the options */
1304 addr
.s_addr
= bootp
->yiaddr
? bootp
->yiaddr
: bootp
->ciaddr
;
1305 if (efprintf(fenv
, "%s_ip_address=%s",
1306 prefix
, inet_ntoa(addr
)) == -1)
1308 if (get_option_addr(ifp
->ctx
, &net
,
1309 bootp
, bootp_len
, DHO_SUBNETMASK
) == -1) {
1310 net
.s_addr
= ipv4_getnetmask(addr
.s_addr
);
1311 if (efprintf(fenv
, "%s_subnet_mask=%s",
1312 prefix
, inet_ntoa(net
)) == -1)
1315 if (efprintf(fenv
, "%s_subnet_cidr=%d",
1316 prefix
, inet_ntocidr(net
))== -1)
1318 if (get_option_addr(ifp
->ctx
, &brd
,
1319 bootp
, bootp_len
, DHO_BROADCAST
) == -1)
1321 brd
.s_addr
= addr
.s_addr
| ~net
.s_addr
;
1322 if (efprintf(fenv
, "%s_broadcast_address=%s",
1323 prefix
, inet_ntoa(brd
)) == -1)
1326 addr
.s_addr
= bootp
->yiaddr
& net
.s_addr
;
1327 if (efprintf(fenv
, "%s_network_number=%s",
1328 prefix
, inet_ntoa(addr
)) == -1)
1332 if (*bootp
->file
&& !(overl
& 1)) {
1333 print_string(safe
, sizeof(safe
), OT_STRING
,
1334 bootp
->file
, sizeof(bootp
->file
));
1335 if (efprintf(fenv
, "%s_filename=%s", prefix
, safe
) == -1)
1338 if (*bootp
->sname
&& !(overl
& 2)) {
1339 print_string(safe
, sizeof(safe
), OT_STRING
| OT_DOMAIN
,
1340 bootp
->sname
, sizeof(bootp
->sname
));
1341 if (efprintf(fenv
, "%s_server_name=%s", prefix
, safe
) == -1)
1345 /* Zero our indexes */
1346 for (i
= 0, opt
= ifp
->ctx
->dhcp_opts
;
1347 i
< ifp
->ctx
->dhcp_opts_len
;
1349 dhcp_zero_index(opt
);
1350 for (i
= 0, opt
= ifp
->options
->dhcp_override
;
1351 i
< ifp
->options
->dhcp_override_len
;
1353 dhcp_zero_index(opt
);
1354 for (i
= 0, opt
= ifp
->ctx
->vivso
;
1355 i
< ifp
->ctx
->vivso_len
;
1357 dhcp_zero_index(opt
);
1359 for (i
= 0, opt
= ifp
->ctx
->dhcp_opts
;
1360 i
< ifp
->ctx
->dhcp_opts_len
;
1363 if (has_option_mask(ifo
->nomask
, opt
->option
))
1365 if (dhcp_getoverride(ifo
, opt
->option
))
1367 p
= get_option(ifp
->ctx
, bootp
, bootp_len
, opt
->option
, &pl
);
1370 dhcp_envoption(ifp
->ctx
, fenv
, prefix
, ifp
->name
,
1371 opt
, dhcp_getoption
, p
, pl
);
1373 if (opt
->option
!= DHO_VIVSO
|| pl
<= (int)sizeof(uint32_t))
1375 memcpy(&en
, p
, sizeof(en
));
1377 vo
= vivso_find(en
, ifp
);
1380 /* Skip over en + total size */
1381 p
+= sizeof(en
) + 1;
1382 pl
-= sizeof(en
) + 1;
1383 dhcp_envoption(ifp
->ctx
, fenv
, prefix
, ifp
->name
,
1384 vo
, dhcp_getoption
, p
, pl
);
1387 for (i
= 0, opt
= ifo
->dhcp_override
;
1388 i
< ifo
->dhcp_override_len
;
1391 if (has_option_mask(ifo
->nomask
, opt
->option
))
1393 p
= get_option(ifp
->ctx
, bootp
, bootp_len
, opt
->option
, &pl
);
1396 dhcp_envoption(ifp
->ctx
, fenv
, prefix
, ifp
->name
,
1397 opt
, dhcp_getoption
, p
, pl
);
1404 get_lease(struct interface
*ifp
,
1405 struct dhcp_lease
*lease
, const struct bootp
*bootp
, size_t len
)
1407 struct dhcpcd_ctx
*ctx
;
1409 assert(bootp
!= NULL
);
1411 memcpy(&lease
->cookie
, bootp
->vend
, sizeof(lease
->cookie
));
1412 /* BOOTP does not set yiaddr for replies when ciaddr is set. */
1413 lease
->addr
.s_addr
= bootp
->yiaddr
? bootp
->yiaddr
: bootp
->ciaddr
;
1415 if (ifp
->options
->options
& (DHCPCD_STATIC
| DHCPCD_INFORM
)) {
1416 if (ifp
->options
->req_addr
.s_addr
!= INADDR_ANY
) {
1417 lease
->mask
= ifp
->options
->req_mask
;
1418 if (ifp
->options
->req_brd
.s_addr
!= INADDR_ANY
)
1419 lease
->brd
= ifp
->options
->req_brd
;
1422 lease
->addr
.s_addr
| ~lease
->mask
.s_addr
;
1424 const struct ipv4_addr
*ia
;
1426 ia
= ipv4_iffindaddr(ifp
, &lease
->addr
, NULL
);
1428 lease
->mask
= ia
->mask
;
1429 lease
->brd
= ia
->brd
;
1432 if (get_option_addr(ctx
, &lease
->mask
, bootp
, len
,
1433 DHO_SUBNETMASK
) == -1)
1434 lease
->mask
.s_addr
=
1435 ipv4_getnetmask(lease
->addr
.s_addr
);
1436 if (get_option_addr(ctx
, &lease
->brd
, bootp
, len
,
1437 DHO_BROADCAST
) == -1)
1439 lease
->addr
.s_addr
| ~lease
->mask
.s_addr
;
1441 if (get_option_uint32(ctx
, &lease
->leasetime
,
1442 bootp
, len
, DHO_LEASETIME
) != 0)
1443 lease
->leasetime
= DHCP_INFINITE_LIFETIME
;
1444 if (get_option_uint32(ctx
, &lease
->renewaltime
,
1445 bootp
, len
, DHO_RENEWALTIME
) != 0)
1446 lease
->renewaltime
= 0;
1447 if (get_option_uint32(ctx
, &lease
->rebindtime
,
1448 bootp
, len
, DHO_REBINDTIME
) != 0)
1449 lease
->rebindtime
= 0;
1450 if (get_option_addr(ctx
, &lease
->server
, bootp
, len
, DHO_SERVERID
) != 0)
1451 lease
->server
.s_addr
= INADDR_ANY
;
1455 get_dhcp_op(uint8_t type
)
1457 const struct dhcp_op
*d
;
1459 for (d
= dhcp_ops
; d
->name
; d
++)
1460 if (d
->value
== type
)
1466 dhcp_fallback(void *arg
)
1468 struct interface
*iface
;
1470 iface
= (struct interface
*)arg
;
1471 dhcpcd_selectprofile(iface
, iface
->options
->fallback
);
1472 dhcpcd_startinterface(iface
);
1476 dhcp_new_xid(struct interface
*ifp
)
1478 struct dhcp_state
*state
;
1479 const struct interface
*ifp1
;
1480 const struct dhcp_state
*state1
;
1482 state
= D_STATE(ifp
);
1483 if (ifp
->options
->options
& DHCPCD_XID_HWADDR
&&
1484 ifp
->hwlen
>= sizeof(state
->xid
))
1485 /* The lower bits are probably more unique on the network */
1487 (ifp
->hwaddr
+ ifp
->hwlen
) - sizeof(state
->xid
),
1488 sizeof(state
->xid
));
1491 state
->xid
= arc4random();
1494 /* Ensure it's unique */
1495 TAILQ_FOREACH(ifp1
, ifp
->ctx
->ifaces
, next
) {
1498 if ((state1
= D_CSTATE(ifp1
)) == NULL
)
1500 if (state1
->xid
== state
->xid
)
1504 if (ifp
->options
->options
& DHCPCD_XID_HWADDR
&&
1505 ifp
->hwlen
>= sizeof(state
->xid
))
1507 logerrx("%s: duplicate xid on %s",
1508 ifp
->name
, ifp1
->name
);
1514 /* We can't do this when sharing leases across interfaes */
1516 /* As the XID changes, re-apply the filter. */
1517 if (state
->bpf_fd
!= -1) {
1518 if (bpf_bootp(ifp
, state
->bpf_fd
) == -1)
1519 logerr(__func__
); /* try to continue */
1525 dhcp_close(struct interface
*ifp
)
1527 struct dhcp_state
*state
= D_STATE(ifp
);
1532 if (state
->bpf_fd
!= -1) {
1533 eloop_event_delete(ifp
->ctx
->eloop
, state
->bpf_fd
);
1534 bpf_close(ifp
, state
->bpf_fd
);
1536 state
->bpf_flags
|= BPF_EOF
;
1538 if (state
->udp_fd
!= -1) {
1539 eloop_event_delete(ifp
->ctx
->eloop
, state
->udp_fd
);
1540 close(state
->udp_fd
);
1544 state
->interval
= 0;
1548 dhcp_openudp(struct interface
*ifp
)
1551 struct sockaddr_in sin
;
1554 if ((s
= xsocket(PF_INET
, SOCK_DGRAM
|SOCK_CLOEXEC
, IPPROTO_UDP
)) == -1)
1558 if (setsockopt(s
, SOL_SOCKET
, SO_REUSEADDR
, &n
, sizeof(n
)) == -1)
1560 #ifdef IP_RECVPKTINFO
1561 if (setsockopt(s
, IPPROTO_IP
, IP_RECVPKTINFO
, &n
, sizeof(n
)) == -1)
1564 memset(&sin
, 0, sizeof(sin
));
1565 sin
.sin_family
= AF_INET
;
1566 sin
.sin_port
= htons(BOOTPC
);
1568 const struct dhcp_state
*state
= D_CSTATE(ifp
);
1571 sin
.sin_addr
.s_addr
= state
->addr
->addr
.s_addr
;
1573 if (bind(s
, (struct sockaddr
*)&sin
, sizeof(sin
)) == -1)
1584 in_cksum(const void *data
, size_t len
, uint32_t *isum
)
1586 const uint16_t *word
= data
;
1587 uint32_t sum
= isum
!= NULL
? *isum
: 0;
1589 for (; len
> 1; len
-= sizeof(*word
))
1593 sum
+= htons((uint16_t)(*(const uint8_t *)word
<< 8));
1598 sum
= (sum
>> 16) + (sum
& 0xffff);
1601 return (uint16_t)~sum
;
1604 static struct bootp_pkt
*
1605 dhcp_makeudppacket(size_t *sz
, const uint8_t *data
, size_t length
,
1606 struct in_addr source
, struct in_addr dest
)
1608 struct bootp_pkt
*udpp
;
1612 if ((udpp
= calloc(1, sizeof(*ip
) + sizeof(*udp
) + length
)) == NULL
)
1617 /* OK, this is important :)
1618 * We copy the data to our packet and then create a small part of the
1619 * ip structure and an invalid ip_len (basically udp length).
1620 * We then fill the udp structure and put the checksum
1621 * of the whole packet into the udp checksum.
1622 * Finally we complete the ip structure and ip checksum.
1623 * If we don't do the ordering like so then the udp checksum will be
1624 * broken, so find another way of doing it! */
1626 memcpy(&udpp
->bootp
, data
, length
);
1628 ip
->ip_p
= IPPROTO_UDP
;
1629 ip
->ip_src
.s_addr
= source
.s_addr
;
1630 if (dest
.s_addr
== 0)
1631 ip
->ip_dst
.s_addr
= INADDR_BROADCAST
;
1633 ip
->ip_dst
.s_addr
= dest
.s_addr
;
1635 udp
->uh_sport
= htons(BOOTPC
);
1636 udp
->uh_dport
= htons(BOOTPS
);
1637 udp
->uh_ulen
= htons((uint16_t)(sizeof(*udp
) + length
));
1638 ip
->ip_len
= udp
->uh_ulen
;
1639 udp
->uh_sum
= in_cksum(udpp
, sizeof(*ip
) + sizeof(*udp
) + length
, NULL
);
1641 ip
->ip_v
= IPVERSION
;
1642 ip
->ip_hl
= sizeof(*ip
) >> 2;
1643 ip
->ip_id
= (uint16_t)arc4random_uniform(UINT16_MAX
);
1644 ip
->ip_ttl
= IPDEFTTL
;
1645 ip
->ip_len
= htons((uint16_t)(sizeof(*ip
) + sizeof(*udp
) + length
));
1646 ip
->ip_sum
= in_cksum(ip
, sizeof(*ip
), NULL
);
1647 if (ip
->ip_sum
== 0)
1648 ip
->ip_sum
= 0xffff; /* RFC 768 */
1650 *sz
= sizeof(*ip
) + sizeof(*udp
) + length
;
1655 dhcp_sendudp(struct interface
*ifp
, struct in_addr
*to
, void *data
, size_t len
)
1659 struct sockaddr_in sin
;
1660 struct iovec iov
[1];
1661 struct dhcp_state
*state
= D_STATE(ifp
);
1664 iov
[0].iov_base
= data
;
1665 iov
[0].iov_len
= len
;
1667 memset(&sin
, 0, sizeof(sin
));
1668 sin
.sin_family
= AF_INET
;
1670 sin
.sin_port
= htons(BOOTPS
);
1672 sin
.sin_len
= sizeof(sin
);
1675 memset(&msg
, 0, sizeof(msg
));
1676 msg
.msg_name
= (void *)&sin
;
1677 msg
.msg_namelen
= sizeof(sin
);
1683 s
= dhcp_openudp(ifp
);
1687 r
= sendmsg(s
, &msg
, 0);
1688 if (state
->udp_fd
== -1)
1694 send_message(struct interface
*ifp
, uint8_t type
,
1695 void (*callback
)(void *))
1697 struct dhcp_state
*state
= D_STATE(ifp
);
1698 struct if_options
*ifo
= ifp
->options
;
1699 struct bootp
*bootp
;
1700 struct bootp_pkt
*udp
;
1703 struct in_addr from
, to
;
1707 /* No carrier? Don't bother sending the packet. */
1708 if (ifp
->carrier
<= LINK_DOWN
)
1710 logdebugx("%s: sending %s with xid 0x%x",
1712 ifo
->options
& DHCPCD_BOOTP
? "BOOTP" : get_dhcp_op(type
),
1715 if (state
->interval
== 0)
1716 state
->interval
= 4;
1718 state
->interval
*= 2;
1719 if (state
->interval
> 64)
1720 state
->interval
= 64;
1722 tv
.tv_sec
= state
->interval
+ DHCP_RAND_MIN
;
1723 tv
.tv_nsec
= (suseconds_t
)arc4random_uniform(
1724 (DHCP_RAND_MAX
- DHCP_RAND_MIN
) * NSEC_PER_SEC
);
1726 /* No carrier? Don't bother sending the packet.
1727 * However, we do need to advance the timeout. */
1728 if (ifp
->carrier
<= LINK_DOWN
)
1730 logdebugx("%s: sending %s (xid 0x%x), next in %0.1f seconds",
1732 ifo
->options
& DHCPCD_BOOTP
? "BOOTP" : get_dhcp_op(type
),
1734 timespec_to_double(&tv
));
1737 r
= make_message(&bootp
, ifp
, type
);
1741 from
.s_addr
= bootp
->ciaddr
;
1742 if (from
.s_addr
!= INADDR_ANY
)
1743 to
.s_addr
= state
->lease
.server
.s_addr
;
1745 to
.s_addr
= INADDR_ANY
;
1747 /* If unicasting, try and avoid sending by BPF so we don't
1748 * use a L2 broadcast. */
1749 if (to
.s_addr
!= INADDR_ANY
&& to
.s_addr
!= INADDR_BROADCAST
) {
1750 if (dhcp_sendudp(ifp
, &to
, bootp
, len
) != -1)
1752 logerr("%s: dhcp_sendudp", ifp
->name
);
1755 if (dhcp_openbpf(ifp
) == -1)
1758 udp
= dhcp_makeudppacket(&ulen
, (uint8_t *)bootp
, len
, from
, to
);
1760 logerr("%s: dhcp_makeudppacket", ifp
->name
);
1763 r
= bpf_send(ifp
, state
->bpf_fd
,
1764 ETHERTYPE_IP
, (uint8_t *)udp
, ulen
);
1767 /* If we failed to send a raw packet this normally means
1768 * we don't have the ability to work beneath the IP layer
1769 * for this interface.
1770 * As such we remove it from consideration without actually
1771 * stopping the interface. */
1773 logerr("%s: if_sendraw", ifp
->name
);
1781 if (!(ifp
->ctx
->options
& DHCPCD_TEST
))
1782 dhcp_drop(ifp
, "FAIL");
1783 eloop_timeout_delete(ifp
->ctx
->eloop
,
1793 /* Even if we fail to send a packet we should continue as we are
1794 * as our failure timeouts will change out codepath when needed. */
1796 eloop_timeout_add_tv(ifp
->ctx
->eloop
, &tv
, callback
, ifp
);
1800 send_inform(void *arg
)
1803 send_message((struct interface
*)arg
, DHCP_INFORM
, send_inform
);
1807 send_discover(void *arg
)
1810 send_message((struct interface
*)arg
, DHCP_DISCOVER
, send_discover
);
1814 send_request(void *arg
)
1817 send_message((struct interface
*)arg
, DHCP_REQUEST
, send_request
);
1821 send_renew(void *arg
)
1824 send_message((struct interface
*)arg
, DHCP_REQUEST
, send_renew
);
1828 send_rebind(void *arg
)
1831 send_message((struct interface
*)arg
, DHCP_REQUEST
, send_rebind
);
1835 dhcp_discover(void *arg
)
1837 struct interface
*ifp
= arg
;
1838 struct dhcp_state
*state
= D_STATE(ifp
);
1839 struct if_options
*ifo
= ifp
->options
;
1841 state
->state
= DHS_DISCOVER
;
1843 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
1845 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
1846 ifo
->reboot
, dhcp_fallback
, ifp
);
1848 else if (ifo
->options
& DHCPCD_IPV4LL
)
1849 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
1850 ifo
->reboot
, ipv4ll_start
, ifp
);
1852 if (ifo
->options
& DHCPCD_REQUEST
)
1853 loginfox("%s: soliciting a DHCP lease (requesting %s)",
1854 ifp
->name
, inet_ntoa(ifo
->req_addr
));
1856 loginfox("%s: soliciting a %s lease",
1857 ifp
->name
, ifo
->options
& DHCPCD_BOOTP
? "BOOTP" : "DHCP");
1862 dhcp_request(void *arg
)
1864 struct interface
*ifp
= arg
;
1865 struct dhcp_state
*state
= D_STATE(ifp
);
1867 state
->state
= DHS_REQUEST
;
1872 dhcp_expire1(struct interface
*ifp
)
1874 struct dhcp_state
*state
= D_STATE(ifp
);
1876 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
1877 dhcp_drop(ifp
, "EXPIRE");
1878 unlink(state
->leasefile
);
1879 state
->interval
= 0;
1880 if (!(ifp
->options
->options
& DHCPCD_LINK
) || ifp
->carrier
> LINK_DOWN
)
1885 dhcp_expire(void *arg
)
1887 struct interface
*ifp
= arg
;
1889 if (ifp
->options
->options
& DHCPCD_LASTLEASE_EXTEND
) {
1890 logwarnx("%s: DHCP lease expired, extending lease", ifp
->name
);
1894 logerrx("%s: DHCP lease expired", ifp
->name
);
1898 #if defined(ARP) || defined(IN_IFF_DUPLICATED)
1900 dhcp_decline(struct interface
*ifp
)
1903 send_message(ifp
, DHCP_DECLINE
, NULL
);
1908 dhcp_startrenew(void *arg
)
1910 struct interface
*ifp
= arg
;
1911 struct dhcp_state
*state
;
1912 struct dhcp_lease
*lease
;
1914 if ((state
= D_STATE(ifp
)) == NULL
)
1917 /* Only renew in the bound or renew states */
1918 if (state
->state
!= DHS_BOUND
&&
1919 state
->state
!= DHS_RENEW
)
1922 /* Remove the timeout as the renew may have been forced. */
1923 eloop_timeout_delete(ifp
->ctx
->eloop
, dhcp_startrenew
, ifp
);
1925 lease
= &state
->lease
;
1926 logdebugx("%s: renewing lease of %s", ifp
->name
,
1927 inet_ntoa(lease
->addr
));
1928 state
->state
= DHS_RENEW
;
1930 state
->interval
= 0;
1935 dhcp_renew(struct interface
*ifp
)
1938 dhcp_startrenew(ifp
);
1942 dhcp_rebind(void *arg
)
1944 struct interface
*ifp
= arg
;
1945 struct dhcp_state
*state
= D_STATE(ifp
);
1946 struct dhcp_lease
*lease
= &state
->lease
;
1948 logwarnx("%s: failed to renew DHCP, rebinding", ifp
->name
);
1949 logdebugx("%s: expire in %"PRIu32
" seconds",
1950 ifp
->name
, lease
->leasetime
- lease
->rebindtime
);
1951 state
->state
= DHS_REBIND
;
1952 eloop_timeout_delete(ifp
->ctx
->eloop
, send_renew
, ifp
);
1953 state
->lease
.server
.s_addr
= INADDR_ANY
;
1954 state
->interval
= 0;
1955 ifp
->options
->options
&= ~(DHCPCD_CSR_WARNED
|
1956 DHCPCD_ROUTER_HOST_ROUTE_WARNED
);
1960 #if defined(ARP) || defined(IN_IFF_DUPLICATED)
1962 dhcp_finish_dad(struct interface
*ifp
, struct in_addr
*ia
)
1964 struct dhcp_state
*state
= D_STATE(ifp
);
1966 if (state
->state
!= DHS_PROBE
)
1968 if (state
->offer
== NULL
|| state
->offer
->yiaddr
!= ia
->s_addr
)
1971 logdebugx("%s: DAD completed for %s", ifp
->name
, inet_ntoa(*ia
));
1972 if (!(ifp
->options
->options
& DHCPCD_INFORM
))
1974 #ifndef IN_IFF_DUPLICATED
1976 struct bootp
*bootp
;
1980 len
= state
->new_len
;
1981 state
->new = state
->offer
;
1982 state
->new_len
= state
->offer_len
;
1983 get_lease(ifp
, &state
->lease
, state
->new, state
->new_len
);
1984 ipv4_applyaddr(ifp
);
1986 state
->new_len
= len
;
1990 /* If we forked, stop here. */
1991 if (ifp
->ctx
->options
& DHCPCD_FORKED
)
1995 /* Stop IPv4LL now we have a working DHCP address */
1999 if (ifp
->options
->options
& DHCPCD_INFORM
)
2005 dhcp_addr_duplicated(struct interface
*ifp
, struct in_addr
*ia
)
2007 struct dhcp_state
*state
= D_STATE(ifp
);
2008 #ifdef IN_IFF_DUPLICATED
2009 struct ipv4_addr
*iap
;
2012 if ((state
->offer
== NULL
|| state
->offer
->yiaddr
!= ia
->s_addr
) &&
2013 !IN_ARE_ADDR_EQUAL(ia
, &state
->lease
.addr
))
2016 /* RFC 2131 3.1.5, Client-server interaction */
2017 logerrx("%s: DAD detected %s", ifp
->name
, inet_ntoa(*ia
));
2018 unlink(state
->leasefile
);
2019 if (!(ifp
->options
->options
& DHCPCD_STATIC
) && !state
->lease
.frominfo
)
2021 #ifdef IN_IFF_DUPLICATED
2022 if ((iap
= ipv4_iffindaddr(ifp
, ia
, NULL
)) != NULL
)
2023 ipv4_deladdr(iap
, 0);
2025 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
2026 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
2027 DHCP_RAND_MAX
, dhcp_discover
, ifp
);
2031 #if defined(ARP) && (!defined(KERNEL_RFC5227) || defined(ARPING))
2033 dhcp_arp_not_found(struct arp_state
*astate
)
2035 struct interface
*ifp
;
2037 struct dhcp_state
*state
;
2038 struct if_options
*ifo
;
2041 ifp
= astate
->iface
;
2043 state
= D_STATE(ifp
);
2045 if (ifo
->arping_len
&& state
->arping_index
< ifo
->arping_len
) {
2046 /* We didn't find a profile for this
2047 * address or hwaddr, so move to the next
2049 if (++state
->arping_index
< ifo
->arping_len
) {
2050 astate
->addr
.s_addr
=
2051 ifo
->arping
[state
->arping_index
];
2056 dhcpcd_startinterface(ifp
);
2061 dhcp_finish_dad(ifp
, &astate
->addr
);
2065 dhcp_arp_found(struct arp_state
*astate
, const struct arp_msg
*amsg
)
2067 struct in_addr addr
;
2068 struct interface
*ifp
= astate
->iface
;
2070 struct dhcp_state
*state
;
2071 struct if_options
*ifo
;
2073 state
= D_STATE(ifp
);
2076 if (state
->arping_index
!= -1 &&
2077 state
->arping_index
< ifo
->arping_len
&&
2079 amsg
->sip
.s_addr
== ifo
->arping
[state
->arping_index
])
2081 char buf
[HWADDR_LEN
* 3];
2083 hwaddr_ntoa(amsg
->sha
, ifp
->hwlen
, buf
, sizeof(buf
));
2084 if (dhcpcd_selectprofile(ifp
, buf
) == -1 &&
2085 dhcpcd_selectprofile(ifp
, inet_ntoa(amsg
->sip
)) == -1)
2087 /* We didn't find a profile for this
2088 * address or hwaddr, so move to the next
2090 dhcp_arp_not_found(astate
);
2094 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
2095 dhcpcd_startinterface(ifp
);
2102 addr
= astate
->addr
;
2104 dhcp_addr_duplicated(ifp
, &addr
);
2107 #ifdef KERNEL_RFC5227
2109 dhcp_arp_announced(struct arp_state
*state
)
2114 #endif /* KERNEL_RFC5227 */
2118 dhcp_bind(struct interface
*ifp
)
2120 struct dhcpcd_ctx
*ctx
= ifp
->ctx
;
2121 struct dhcp_state
*state
= D_STATE(ifp
);
2122 struct if_options
*ifo
= ifp
->options
;
2123 struct dhcp_lease
*lease
= &state
->lease
;
2125 state
->reason
= NULL
;
2126 /* If we don't have an offer, we are re-binding a lease on preference,
2127 * normally when two interfaces have a lease matching IP addresses. */
2130 state
->old
= state
->new;
2131 state
->old_len
= state
->new_len
;
2132 state
->new = state
->offer
;
2133 state
->new_len
= state
->offer_len
;
2134 state
->offer
= NULL
;
2135 state
->offer_len
= 0;
2137 get_lease(ifp
, lease
, state
->new, state
->new_len
);
2138 if (ifo
->options
& DHCPCD_STATIC
) {
2139 loginfox("%s: using static address %s/%d",
2140 ifp
->name
, inet_ntoa(lease
->addr
),
2141 inet_ntocidr(lease
->mask
));
2142 lease
->leasetime
= DHCP_INFINITE_LIFETIME
;
2143 state
->reason
= "STATIC";
2144 } else if (ifo
->options
& DHCPCD_INFORM
) {
2145 loginfox("%s: received approval for %s",
2146 ifp
->name
, inet_ntoa(lease
->addr
));
2147 lease
->leasetime
= DHCP_INFINITE_LIFETIME
;
2148 state
->reason
= "INFORM";
2150 if (lease
->frominfo
)
2151 state
->reason
= "TIMEOUT";
2152 if (lease
->leasetime
== DHCP_INFINITE_LIFETIME
) {
2153 lease
->renewaltime
=
2156 loginfox("%s: leased %s for infinity",
2157 ifp
->name
, inet_ntoa(lease
->addr
));
2159 if (lease
->leasetime
< DHCP_MIN_LEASE
) {
2160 logwarnx("%s: minimum lease is %d seconds",
2161 ifp
->name
, DHCP_MIN_LEASE
);
2162 lease
->leasetime
= DHCP_MIN_LEASE
;
2164 if (lease
->rebindtime
== 0)
2166 (uint32_t)(lease
->leasetime
* T2
);
2167 else if (lease
->rebindtime
>= lease
->leasetime
) {
2169 (uint32_t)(lease
->leasetime
* T2
);
2170 logwarnx("%s: rebind time greater than lease "
2171 "time, forcing to %"PRIu32
" seconds",
2172 ifp
->name
, lease
->rebindtime
);
2174 if (lease
->renewaltime
== 0)
2175 lease
->renewaltime
=
2176 (uint32_t)(lease
->leasetime
* T1
);
2177 else if (lease
->renewaltime
> lease
->rebindtime
) {
2178 lease
->renewaltime
=
2179 (uint32_t)(lease
->leasetime
* T1
);
2180 logwarnx("%s: renewal time greater than "
2181 "rebind time, forcing to %"PRIu32
" seconds",
2182 ifp
->name
, lease
->renewaltime
);
2185 lease
->addr
.s_addr
== state
->addr
->addr
.s_addr
&&
2186 !(state
->added
& STATE_FAKE
))
2187 logdebugx("%s: leased %s for %"PRIu32
" seconds",
2188 ifp
->name
, inet_ntoa(lease
->addr
),
2191 loginfox("%s: leased %s for %"PRIu32
" seconds",
2192 ifp
->name
, inet_ntoa(lease
->addr
),
2196 if (ctx
->options
& DHCPCD_TEST
) {
2197 state
->reason
= "TEST";
2198 script_runreason(ifp
, state
->reason
);
2199 eloop_exit(ctx
->eloop
, EXIT_SUCCESS
);
2202 if (state
->reason
== NULL
) {
2203 if (state
->old
&& !(state
->added
& STATE_FAKE
)) {
2204 if (state
->old
->yiaddr
== state
->new->yiaddr
&&
2205 lease
->server
.s_addr
&&
2206 state
->state
!= DHS_REBIND
)
2207 state
->reason
= "RENEW";
2209 state
->reason
= "REBIND";
2210 } else if (state
->state
== DHS_REBOOT
)
2211 state
->reason
= "REBOOT";
2213 state
->reason
= "BOUND";
2215 if (lease
->leasetime
== DHCP_INFINITE_LIFETIME
)
2216 lease
->renewaltime
= lease
->rebindtime
= lease
->leasetime
;
2218 eloop_timeout_add_sec(ctx
->eloop
,
2219 (time_t)lease
->renewaltime
, dhcp_startrenew
, ifp
);
2220 eloop_timeout_add_sec(ctx
->eloop
,
2221 (time_t)lease
->rebindtime
, dhcp_rebind
, ifp
);
2222 eloop_timeout_add_sec(ctx
->eloop
,
2223 (time_t)lease
->leasetime
, dhcp_expire
, ifp
);
2224 logdebugx("%s: renew in %"PRIu32
" seconds, rebind in %"PRIu32
2226 ifp
->name
, lease
->renewaltime
, lease
->rebindtime
);
2228 state
->state
= DHS_BOUND
;
2229 if (!state
->lease
.frominfo
&&
2230 !(ifo
->options
& (DHCPCD_INFORM
| DHCPCD_STATIC
)))
2231 if (write_lease(ifp
, state
->new, state
->new_len
) == -1)
2234 ipv4_applyaddr(ifp
);
2237 /* Close the BPF filter as we can now receive DHCP messages
2238 * on a UDP socket. */
2239 if (state
->udp_fd
== -1 ||
2240 (state
->old
!= NULL
&& state
->old
->yiaddr
!= state
->new->yiaddr
))
2243 /* If not in master mode, open an address specific socket. */
2244 if (ctx
->udp_fd
== -1) {
2245 state
->udp_fd
= dhcp_openudp(ifp
);
2246 if (state
->udp_fd
== -1) {
2248 /* Address sharing without master mode is
2249 * not supported. It's also possible another
2250 * DHCP client could be running which is
2252 * We still need to work, so re-open BPF. */
2255 eloop_event_add(ctx
->eloop
,
2256 state
->udp_fd
, dhcp_handleifudp
, ifp
);
2263 dhcp_lastlease(void *arg
)
2265 struct interface
*ifp
= arg
;
2266 struct dhcp_state
*state
= D_STATE(ifp
);
2268 loginfox("%s: timed out contacting a DHCP server, using last lease",
2271 /* If we forked, stop here. */
2272 if (ifp
->ctx
->options
& DHCPCD_FORKED
)
2274 state
->interval
= 0;
2279 dhcp_message_new(struct bootp
**bootp
,
2280 const struct in_addr
*addr
, const struct in_addr
*mask
)
2285 if ((*bootp
= calloc(1, sizeof(**bootp
))) == NULL
)
2288 (*bootp
)->yiaddr
= addr
->s_addr
;
2291 cookie
= htonl(MAGIC_COOKIE
);
2292 memcpy(p
, &cookie
, sizeof(cookie
));
2293 p
+= sizeof(cookie
);
2295 if (mask
->s_addr
!= INADDR_ANY
) {
2296 *p
++ = DHO_SUBNETMASK
;
2297 *p
++ = sizeof(mask
->s_addr
);
2298 memcpy(p
, &mask
->s_addr
, sizeof(mask
->s_addr
));
2299 p
+= sizeof(mask
->s_addr
);
2303 return sizeof(**bootp
);
2307 #ifndef KERNEL_RFC5227
2309 dhcp_arp_defend_failed(struct arp_state
*astate
)
2312 dhcp_drop(astate
->iface
, "EXPIRED");
2313 dhcp_start1(astate
->iface
);
2317 #if !defined(KERNEL_RFC5227) || defined(ARPING)
2318 static struct arp_state
*
2319 dhcp_arp_new(struct interface
*ifp
, struct in_addr
*addr
)
2321 struct arp_state
*astate
;
2323 astate
= arp_new(ifp
, addr
);
2327 astate
->found_cb
= dhcp_arp_found
;
2328 astate
->not_found_cb
= dhcp_arp_not_found
;
2329 #ifdef KERNEL_RFC5227
2330 astate
->announced_cb
= dhcp_arp_announced
;
2332 astate
->defend_failed_cb
= dhcp_arp_defend_failed
;
2339 #if defined(ARP) || defined(KERNEL_RFC5227)
2341 dhcp_arp_address(struct interface
*ifp
)
2343 struct dhcp_state
*state
;
2344 struct in_addr addr
;
2345 struct ipv4_addr
*ia
;
2347 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
2349 state
= D_STATE(ifp
);
2350 addr
.s_addr
= state
->offer
->yiaddr
== INADDR_ANY
?
2351 state
->offer
->ciaddr
: state
->offer
->yiaddr
;
2352 /* If the interface already has the address configured
2353 * then we can't ARP for duplicate detection. */
2354 ia
= ipv4_iffindaddr(ifp
, &addr
, NULL
);
2355 #ifdef IN_IFF_NOTUSEABLE
2356 if (ia
== NULL
|| ia
->addr_flags
& IN_IFF_NOTUSEABLE
) {
2357 state
->state
= DHS_PROBE
;
2359 struct dhcp_lease l
;
2361 get_lease(ifp
, &l
, state
->offer
, state
->offer_len
);
2362 /* Add the address now, let the kernel handle DAD. */
2363 ipv4_addaddr(ifp
, &l
.addr
, &l
.mask
, &l
.brd
,
2364 l
.leasetime
, l
.rebindtime
);
2366 loginfox("%s: waiting for DAD on %s",
2367 ifp
->name
, inet_ntoa(addr
));
2371 if (!(ifp
->flags
& IFF_NOARP
) &&
2372 ifp
->options
->options
& DHCPCD_ARP
&&
2375 struct arp_state
*astate
;
2376 struct dhcp_lease l
;
2378 astate
= dhcp_arp_new(ifp
, &addr
);
2382 state
->state
= DHS_PROBE
;
2383 get_lease(ifp
, &l
, state
->offer
, state
->offer_len
);
2384 loginfox("%s: probing address %s/%d",
2385 ifp
->name
, inet_ntoa(l
.addr
), inet_ntocidr(l
.mask
));
2386 /* We need to handle DAD. */
2396 dhcp_arp_bind(struct interface
*ifp
)
2399 if (ifp
->ctx
->options
& DHCPCD_TEST
||
2400 dhcp_arp_address(ifp
) == 1)
2406 dhcp_static(struct interface
*ifp
)
2408 struct if_options
*ifo
;
2409 struct dhcp_state
*state
;
2410 struct ipv4_addr
*ia
;
2412 state
= D_STATE(ifp
);
2416 if (ifo
->req_addr
.s_addr
== INADDR_ANY
&&
2417 (ia
= ipv4_iffindaddr(ifp
, NULL
, NULL
)) == NULL
)
2419 loginfox("%s: waiting for 3rd party to "
2420 "configure IP address", ifp
->name
);
2421 state
->reason
= "3RDPARTY";
2422 script_runreason(ifp
, state
->reason
);
2426 state
->offer_len
= dhcp_message_new(&state
->offer
,
2427 ia
? &ia
->addr
: &ifo
->req_addr
,
2428 ia
? &ia
->mask
: &ifo
->req_mask
);
2429 if (state
->offer_len
)
2430 #if defined(ARP) || defined(KERNEL_RFC5227)
2438 dhcp_inform(struct interface
*ifp
)
2440 struct dhcp_state
*state
;
2441 struct if_options
*ifo
;
2442 struct ipv4_addr
*ia
;
2444 state
= D_STATE(ifp
);
2447 state
->state
= DHS_INFORM
;
2449 state
->offer
= NULL
;
2450 state
->offer_len
= 0;
2452 if (ifo
->req_addr
.s_addr
== INADDR_ANY
) {
2453 ia
= ipv4_iffindaddr(ifp
, NULL
, NULL
);
2455 loginfox("%s: waiting for 3rd party to "
2456 "configure IP address",
2458 if (!(ifp
->ctx
->options
& DHCPCD_TEST
)) {
2459 state
->reason
= "3RDPARTY";
2460 script_runreason(ifp
, state
->reason
);
2465 ia
= ipv4_iffindaddr(ifp
, &ifo
->req_addr
, &ifo
->req_mask
);
2467 if (ifp
->ctx
->options
& DHCPCD_TEST
) {
2468 logerrx("%s: cannot add IP address in test mode",
2472 ia
= ipv4_iffindaddr(ifp
, &ifo
->req_addr
, NULL
);
2474 /* Netmask must be different, delete it. */
2475 ipv4_deladdr(ia
, 1);
2476 state
->offer_len
= dhcp_message_new(&state
->offer
,
2477 &ifo
->req_addr
, &ifo
->req_mask
);
2479 if (dhcp_arp_address(ifp
) == 0)
2482 ia
= ipv4_iffindaddr(ifp
,
2483 &ifo
->req_addr
, &ifo
->req_mask
);
2489 state
->offer_len
= dhcp_message_new(&state
->offer
,
2490 &ia
->addr
, &ia
->mask
);
2491 if (state
->offer_len
) {
2493 get_lease(ifp
, &state
->lease
, state
->offer
, state
->offer_len
);
2499 dhcp_reboot_newopts(struct interface
*ifp
, unsigned long long oldopts
)
2501 struct if_options
*ifo
;
2502 struct dhcp_state
*state
= D_STATE(ifp
);
2504 if (state
== NULL
|| state
->state
== DHS_NONE
)
2507 if ((ifo
->options
& (DHCPCD_INFORM
| DHCPCD_STATIC
) &&
2508 (state
->addr
== NULL
||
2509 state
->addr
->addr
.s_addr
!= ifo
->req_addr
.s_addr
)) ||
2510 (oldopts
& (DHCPCD_INFORM
| DHCPCD_STATIC
) &&
2511 !(ifo
->options
& (DHCPCD_INFORM
| DHCPCD_STATIC
))))
2513 dhcp_drop(ifp
, "EXPIRE");
2519 dhcp_activeaddr(const struct interface
*ifp
, const struct in_addr
*addr
)
2521 const struct interface
*ifp1
;
2522 const struct dhcp_state
*state
;
2524 TAILQ_FOREACH(ifp1
, ifp
->ctx
->ifaces
, next
) {
2527 if ((state
= D_CSTATE(ifp1
)) == NULL
)
2529 switch(state
->state
) {
2539 if (state
->lease
.addr
.s_addr
== addr
->s_addr
)
2547 dhcp_reboot(struct interface
*ifp
)
2549 struct if_options
*ifo
;
2550 struct dhcp_state
*state
= D_STATE(ifp
);
2552 struct ipv4_addr
*ia
;
2555 if (state
== NULL
|| state
->state
== DHS_NONE
)
2558 state
->state
= DHS_REBOOT
;
2559 state
->interval
= 0;
2561 if (ifo
->options
& DHCPCD_LINK
&& ifp
->carrier
<= LINK_DOWN
) {
2562 loginfox("%s: waiting for carrier", ifp
->name
);
2565 if (ifo
->options
& DHCPCD_STATIC
) {
2569 if (ifo
->options
& DHCPCD_INFORM
) {
2570 loginfox("%s: informing address of %s",
2571 ifp
->name
, inet_ntoa(state
->lease
.addr
));
2575 if (ifo
->reboot
== 0 || state
->offer
== NULL
) {
2579 if (!IS_DHCP(state
->offer
))
2582 loginfox("%s: rebinding lease of %s",
2583 ifp
->name
, inet_ntoa(state
->lease
.addr
));
2586 /* If the address exists on the interface and no other interface
2587 * is currently using it then announce it to ensure this
2588 * interface gets the reply. */
2589 ia
= ipv4_iffindaddr(ifp
, &state
->lease
.addr
, NULL
);
2591 !(ifp
->ctx
->options
& DHCPCD_TEST
) &&
2592 #ifdef IN_IFF_NOTUSEABLE
2593 !(ia
->addr_flags
& IN_IFF_NOTUSEABLE
) &&
2595 dhcp_activeaddr(ifp
, &state
->lease
.addr
) == 0)
2596 arp_ifannounceaddr(ifp
, &state
->lease
.addr
);
2600 state
->lease
.server
.s_addr
= INADDR_ANY
;
2601 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
2604 /* Need to add this before dhcp_expire and friends. */
2605 if (!ifo
->fallback
&& ifo
->options
& DHCPCD_IPV4LL
)
2606 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
2607 ifo
->reboot
, ipv4ll_start
, ifp
);
2610 if (ifo
->options
& DHCPCD_LASTLEASE
&& state
->lease
.frominfo
)
2611 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
2612 ifo
->reboot
, dhcp_lastlease
, ifp
);
2613 else if (!(ifo
->options
& DHCPCD_INFORM
))
2614 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
2615 ifo
->reboot
, dhcp_expire
, ifp
);
2617 /* Don't bother ARP checking as the server could NAK us first.
2618 * Don't call dhcp_request as that would change the state */
2623 dhcp_drop(struct interface
*ifp
, const char *reason
)
2625 struct dhcp_state
*state
;
2630 state
= D_STATE(ifp
);
2631 /* dhcp_start may just have been called and we don't yet have a state
2632 * but we do have a timeout, so punt it. */
2633 if (state
== NULL
|| state
->state
== DHS_NONE
) {
2634 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
2639 if (state
->addr
!= NULL
)
2640 arp_freeaddr(ifp
, &state
->addr
->addr
);
2643 state
->arping_index
= -1;
2646 if (ifp
->options
->options
& DHCPCD_RELEASE
&&
2647 !(ifp
->options
->options
& DHCPCD_INFORM
))
2649 /* Failure to send the release may cause this function to
2650 * re-enter so guard by setting the state. */
2651 if (state
->state
== DHS_RELEASE
)
2653 state
->state
= DHS_RELEASE
;
2655 unlink(state
->leasefile
);
2656 if (ifp
->carrier
> LINK_DOWN
&&
2657 state
->new != NULL
&&
2658 state
->lease
.server
.s_addr
!= INADDR_ANY
)
2660 loginfox("%s: releasing lease of %s",
2661 ifp
->name
, inet_ntoa(state
->lease
.addr
));
2663 send_message(ifp
, DHCP_RELEASE
, NULL
);
2665 /* Give the packet a chance to go */
2666 ts
.tv_sec
= RELEASE_DELAY_S
;
2667 ts
.tv_nsec
= RELEASE_DELAY_NS
;
2668 nanosleep(&ts
, NULL
);
2673 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
2675 dhcp_auth_reset(&state
->auth
);
2678 state
->state
= DHS_NONE
;
2680 state
->offer
= NULL
;
2681 state
->offer_len
= 0;
2683 state
->old
= state
->new;
2684 state
->old_len
= state
->new_len
;
2687 state
->reason
= reason
;
2688 ipv4_applyaddr(ifp
);
2692 state
->lease
.addr
.s_addr
= 0;
2693 ifp
->options
->options
&= ~(DHCPCD_CSR_WARNED
|
2694 DHCPCD_ROUTER_HOST_ROUTE_WARNED
);
2698 blacklisted_ip(const struct if_options
*ifo
, in_addr_t addr
)
2702 for (i
= 0; i
< ifo
->blacklist_len
; i
+= 2)
2703 if (ifo
->blacklist
[i
] == (addr
& ifo
->blacklist
[i
+ 1]))
2708 #define WHTLST_NONE 0
2709 #define WHTLST_MATCH 1
2710 #define WHTLST_NOMATCH 2
2712 whitelisted_ip(const struct if_options
*ifo
, in_addr_t addr
)
2716 if (ifo
->whitelist_len
== 0)
2718 for (i
= 0; i
< ifo
->whitelist_len
; i
+= 2)
2719 if (ifo
->whitelist
[i
] == (addr
& ifo
->whitelist
[i
+ 1]))
2720 return WHTLST_MATCH
;
2721 return WHTLST_NOMATCH
;
2725 log_dhcp(logfunc_t
*logfunc
, const char *msg
,
2726 const struct interface
*ifp
, const struct bootp
*bootp
, size_t bootp_len
,
2727 const struct in_addr
*from
, int ad
)
2730 char *a
, sname
[sizeof(bootp
->sname
) * 4];
2731 struct in_addr addr
;
2735 if (strcmp(msg
, "NAK:") == 0) {
2736 a
= get_option_string(ifp
->ctx
, bootp
, bootp_len
, DHO_MESSAGE
);
2742 tmpl
= (al
* 4) + 1;
2749 print_string(tmp
, tmpl
, OT_STRING
, (uint8_t *)a
, al
);
2753 } else if (ad
&& bootp
->yiaddr
!= 0) {
2754 addr
.s_addr
= bootp
->yiaddr
;
2755 a
= strdup(inet_ntoa(addr
));
2764 r
= get_option_addr(ifp
->ctx
, &addr
, bootp
, bootp_len
, DHO_SERVERID
);
2765 if (get_option_uint8(ifp
->ctx
, &overl
, bootp
, bootp_len
,
2766 DHO_OPTSOVERLOADED
) == -1)
2768 if (bootp
->sname
[0] && r
== 0 && !(overl
& 2)) {
2769 print_string(sname
, sizeof(sname
), OT_STRING
| OT_DOMAIN
,
2770 bootp
->sname
, sizeof(bootp
->sname
));
2772 logfunc("%s: %s %s %s `%s'",
2773 ifp
->name
, msg
, tfrom
, inet_ntoa(addr
), sname
);
2775 logfunc("%s: %s %s %s %s `%s'",
2776 ifp
->name
, msg
, a
, tfrom
, inet_ntoa(addr
), sname
);
2783 logfunc("%s: %s %s %s",
2784 ifp
->name
, msg
, tfrom
, inet_ntoa(addr
));
2786 logfunc("%s: %s %s %s %s",
2787 ifp
->name
, msg
, a
, tfrom
, inet_ntoa(addr
));
2792 /* If we're sharing the same IP address with another interface on the
2793 * same network, we may receive the DHCP reply on the wrong interface.
2794 * Try and re-direct it here. */
2796 dhcp_redirect_dhcp(struct interface
*ifp
, struct bootp
*bootp
, size_t bootp_len
,
2797 const struct in_addr
*from
)
2799 struct interface
*ifn
;
2800 const struct dhcp_state
*state
;
2803 xid
= ntohl(bootp
->xid
);
2804 TAILQ_FOREACH(ifn
, ifp
->ctx
->ifaces
, next
) {
2805 state
= D_CSTATE(ifn
);
2806 if (state
== NULL
|| state
->state
== DHS_NONE
)
2808 if (state
->xid
!= xid
)
2810 if (ifn
->hwlen
<= sizeof(bootp
->chaddr
) &&
2811 memcmp(bootp
->chaddr
, ifn
->hwaddr
, ifn
->hwlen
))
2813 logdebugx("%s: redirecting DHCP message to %s",
2814 ifp
->name
, ifn
->name
);
2815 dhcp_handledhcp(ifn
, bootp
, bootp_len
, from
);
2820 dhcp_handledhcp(struct interface
*ifp
, struct bootp
*bootp
, size_t bootp_len
,
2821 const struct in_addr
*from
)
2823 struct dhcp_state
*state
= D_STATE(ifp
);
2824 struct if_options
*ifo
= ifp
->options
;
2825 struct dhcp_lease
*lease
= &state
->lease
;
2827 struct in_addr addr
;
2832 const uint8_t *auth
;
2835 #ifdef IN_IFF_DUPLICATED
2836 struct ipv4_addr
*ia
;
2839 #define LOGDHCP0(l, m) \
2840 log_dhcp((l), (m), ifp, bootp, bootp_len, from, 0)
2841 #define LOGDHCP(l, m) \
2842 log_dhcp((l), (m), ifp, bootp, bootp_len, from, 1)
2844 if (bootp
->op
!= BOOTREPLY
) {
2845 logdebugx("%s: op (%d) is not BOOTREPLY",
2846 ifp
->name
, bootp
->op
);
2850 if (state
->xid
!= ntohl(bootp
->xid
)) {
2851 if (state
->state
!= DHS_BOUND
&& state
->state
!= DHS_NONE
)
2852 logdebugx("%s: wrong xid 0x%x (expecting 0x%x) from %s",
2853 ifp
->name
, ntohl(bootp
->xid
), state
->xid
,
2855 dhcp_redirect_dhcp(ifp
, bootp
, bootp_len
, from
);
2859 if (ifp
->hwlen
<= sizeof(bootp
->chaddr
) &&
2860 memcmp(bootp
->chaddr
, ifp
->hwaddr
, ifp
->hwlen
))
2862 char buf
[sizeof(bootp
->chaddr
) * 3];
2864 logdebugx("%s: xid 0x%x is for hwaddr %s",
2865 ifp
->name
, ntohl(bootp
->xid
),
2866 hwaddr_ntoa(bootp
->chaddr
, sizeof(bootp
->chaddr
),
2868 dhcp_redirect_dhcp(ifp
, bootp
, bootp_len
, from
);
2875 i
= whitelisted_ip(ifp
->options
, from
->s_addr
);
2877 case WHTLST_NOMATCH
:
2878 logwarnx("%s: non whitelisted DHCP packet from %s",
2879 ifp
->name
, inet_ntoa(*from
));
2884 if (blacklisted_ip(ifp
->options
, from
->s_addr
) == 1) {
2885 logwarnx("%s: blacklisted DHCP packet from %s",
2886 ifp
->name
, inet_ntoa(*from
));
2891 /* We may have found a BOOTP server */
2892 if (get_option_uint8(ifp
->ctx
, &type
,
2893 bootp
, bootp_len
, DHO_MESSAGETYPE
) == -1)
2895 else if (ifo
->options
& DHCPCD_BOOTP
) {
2896 logdebugx("%s: ignoring DHCP reply (expecting BOOTP)",
2902 /* Authenticate the message */
2903 auth
= get_option(ifp
->ctx
, bootp
, bootp_len
,
2904 DHO_AUTHENTICATION
, &auth_len
);
2906 if (dhcp_auth_validate(&state
->auth
, &ifo
->auth
,
2907 (uint8_t *)bootp
, bootp_len
, 4, type
,
2908 auth
, auth_len
) == NULL
)
2910 LOGDHCP0(logerrx
, "authentication failed");
2913 if (state
->auth
.token
)
2914 logdebugx("%s: validated using 0x%08" PRIu32
,
2915 ifp
->name
, state
->auth
.token
->secretid
);
2917 loginfox("%s: accepted reconfigure key", ifp
->name
);
2918 } else if (ifo
->auth
.options
& DHCPCD_AUTH_SEND
) {
2919 if (ifo
->auth
.options
& DHCPCD_AUTH_REQUIRE
) {
2920 LOGDHCP0(logerrx
, "no authentication");
2923 LOGDHCP0(logwarnx
, "no authentication");
2928 if (type
== DHCP_FORCERENEW
) {
2929 if (from
->s_addr
== INADDR_ANY
||
2930 from
->s_addr
== INADDR_BROADCAST
)
2932 LOGDHCP(logerrx
, "discarding Force Renew");
2937 LOGDHCP(logerrx
, "unauthenticated Force Renew");
2938 if (ifo
->auth
.options
& DHCPCD_AUTH_REQUIRE
)
2941 if (state
->state
!= DHS_BOUND
&& state
->state
!= DHS_INFORM
) {
2942 LOGDHCP(logdebugx
, "not bound, ignoring Force Renew");
2945 LOGDHCP(loginfox
, "Force Renew from");
2946 /* The rebind and expire timings are still the same, we just
2947 * enter the renew state early */
2948 if (state
->state
== DHS_BOUND
)
2951 eloop_timeout_delete(ifp
->ctx
->eloop
,
2956 LOGDHCP(logerrx
, "unauthenticated Force Renew");
2961 if (state
->state
== DHS_BOUND
) {
2962 /* Before we supported FORCERENEW we closed off the raw
2963 * port so we effectively ignored all messages.
2964 * As such we'll not log by default here. */
2965 //LOGDHCP(logdebugx, "bound, ignoring");
2969 if (state
->state
== DHS_PROBE
) {
2970 /* Ignore any DHCP messages whilst probing a lease to bind. */
2971 LOGDHCP(logdebugx
, "probing, ignoring");
2975 /* reset the message counter */
2976 state
->interval
= 0;
2978 /* Ensure that no reject options are present */
2979 for (i
= 1; i
< 255; i
++) {
2980 if (has_option_mask(ifo
->rejectmask
, i
) &&
2981 get_option_uint8(ifp
->ctx
, &tmp
,
2982 bootp
, bootp_len
, (uint8_t)i
) == 0)
2984 LOGDHCP(logwarnx
, "reject DHCP");
2989 if (type
== DHCP_NAK
) {
2990 /* For NAK, only check if we require the ServerID */
2991 if (has_option_mask(ifo
->requiremask
, DHO_SERVERID
) &&
2992 get_option_addr(ifp
->ctx
, &addr
,
2993 bootp
, bootp_len
, DHO_SERVERID
) == -1)
2995 LOGDHCP(logwarnx
, "reject NAK");
2999 /* We should restart on a NAK */
3000 LOGDHCP(logwarnx
, "NAK:");
3001 if ((msg
= get_option_string(ifp
->ctx
,
3002 bootp
, bootp_len
, DHO_MESSAGE
)))
3004 logwarnx("%s: message: %s", ifp
->name
, msg
);
3007 if (state
->state
== DHS_INFORM
) /* INFORM should not be NAKed */
3009 if (!(ifp
->ctx
->options
& DHCPCD_TEST
)) {
3010 dhcp_drop(ifp
, "NAK");
3011 unlink(state
->leasefile
);
3014 /* If we constantly get NAKS then we should slowly back off */
3015 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
3016 state
->nakoff
, dhcp_discover
, ifp
);
3017 if (state
->nakoff
== 0)
3021 if (state
->nakoff
> NAKOFF_MAX
)
3022 state
->nakoff
= NAKOFF_MAX
;
3027 /* Ensure that all required options are present */
3028 for (i
= 1; i
< 255; i
++) {
3029 if (has_option_mask(ifo
->requiremask
, i
) &&
3030 get_option_uint8(ifp
->ctx
, &tmp
,
3031 bootp
, bootp_len
, (uint8_t)i
) != 0)
3033 /* If we are BOOTP, then ignore the need for serverid.
3034 * To ignore BOOTP, require dhcp_message_type.
3035 * However, nothing really stops BOOTP from providing
3036 * DHCP style options as well so the above isn't
3038 if (type
== 0 && i
== DHO_SERVERID
)
3040 LOGDHCP(logwarnx
, "reject DHCP");
3045 /* DHCP Auto-Configure, RFC 2563 */
3046 if (type
== DHCP_OFFER
&& bootp
->yiaddr
== 0) {
3047 LOGDHCP(logwarnx
, "no address given");
3048 if ((msg
= get_option_string(ifp
->ctx
,
3049 bootp
, bootp_len
, DHO_MESSAGE
)))
3051 logwarnx("%s: message: %s", ifp
->name
, msg
);
3055 if (state
->state
== DHS_DISCOVER
&&
3056 get_option_uint8(ifp
->ctx
, &tmp
, bootp
, bootp_len
,
3057 DHO_AUTOCONFIGURE
) == 0)
3061 LOGDHCP(logwarnx
, "IPv4LL disabled from");
3068 LOGDHCP(logwarnx
, "IPv4LL enabled from");
3072 logerrx("%s: unknown auto configuration "
3077 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
3078 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
3079 DHCP_MAX
, dhcp_discover
, ifp
);
3085 /* Ensure that the address offered is valid */
3086 if ((type
== 0 || type
== DHCP_OFFER
|| type
== DHCP_ACK
) &&
3087 (bootp
->ciaddr
== INADDR_ANY
|| bootp
->ciaddr
== INADDR_BROADCAST
)
3089 (bootp
->yiaddr
== INADDR_ANY
|| bootp
->yiaddr
== INADDR_BROADCAST
))
3091 LOGDHCP(logwarnx
, "reject invalid address");
3095 #ifdef IN_IFF_DUPLICATED
3096 ia
= ipv4_iffindaddr(ifp
, &lease
->addr
, NULL
);
3097 if (ia
&& ia
->addr_flags
& IN_IFF_DUPLICATED
) {
3098 LOGDHCP(logwarnx
, "declined duplicate address");
3101 ipv4_deladdr(ia
, 0);
3102 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
3103 eloop_timeout_add_sec(ifp
->ctx
->eloop
,
3104 DHCP_RAND_MAX
, dhcp_discover
, ifp
);
3109 bootp_copied
= false;
3110 if ((type
== 0 || type
== DHCP_OFFER
) && state
->state
== DHS_DISCOVER
) {
3111 lease
->frominfo
= 0;
3112 lease
->addr
.s_addr
= bootp
->yiaddr
;
3113 memcpy(&lease
->cookie
, bootp
->vend
, sizeof(lease
->cookie
));
3115 get_option_addr(ifp
->ctx
,
3116 &lease
->server
, bootp
, bootp_len
, DHO_SERVERID
) != 0)
3117 lease
->server
.s_addr
= INADDR_ANY
;
3119 /* Test for rapid commit in the OFFER */
3120 if (!(ifp
->ctx
->options
& DHCPCD_TEST
) &&
3121 has_option_mask(ifo
->requestmask
, DHO_RAPIDCOMMIT
) &&
3122 get_option(ifp
->ctx
, bootp
, bootp_len
,
3123 DHO_RAPIDCOMMIT
, NULL
))
3125 state
->state
= DHS_REQUEST
;
3129 LOGDHCP(loginfox
, "offered");
3130 if (state
->offer_len
< bootp_len
) {
3132 if ((state
->offer
= malloc(bootp_len
)) == NULL
) {
3134 state
->offer_len
= 0;
3138 state
->offer_len
= bootp_len
;
3139 memcpy(state
->offer
, bootp
, bootp_len
);
3140 bootp_copied
= true;
3141 if (ifp
->ctx
->options
& DHCPCD_TEST
) {
3143 state
->old
= state
->new;
3144 state
->old_len
= state
->new_len
;
3145 state
->new = state
->offer
;
3146 state
->new_len
= state
->offer_len
;
3147 state
->offer
= NULL
;
3148 state
->offer_len
= 0;
3149 state
->reason
= "TEST";
3150 script_runreason(ifp
, state
->reason
);
3151 eloop_exit(ifp
->ctx
->eloop
, EXIT_SUCCESS
);
3152 state
->bpf_flags
|= BPF_EOF
;
3155 eloop_timeout_delete(ifp
->ctx
->eloop
, send_discover
, ifp
);
3156 /* We don't request BOOTP addresses */
3158 /* We used to ARP check here, but that seems to be in
3159 * violation of RFC2131 where it only describes
3160 * DECLINE after REQUEST.
3161 * It also seems that some MS DHCP servers actually
3162 * ignore DECLINE if no REQUEST, ie we decline a
3170 if (type
== DHCP_OFFER
) {
3171 LOGDHCP(logwarnx
, "ignoring offer of");
3175 /* We should only be dealing with acks */
3176 if (type
!= DHCP_ACK
) {
3177 LOGDHCP(logerr
, "not ACK or OFFER");
3181 if (state
->state
== DHS_DISCOVER
) {
3182 /* We only allow ACK of rapid commit DISCOVER. */
3183 if (has_option_mask(ifo
->requestmask
,
3185 get_option(ifp
->ctx
, bootp
, bootp_len
,
3186 DHO_RAPIDCOMMIT
, NULL
))
3187 state
->state
= DHS_REQUEST
;
3189 LOGDHCP(logdebugx
, "ignoring ack of");
3195 if (!(ifo
->options
& DHCPCD_INFORM
))
3196 LOGDHCP(logdebugx
, "acknowledged");
3198 ifo
->options
&= ~DHCPCD_STATIC
;
3201 /* No NAK, so reset the backoff
3202 * We don't reset on an OFFER message because the server could
3203 * potentially NAK the REQUEST. */
3206 /* BOOTP could have already assigned this above. */
3207 if (!bootp_copied
) {
3208 if (state
->offer_len
< bootp_len
) {
3210 if ((state
->offer
= malloc(bootp_len
)) == NULL
) {
3212 state
->offer_len
= 0;
3216 state
->offer_len
= bootp_len
;
3217 memcpy(state
->offer
, bootp
, bootp_len
);
3220 lease
->frominfo
= 0;
3221 eloop_timeout_delete(ifp
->ctx
->eloop
, NULL
, ifp
);
3223 #if defined(ARP) || defined(KERNEL_RFC5227)
3231 get_udp_data(void *packet
, size_t *len
)
3233 const struct ip
*ip
= packet
;
3234 size_t ip_hl
= (size_t)ip
->ip_hl
* 4;
3237 p
+= ip_hl
+ sizeof(struct udphdr
);
3238 *len
= (size_t)ntohs(ip
->ip_len
) - sizeof(struct udphdr
) - ip_hl
;
3243 valid_udp_packet(void *packet
, size_t plen
, struct in_addr
*from
,
3246 struct ip
*ip
= packet
;
3247 struct ip pseudo_ip
= {
3248 .ip_p
= IPPROTO_UDP
,
3249 .ip_src
= ip
->ip_src
,
3250 .ip_dst
= ip
->ip_dst
3253 uint16_t ip_len
, uh_sum
;
3257 if (plen
< sizeof(*ip
)) {
3259 from
->s_addr
= INADDR_ANY
;
3265 from
->s_addr
= ip
->ip_src
.s_addr
;
3267 ip_hlen
= (size_t)ip
->ip_hl
* 4;
3268 if (in_cksum(ip
, ip_hlen
, NULL
) != 0) {
3273 /* Check we have a payload */
3274 ip_len
= ntohs(ip
->ip_len
);
3275 if (ip_len
<= ip_hlen
+ sizeof(*udp
)) {
3279 /* Check we don't go beyond the payload */
3280 if (ip_len
> plen
) {
3285 if (flags
& BPF_PARTIALCSUM
)
3288 /* UDP checksum is based on a pseudo IP header alongside
3289 * the UDP header and payload. */
3290 udp
= (struct udphdr
*)(void *)((char *)ip
+ ip_hlen
);
3291 if (udp
->uh_sum
== 0)
3294 uh_sum
= udp
->uh_sum
;
3296 pseudo_ip
.ip_len
= udp
->uh_ulen
;
3298 in_cksum(&pseudo_ip
, sizeof(pseudo_ip
), &csum
);
3299 csum
= in_cksum(udp
, ntohs(udp
->uh_ulen
), &csum
);
3300 if (csum
!= uh_sum
) {
3309 dhcp_handlebootp(struct interface
*ifp
, struct bootp
*bootp
, size_t len
,
3310 struct in_addr
*from
)
3314 /* udp_len must be correct because the values are checked in
3315 * valid_udp_packet(). */
3316 if (len
< offsetof(struct bootp
, vend
)) {
3317 logerrx("%s: truncated packet (%zu) from %s",
3318 ifp
->name
, len
, inet_ntoa(*from
));
3321 /* To make our IS_DHCP macro easy, ensure the vendor
3322 * area has at least 4 octets. */
3323 v
= len
- offsetof(struct bootp
, vend
);
3325 bootp
->vend
[v
++] = '\0';
3329 dhcp_handledhcp(ifp
, bootp
, len
, from
);
3333 dhcp_handlepacket(struct interface
*ifp
, uint8_t *data
, size_t len
)
3335 struct bootp
*bootp
;
3336 struct in_addr from
;
3338 const struct dhcp_state
*state
= D_CSTATE(ifp
);
3340 if (valid_udp_packet(data
, len
, &from
, state
->bpf_flags
) == -1) {
3341 if (errno
== EINVAL
)
3342 logerrx("%s: checksum failure from %s",
3343 ifp
->name
, inet_ntoa(from
));
3345 logerr("%s: invalid UDP packet from %s",
3346 ifp
->name
, inet_ntoa(from
));
3351 * DHCP has a variable option area rather than a fixed vendor area.
3352 * Because DHCP uses the BOOTP protocol it should still send BOOTP
3353 * sized packets to be RFC compliant.
3354 * However some servers send a truncated vendor area.
3355 * dhcpcd can work fine without the vendor area being sent.
3357 bootp
= get_udp_data(data
, &udp_len
);
3358 dhcp_handlebootp(ifp
, bootp
, udp_len
, &from
);
3362 dhcp_readpacket(void *arg
)
3364 struct interface
*ifp
= arg
;
3365 uint8_t buf
[MTU_MAX
];
3367 struct dhcp_state
*state
= D_STATE(ifp
);
3369 /* Some RAW mechanisms are generic file descriptors, not sockets.
3370 * This means we have no kernel call to just get one packet,
3371 * so we have to process the entire buffer. */
3372 state
->bpf_flags
&= ~BPF_EOF
;
3373 state
->bpf_flags
|= BPF_READING
;
3374 while (!(state
->bpf_flags
& BPF_EOF
)) {
3375 bytes
= bpf_read(ifp
, state
->bpf_fd
, buf
, sizeof(buf
),
3378 if (state
->state
!= DHS_NONE
) {
3379 logerr("%s: %s", __func__
, ifp
->name
);
3384 dhcp_handlepacket(ifp
, buf
, (size_t)bytes
);
3385 /* Check we still have a state after processing. */
3386 if ((state
= D_STATE(ifp
)) == NULL
)
3390 state
->bpf_flags
&= ~BPF_READING
;
3394 dhcp_readudp(struct dhcpcd_ctx
*ctx
, struct interface
*ifp
)
3396 const struct dhcp_state
*state
;
3397 struct sockaddr_in from
;
3398 unsigned char buf
[10 * 1024]; /* Maximum MTU */
3399 struct iovec iov
= {
3401 .iov_len
= sizeof(buf
),
3404 unsigned char ctl
[CMSG_SPACE(sizeof(struct in_pktinfo
))] = { 0 };
3405 char sfrom
[INET_ADDRSTRLEN
];
3407 struct msghdr msg
= {
3408 .msg_name
= &from
, .msg_namelen
= sizeof(from
),
3409 .msg_iov
= &iov
, .msg_iovlen
= 1,
3411 .msg_control
= ctl
, .msg_controllen
= sizeof(ctl
),
3418 state
= D_CSTATE(ifp
);
3423 bytes
= recvmsg(s
, &msg
, 0);
3430 inet_ntop(AF_INET
, &from
.sin_addr
, sfrom
, sizeof(sfrom
));
3433 ifp
= if_findifpfromcmsg(ctx
, &msg
, NULL
);
3438 state
= D_CSTATE(ifp
);
3439 if (state
== NULL
) {
3440 logdebugx("%s: received BOOTP for inactive interface",
3446 if (state
->bpf_fd
!= -1) {
3447 /* Avoid a duplicate read if BPF is open for the interface. */
3451 dhcp_handlebootp(ifp
, (struct bootp
*)(void *)buf
, (size_t)bytes
,
3457 dhcp_handleudp(void *arg
)
3459 struct dhcpcd_ctx
*ctx
= arg
;
3461 dhcp_readudp(ctx
, NULL
);
3466 dhcp_handleifudp(void *arg
)
3468 struct interface
*ifp
= arg
;
3470 dhcp_readudp(ifp
->ctx
, ifp
);
3476 dhcp_openbpf(struct interface
*ifp
)
3478 struct dhcp_state
*state
;
3480 state
= D_STATE(ifp
);
3481 if (state
->bpf_fd
!= -1)
3484 state
->bpf_fd
= bpf_open(ifp
, bpf_bootp
);
3485 if (state
->bpf_fd
== -1) {
3486 if (errno
== ENOENT
) {
3487 logerrx("%s not found", bpf_name
);
3488 /* May as well disable IPv4 entirely at
3489 * this point as we really need it. */
3490 ifp
->options
->options
&= ~DHCPCD_IPV4
;
3492 logerr("%s: %s", __func__
, ifp
->name
);
3496 eloop_event_add(ifp
->ctx
->eloop
,
3497 state
->bpf_fd
, dhcp_readpacket
, ifp
);
3502 dhcp_dump(struct interface
*ifp
)
3504 struct dhcp_state
*state
;
3506 ifp
->if_data
[IF_DATA_DHCP
] = state
= calloc(1, sizeof(*state
));
3510 dhcp_set_leasefile(state
->leasefile
, sizeof(state
->leasefile
),
3512 state
->new_len
= read_lease(ifp
, &state
->new);
3513 if (state
->new == NULL
) {
3515 *ifp
->name
? ifp
->name
: state
->leasefile
, __func__
);
3518 state
->reason
= "DUMP";
3519 return script_runreason(ifp
, state
->reason
);
3527 dhcp_free(struct interface
*ifp
)
3529 struct dhcp_state
*state
= D_STATE(ifp
);
3530 struct dhcpcd_ctx
*ctx
;
3537 state
->state
= DHS_NONE
;
3541 free(state
->clientid
);
3546 /* If we don't have any more DHCP enabled interfaces,
3547 * close the global socket and release resources */
3549 TAILQ_FOREACH(ifp
, ctx
->ifaces
, next
) {
3550 state
= D_STATE(ifp
);
3551 if (state
!= NULL
&& state
->state
!= DHS_NONE
)
3556 if (ctx
->udp_fd
!= -1) {
3557 eloop_event_delete(ctx
->eloop
, ctx
->udp_fd
);
3562 free(ctx
->opt_buffer
);
3563 ctx
->opt_buffer
= NULL
;
3568 dhcp_initstate(struct interface
*ifp
)
3570 struct dhcp_state
*state
;
3572 state
= D_STATE(ifp
);
3576 ifp
->if_data
[IF_DATA_DHCP
] = calloc(1, sizeof(*state
));
3577 state
= D_STATE(ifp
);
3581 state
->state
= DHS_NONE
;
3582 /* 0 is a valid fd, so init to -1 */
3586 state
->arping_index
= -1;
3592 dhcp_init(struct interface
*ifp
)
3594 struct dhcp_state
*state
;
3595 const struct if_options
*ifo
;
3597 char buf
[(sizeof(ifo
->clientid
) - 1) * 3];
3599 if (dhcp_initstate(ifp
) == -1)
3602 state
= D_STATE(ifp
);
3603 state
->state
= DHS_INIT
;
3604 state
->reason
= "PREINIT";
3606 dhcp_set_leasefile(state
->leasefile
, sizeof(state
->leasefile
),
3610 /* We need to drop the leasefile so that dhcp_start
3611 * doesn't load it. */
3612 if (ifo
->options
& DHCPCD_REQUEST
)
3613 unlink(state
->leasefile
);
3615 free(state
->clientid
);
3616 state
->clientid
= NULL
;
3618 if (*ifo
->clientid
) {
3619 state
->clientid
= malloc((size_t)(ifo
->clientid
[0] + 1));
3620 if (state
->clientid
== NULL
)
3622 memcpy(state
->clientid
, ifo
->clientid
,
3623 (size_t)(ifo
->clientid
[0]) + 1);
3624 } else if (ifo
->options
& DHCPCD_CLIENTID
) {
3625 if (ifo
->options
& DHCPCD_DUID
) {
3626 state
->clientid
= malloc(ifp
->ctx
->duid_len
+ 6);
3627 if (state
->clientid
== NULL
)
3629 state
->clientid
[0] =(uint8_t)(ifp
->ctx
->duid_len
+ 5);
3630 state
->clientid
[1] = 255; /* RFC 4361 */
3631 memcpy(state
->clientid
+ 2, ifo
->iaid
, 4);
3632 memcpy(state
->clientid
+ 6, ifp
->ctx
->duid
,
3633 ifp
->ctx
->duid_len
);
3635 len
= (uint8_t)(ifp
->hwlen
+ 1);
3636 state
->clientid
= malloc((size_t)len
+ 1);
3637 if (state
->clientid
== NULL
)
3639 state
->clientid
[0] = len
;
3640 state
->clientid
[1] = (uint8_t)ifp
->family
;
3641 memcpy(state
->clientid
+ 2, ifp
->hwaddr
,
3646 if (ifo
->options
& DHCPCD_DUID
)
3647 /* Don't bother logging as DUID and IAID are reported
3648 * at device start. */
3651 if (ifo
->options
& DHCPCD_CLIENTID
)
3652 logdebugx("%s: using ClientID %s", ifp
->name
,
3653 hwaddr_ntoa(state
->clientid
+ 1, state
->clientid
[0],
3655 else if (ifp
->hwlen
)
3656 logdebugx("%s: using hwaddr %s", ifp
->name
,
3657 hwaddr_ntoa(ifp
->hwaddr
, ifp
->hwlen
, buf
, sizeof(buf
)));
3666 dhcp_start1(void *arg
)
3668 struct interface
*ifp
= arg
;
3669 struct dhcpcd_ctx
*ctx
= ifp
->ctx
;
3670 struct if_options
*ifo
= ifp
->options
;
3671 struct dhcp_state
*state
;
3676 if (!(ifo
->options
& DHCPCD_IPV4
))
3679 /* Listen on *.*.*.*:bootpc so that the kernel never sends an
3680 * ICMP port unreachable message back to the DHCP server.
3681 * Only do this in master mode so we don't swallow messages
3682 * for dhcpcd running on another interface. */
3683 if (ctx
->udp_fd
== -1 && ctx
->options
& DHCPCD_MASTER
) {
3684 ctx
->udp_fd
= dhcp_openudp(NULL
);
3685 if (ctx
->udp_fd
== -1) {
3686 /* Don't log an error if some other process
3687 * is handling this. */
3688 if (errno
!= EADDRINUSE
)
3689 logerr("%s: dhcp_openudp", __func__
);
3691 eloop_event_add(ctx
->eloop
,
3692 ctx
->udp_fd
, dhcp_handleudp
, ctx
);
3695 if (dhcp_init(ifp
) == -1) {
3696 logerr("%s: dhcp_init", ifp
->name
);
3700 state
= D_STATE(ifp
);
3701 clock_gettime(CLOCK_MONOTONIC
, &state
->started
);
3702 state
->interval
= 0;
3704 state
->offer
= NULL
;
3705 state
->offer_len
= 0;
3708 if (ifo
->arping_len
&& state
->arping_index
< ifo
->arping_len
) {
3709 struct arp_state
*astate
;
3711 astate
= dhcp_arp_new(ifp
, NULL
);
3713 dhcp_arp_not_found(astate
);
3718 if (ifo
->options
& DHCPCD_STATIC
) {
3723 if (ifo
->options
& DHCPCD_INFORM
) {
3728 /* We don't want to read the old lease if we NAK an old test */
3729 nolease
= state
->offer
&& ifp
->ctx
->options
& DHCPCD_TEST
;
3730 if (!nolease
&& ifo
->options
& DHCPCD_DHCP
) {
3731 state
->offer_len
= read_lease(ifp
, &state
->offer
);
3732 /* Check the saved lease matches the type we want */
3734 #ifdef IN_IFF_DUPLICATED
3735 struct in_addr addr
;
3736 struct ipv4_addr
*ia
;
3738 addr
.s_addr
= state
->offer
->yiaddr
;
3739 ia
= ipv4_iffindaddr(ifp
, &addr
, NULL
);
3742 if ((!IS_DHCP(state
->offer
) &&
3743 !(ifo
->options
& DHCPCD_BOOTP
)) ||
3744 #ifdef IN_IFF_DUPLICATED
3745 (ia
&& ia
->addr_flags
& IN_IFF_DUPLICATED
) ||
3747 (IS_DHCP(state
->offer
) &&
3748 ifo
->options
& DHCPCD_BOOTP
))
3751 state
->offer
= NULL
;
3752 state
->offer_len
= 0;
3757 struct ipv4_addr
*ia
;
3759 get_lease(ifp
, &state
->lease
, state
->offer
, state
->offer_len
);
3760 state
->lease
.frominfo
= 1;
3761 if (state
->new == NULL
&&
3762 (ia
= ipv4_iffindaddr(ifp
,
3763 &state
->lease
.addr
, &state
->lease
.mask
)) != NULL
)
3765 /* We still have the IP address from the last lease.
3766 * Fake add the address and routes from it so the lease
3767 * can be cleaned up. */
3768 state
->new = malloc(state
->offer_len
);
3771 state
->offer
, state
->offer_len
);
3772 state
->new_len
= state
->offer_len
;
3774 state
->added
|= STATE_ADDED
| STATE_FAKE
;
3775 rt_build(ifp
->ctx
, AF_INET
);
3779 if (!IS_DHCP(state
->offer
)) {
3781 state
->offer
= NULL
;
3782 state
->offer_len
= 0;
3783 } else if (!(ifo
->options
& DHCPCD_LASTLEASE_EXTEND
) &&
3784 state
->lease
.leasetime
!= DHCP_INFINITE_LIFETIME
&&
3785 stat(state
->leasefile
, &st
) == 0)
3789 /* Offset lease times and check expiry */
3792 (time_t)state
->lease
.leasetime
< now
- st
.st_mtime
)
3794 logdebugx("%s: discarding expired lease",
3797 state
->offer
= NULL
;
3798 state
->offer_len
= 0;
3799 state
->lease
.addr
.s_addr
= 0;
3800 /* Technically we should discard the lease
3801 * as it's expired, just as DHCPv6 addresses
3802 * would be by the kernel.
3803 * However, this may violate POLA so
3804 * we currently leave it be.
3805 * If we get a totally different lease from
3806 * the DHCP server we'll drop it anyway, as
3807 * we will on any other event which would
3808 * trigger a lease drop.
3809 * This should only happen if dhcpcd stops
3810 * running and the lease expires before
3811 * dhcpcd starts again. */
3814 dhcp_drop(ifp
, "EXPIRE");
3817 l
= (uint32_t)(now
- st
.st_mtime
);
3818 state
->lease
.leasetime
-= l
;
3819 state
->lease
.renewaltime
-= l
;
3820 state
->lease
.rebindtime
-= l
;
3826 if (!(ifo
->options
& DHCPCD_DHCP
)) {
3827 if (ifo
->options
& DHCPCD_IPV4LL
)
3833 if (state
->offer
== NULL
|| !IS_DHCP(state
->offer
))
3840 dhcp_start(struct interface
*ifp
)
3844 const struct dhcp_state
*state
;
3847 if (!(ifp
->options
->options
& DHCPCD_IPV4
))
3850 /* If we haven't been given a netmask for our requested address,
3852 if (ifp
->options
->req_addr
.s_addr
!= INADDR_ANY
&&
3853 ifp
->options
->req_mask
.s_addr
== INADDR_ANY
)
3854 ifp
->options
->req_mask
.s_addr
=
3855 ipv4_getnetmask(ifp
->options
->req_addr
.s_addr
);
3857 /* If we haven't specified a ClientID and our hardware address
3858 * length is greater than BOOTP CHADDR then we enforce a ClientID
3859 * of the hardware address family and the hardware address.
3860 * If there is no hardware address and no ClientID set,
3861 * force a DUID based ClientID. */
3862 if (ifp
->hwlen
> 16)
3863 ifp
->options
->options
|= DHCPCD_CLIENTID
;
3864 else if (ifp
->hwlen
== 0 && !(ifp
->options
->options
& DHCPCD_CLIENTID
))
3865 ifp
->options
->options
|= DHCPCD_CLIENTID
| DHCPCD_DUID
;
3867 /* Firewire and InfiniBand interfaces require ClientID and
3868 * the broadcast option being set. */
3869 switch (ifp
->family
) {
3870 case ARPHRD_IEEE1394
: /* FALLTHROUGH */
3871 case ARPHRD_INFINIBAND
:
3872 ifp
->options
->options
|= DHCPCD_CLIENTID
| DHCPCD_BROADCAST
;
3876 /* If we violate RFC2131 section 3.7 then require ARP
3877 * to detect if any other client wants our address. */
3878 if (ifp
->options
->options
& DHCPCD_LASTLEASE_EXTEND
)
3879 ifp
->options
->options
|= DHCPCD_ARP
;
3881 /* No point in delaying a static configuration */
3882 if (ifp
->options
->options
& DHCPCD_STATIC
||
3883 !(ifp
->options
->options
& DHCPCD_INITIAL_DELAY
))
3890 /* If we have arpinged then we have already delayed. */
3891 state
= D_CSTATE(ifp
);
3892 if (state
!= NULL
&& state
->arping_index
!= -1) {
3898 tv
.tv_sec
= DHCP_MIN_DELAY
;
3899 tv
.tv_nsec
= (suseconds_t
)arc4random_uniform(
3900 (DHCP_MAX_DELAY
- DHCP_MIN_DELAY
) * NSEC_PER_SEC
);
3902 logdebugx("%s: delaying IPv4 for %0.1f seconds",
3903 ifp
->name
, timespec_to_double(&tv
));
3905 eloop_timeout_add_tv(ifp
->ctx
->eloop
, &tv
, dhcp_start1
, ifp
);
3909 dhcp_abort(struct interface
*ifp
)
3911 struct dhcp_state
*state
;
3913 state
= D_STATE(ifp
);
3916 state
->arping_index
= -1;
3919 eloop_timeout_delete(ifp
->ctx
->eloop
, dhcp_start1
, ifp
);
3921 if (state
!= NULL
&& state
->added
) {
3922 rt_build(ifp
->ctx
, AF_INET
);
3924 arp_announceaddr(ifp
->ctx
, &state
->addr
->addr
);
3930 dhcp_handleifa(int cmd
, struct ipv4_addr
*ia
, pid_t pid
)
3932 struct interface
*ifp
;
3933 struct dhcp_state
*state
;
3934 struct if_options
*ifo
;
3938 state
= D_STATE(ifp
);
3939 if (state
== NULL
|| state
->state
== DHS_NONE
)
3942 if (cmd
== RTM_DELADDR
) {
3943 if (state
->addr
== ia
) {
3944 loginfox("%s: pid %d deleted IP address %s",
3945 ifp
->name
, pid
, ia
->saddr
);
3947 /* Don't clear the added state as we need
3948 * to drop the lease. */
3949 dhcp_drop(ifp
, "EXPIRE");
3955 if (cmd
!= RTM_NEWADDR
)
3958 #ifdef IN_IFF_NOTUSEABLE
3959 if (!(ia
->addr_flags
& IN_IFF_NOTUSEABLE
))
3960 dhcp_finish_dad(ifp
, &ia
->addr
);
3961 else if (ia
->addr_flags
& IN_IFF_DUPLICATED
)
3962 dhcp_addr_duplicated(ifp
, &ia
->addr
);
3966 if (ifo
->options
& DHCPCD_INFORM
) {
3967 if (state
->state
!= DHS_INFORM
)
3972 if (!(ifo
->options
& DHCPCD_STATIC
))
3974 if (ifo
->req_addr
.s_addr
!= INADDR_ANY
)
3978 state
->old
= state
->new;
3979 state
->new_len
= dhcp_message_new(&state
->new, &ia
->addr
, &ia
->mask
);
3980 if (state
->new == NULL
)
3982 if (ifp
->flags
& IFF_POINTOPOINT
) {
3983 for (i
= 1; i
< 255; i
++)
3984 if (i
!= DHO_ROUTER
&& has_option_mask(ifo
->dstmask
,i
))
3985 dhcp_message_add_addr(state
->new, i
, ia
->brd
);
3987 state
->reason
= "STATIC";
3988 rt_build(ifp
->ctx
, AF_INET
);
3989 script_runreason(ifp
, state
->reason
);
3990 if (ifo
->options
& DHCPCD_INFORM
) {
3991 state
->state
= DHS_INFORM
;
3993 state
->lease
.server
.s_addr
= INADDR_ANY
;