2 This file is part of systemd.
4 Copyright (C) 2013 Intel Corporation. All rights reserved.
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 #include <net/ethernet.h>
22 #include <net/if_arp.h>
26 #include <sys/ioctl.h>
27 #include <linux/if_infiniband.h>
29 #include "sd-dhcp-client.h"
32 #include "dhcp-identifier.h"
33 #include "dhcp-internal.h"
34 #include "dhcp-lease-internal.h"
35 #include "dhcp-protocol.h"
36 #include "random-util.h"
37 #include "string-util.h"
40 #define MAX_CLIENT_ID_LEN (sizeof(uint32_t) + MAX_DUID_LEN) /* Arbitrary limit */
41 #define MAX_MAC_ADDR_LEN CONST_MAX(INFINIBAND_ALEN, ETH_ALEN)
43 struct sd_dhcp_client
{
49 sd_event_source
*timeout_resend
;
52 union sockaddr_union link
;
53 sd_event_source
*receive_message
;
54 bool request_broadcast
;
56 size_t req_opts_allocated
;
59 uint8_t mac_addr
[MAX_MAC_ADDR_LEN
];
66 /* 0: Generic (non-LL) (RFC 2132) */
67 uint8_t data
[MAX_CLIENT_ID_LEN
];
70 /* 1: Ethernet Link-Layer (RFC 2132) */
71 uint8_t haddr
[ETH_ALEN
];
74 /* 2 - 254: ARP/Link-Layer (RFC 2132) */
78 /* 255: Node-specific (RFC 4361) */
83 uint8_t data
[MAX_CLIENT_ID_LEN
];
89 char *vendor_class_identifier
;
95 sd_event_source
*timeout_t1
;
96 sd_event_source
*timeout_t2
;
97 sd_event_source
*timeout_expire
;
98 sd_dhcp_client_cb_t cb
;
100 sd_dhcp_lease
*lease
;
103 static const uint8_t default_req_opts
[] = {
104 DHCP_OPTION_SUBNET_MASK
,
106 DHCP_OPTION_HOST_NAME
,
107 DHCP_OPTION_DOMAIN_NAME
,
108 DHCP_OPTION_DOMAIN_NAME_SERVER
,
111 static int client_receive_message_raw(sd_event_source
*s
, int fd
,
112 uint32_t revents
, void *userdata
);
113 static int client_receive_message_udp(sd_event_source
*s
, int fd
,
114 uint32_t revents
, void *userdata
);
115 static void client_stop(sd_dhcp_client
*client
, int error
);
117 int sd_dhcp_client_set_callback(sd_dhcp_client
*client
, sd_dhcp_client_cb_t cb
,
119 assert_return(client
, -EINVAL
);
122 client
->userdata
= userdata
;
127 int sd_dhcp_client_set_request_broadcast(sd_dhcp_client
*client
, int broadcast
) {
128 assert_return(client
, -EINVAL
);
130 client
->request_broadcast
= !!broadcast
;
135 int sd_dhcp_client_set_request_option(sd_dhcp_client
*client
, uint8_t option
) {
138 assert_return(client
, -EINVAL
);
139 assert_return (IN_SET(client
->state
, DHCP_STATE_INIT
,
140 DHCP_STATE_STOPPED
), -EBUSY
);
143 case DHCP_OPTION_PAD
:
144 case DHCP_OPTION_OVERLOAD
:
145 case DHCP_OPTION_MESSAGE_TYPE
:
146 case DHCP_OPTION_PARAMETER_REQUEST_LIST
:
147 case DHCP_OPTION_END
:
154 for (i
= 0; i
< client
->req_opts_size
; i
++)
155 if (client
->req_opts
[i
] == option
)
158 if (!GREEDY_REALLOC(client
->req_opts
, client
->req_opts_allocated
,
159 client
->req_opts_size
+ 1))
162 client
->req_opts
[client
->req_opts_size
++] = option
;
167 int sd_dhcp_client_set_request_address(sd_dhcp_client
*client
,
168 const struct in_addr
*last_addr
) {
169 assert_return(client
, -EINVAL
);
170 assert_return (IN_SET(client
->state
, DHCP_STATE_INIT
,
171 DHCP_STATE_STOPPED
), -EBUSY
);
174 client
->last_addr
= last_addr
->s_addr
;
176 client
->last_addr
= INADDR_ANY
;
181 int sd_dhcp_client_set_index(sd_dhcp_client
*client
, int interface_index
) {
182 assert_return(client
, -EINVAL
);
183 assert_return (IN_SET(client
->state
, DHCP_STATE_INIT
,
184 DHCP_STATE_STOPPED
), -EBUSY
);
185 assert_return(interface_index
> 0, -EINVAL
);
187 client
->index
= interface_index
;
192 int sd_dhcp_client_set_mac(sd_dhcp_client
*client
, const uint8_t *addr
,
193 size_t addr_len
, uint16_t arp_type
) {
194 DHCP_CLIENT_DONT_DESTROY(client
);
195 bool need_restart
= false;
197 assert_return(client
, -EINVAL
);
198 assert_return(addr
, -EINVAL
);
199 assert_return(addr_len
> 0 && addr_len
<= MAX_MAC_ADDR_LEN
, -EINVAL
);
200 assert_return(arp_type
> 0, -EINVAL
);
202 if (arp_type
== ARPHRD_ETHER
)
203 assert_return(addr_len
== ETH_ALEN
, -EINVAL
);
204 else if (arp_type
== ARPHRD_INFINIBAND
)
205 assert_return(addr_len
== INFINIBAND_ALEN
, -EINVAL
);
209 if (client
->mac_addr_len
== addr_len
&&
210 memcmp(&client
->mac_addr
, addr
, addr_len
) == 0)
213 if (!IN_SET(client
->state
, DHCP_STATE_INIT
, DHCP_STATE_STOPPED
)) {
214 log_dhcp_client(client
, "Changing MAC address on running DHCP "
215 "client, restarting");
217 client_stop(client
, SD_DHCP_CLIENT_EVENT_STOP
);
220 memcpy(&client
->mac_addr
, addr
, addr_len
);
221 client
->mac_addr_len
= addr_len
;
222 client
->arp_type
= arp_type
;
224 if (need_restart
&& client
->state
!= DHCP_STATE_STOPPED
)
225 sd_dhcp_client_start(client
);
230 int sd_dhcp_client_get_client_id(sd_dhcp_client
*client
, uint8_t *type
,
231 const uint8_t **data
, size_t *data_len
) {
233 assert_return(client
, -EINVAL
);
234 assert_return(type
, -EINVAL
);
235 assert_return(data
, -EINVAL
);
236 assert_return(data_len
, -EINVAL
);
241 if (client
->client_id_len
) {
242 *type
= client
->client_id
.type
;
243 *data
= client
->client_id
.raw
.data
;
244 *data_len
= client
->client_id_len
- sizeof(client
->client_id
.type
);
250 int sd_dhcp_client_set_client_id(sd_dhcp_client
*client
, uint8_t type
,
251 const uint8_t *data
, size_t data_len
) {
252 DHCP_CLIENT_DONT_DESTROY(client
);
253 bool need_restart
= false;
255 assert_return(client
, -EINVAL
);
256 assert_return(data
, -EINVAL
);
257 assert_return(data_len
> 0 && data_len
<= MAX_CLIENT_ID_LEN
, -EINVAL
);
261 if (data_len
!= ETH_ALEN
)
264 case ARPHRD_INFINIBAND
:
265 if (data_len
!= INFINIBAND_ALEN
)
272 if (client
->client_id_len
== data_len
+ sizeof(client
->client_id
.type
) &&
273 client
->client_id
.type
== type
&&
274 memcmp(&client
->client_id
.raw
.data
, data
, data_len
) == 0)
277 if (!IN_SET(client
->state
, DHCP_STATE_INIT
, DHCP_STATE_STOPPED
)) {
278 log_dhcp_client(client
, "Changing client ID on running DHCP "
279 "client, restarting");
281 client_stop(client
, SD_DHCP_CLIENT_EVENT_STOP
);
284 client
->client_id
.type
= type
;
285 memcpy(&client
->client_id
.raw
.data
, data
, data_len
);
286 client
->client_id_len
= data_len
+ sizeof (client
->client_id
.type
);
288 if (need_restart
&& client
->state
!= DHCP_STATE_STOPPED
)
289 sd_dhcp_client_start(client
);
294 int sd_dhcp_client_set_hostname(sd_dhcp_client
*client
,
295 const char *hostname
) {
296 char *new_hostname
= NULL
;
298 assert_return(client
, -EINVAL
);
300 if (streq_ptr(client
->hostname
, hostname
))
304 new_hostname
= strdup(hostname
);
309 free(client
->hostname
);
310 client
->hostname
= new_hostname
;
315 int sd_dhcp_client_set_vendor_class_identifier(sd_dhcp_client
*client
,
317 char *new_vci
= NULL
;
319 assert_return(client
, -EINVAL
);
321 new_vci
= strdup(vci
);
325 free(client
->vendor_class_identifier
);
327 client
->vendor_class_identifier
= new_vci
;
332 int sd_dhcp_client_set_mtu(sd_dhcp_client
*client
, uint32_t mtu
) {
333 assert_return(client
, -EINVAL
);
334 assert_return(mtu
>= DHCP_DEFAULT_MIN_SIZE
, -ERANGE
);
341 int sd_dhcp_client_get_lease(sd_dhcp_client
*client
, sd_dhcp_lease
**ret
) {
342 assert_return(client
, -EINVAL
);
343 assert_return(ret
, -EINVAL
);
345 if (client
->state
!= DHCP_STATE_BOUND
&&
346 client
->state
!= DHCP_STATE_RENEWING
&&
347 client
->state
!= DHCP_STATE_REBINDING
)
348 return -EADDRNOTAVAIL
;
350 *ret
= client
->lease
;
355 static void client_notify(sd_dhcp_client
*client
, int event
) {
357 client
->cb(client
, event
, client
->userdata
);
360 static int client_initialize(sd_dhcp_client
*client
) {
361 assert_return(client
, -EINVAL
);
363 client
->receive_message
=
364 sd_event_source_unref(client
->receive_message
);
366 client
->fd
= asynchronous_close(client
->fd
);
368 client
->timeout_resend
= sd_event_source_unref(client
->timeout_resend
);
370 client
->timeout_t1
= sd_event_source_unref(client
->timeout_t1
);
371 client
->timeout_t2
= sd_event_source_unref(client
->timeout_t2
);
372 client
->timeout_expire
= sd_event_source_unref(client
->timeout_expire
);
376 client
->state
= DHCP_STATE_INIT
;
379 client
->lease
= sd_dhcp_lease_unref(client
->lease
);
384 static void client_stop(sd_dhcp_client
*client
, int error
) {
388 log_dhcp_client(client
, "STOPPED: %s", strerror(-error
));
389 else if (error
== SD_DHCP_CLIENT_EVENT_STOP
)
390 log_dhcp_client(client
, "STOPPED");
392 log_dhcp_client(client
, "STOPPED: Unknown event");
394 client_notify(client
, error
);
396 client_initialize(client
);
399 static int client_message_init(sd_dhcp_client
*client
, DHCPPacket
**ret
,
400 uint8_t type
, size_t *_optlen
, size_t *_optoffset
) {
401 _cleanup_free_ DHCPPacket
*packet
;
402 size_t optlen
, optoffset
, size
;
409 assert(client
->start_time
);
413 assert(type
== DHCP_DISCOVER
|| type
== DHCP_REQUEST
);
415 optlen
= DHCP_MIN_OPTIONS_SIZE
;
416 size
= sizeof(DHCPPacket
) + optlen
;
418 packet
= malloc0(size
);
422 r
= dhcp_message_init(&packet
->dhcp
, BOOTREQUEST
, client
->xid
, type
,
423 client
->arp_type
, optlen
, &optoffset
);
427 /* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers
428 refuse to issue an DHCP lease if 'secs' is set to zero */
429 r
= sd_event_now(client
->event
, clock_boottime_or_monotonic(), &time_now
);
432 assert(time_now
>= client
->start_time
);
434 /* seconds between sending first and last DISCOVER
435 * must always be strictly positive to deal with broken servers */
436 secs
= ((time_now
- client
->start_time
) / USEC_PER_SEC
) ? : 1;
437 packet
->dhcp
.secs
= htobe16(secs
);
439 /* RFC2132 section 4.1
440 A client that cannot receive unicast IP datagrams until its protocol
441 software has been configured with an IP address SHOULD set the
442 BROADCAST bit in the 'flags' field to 1 in any DHCPDISCOVER or
443 DHCPREQUEST messages that client sends. The BROADCAST bit will
444 provide a hint to the DHCP server and BOOTP relay agent to broadcast
445 any messages to the client on the client's subnet.
447 Note: some interfaces needs this to be enabled, but some networks
448 needs this to be disabled as broadcasts are filteretd, so this
449 needs to be configurable */
450 if (client
->request_broadcast
|| client
->arp_type
!= ARPHRD_ETHER
)
451 packet
->dhcp
.flags
= htobe16(0x8000);
453 /* RFC2132 section 4.1.1:
454 The client MUST include its hardware address in the ’chaddr’ field, if
455 necessary for delivery of DHCP reply messages. Non-Ethernet
456 interfaces will leave 'chaddr' empty and use the client identifier
457 instead (eg, RFC 4390 section 2.1).
459 if (client
->arp_type
== ARPHRD_ETHER
)
460 memcpy(&packet
->dhcp
.chaddr
, &client
->mac_addr
, ETH_ALEN
);
462 /* If no client identifier exists, construct an RFC 4361-compliant one */
463 if (client
->client_id_len
== 0) {
466 client
->client_id
.type
= 255;
468 r
= dhcp_identifier_set_iaid(client
->index
, client
->mac_addr
, client
->mac_addr_len
, &client
->client_id
.ns
.iaid
);
472 r
= dhcp_identifier_set_duid_en(&client
->client_id
.ns
.duid
, &duid_len
);
476 client
->client_id_len
= sizeof(client
->client_id
.type
) + sizeof(client
->client_id
.ns
.iaid
) + duid_len
;
479 /* Some DHCP servers will refuse to issue an DHCP lease if the Client
480 Identifier option is not set */
481 if (client
->client_id_len
) {
482 r
= dhcp_option_append(&packet
->dhcp
, optlen
, &optoffset
, 0,
483 DHCP_OPTION_CLIENT_IDENTIFIER
,
484 client
->client_id_len
,
490 /* RFC2131 section 3.5:
491 in its initial DHCPDISCOVER or DHCPREQUEST message, a
492 client may provide the server with a list of specific
493 parameters the client is interested in. If the client
494 includes a list of parameters in a DHCPDISCOVER message,
495 it MUST include that list in any subsequent DHCPREQUEST
498 r
= dhcp_option_append(&packet
->dhcp
, optlen
, &optoffset
, 0,
499 DHCP_OPTION_PARAMETER_REQUEST_LIST
,
500 client
->req_opts_size
, client
->req_opts
);
504 /* RFC2131 section 3.5:
505 The client SHOULD include the ’maximum DHCP message size’ option to
506 let the server know how large the server may make its DHCP messages.
508 Note (from ConnMan): Some DHCP servers will send bigger DHCP packets
509 than the defined default size unless the Maximum Messge Size option
512 RFC3442 "Requirements to Avoid Sizing Constraints":
513 Because a full routing table can be quite large, the standard 576
514 octet maximum size for a DHCP message may be too short to contain
515 some legitimate Classless Static Route options. Because of this,
516 clients implementing the Classless Static Route option SHOULD send a
517 Maximum DHCP Message Size [4] option if the DHCP client's TCP/IP
518 stack is capable of receiving larger IP datagrams. In this case, the
519 client SHOULD set the value of this option to at least the MTU of the
520 interface that the client is configuring. The client MAY set the
521 value of this option higher, up to the size of the largest UDP packet
522 it is prepared to accept. (Note that the value specified in the
523 Maximum DHCP Message Size option is the total maximum packet size,
524 including IP and UDP headers.)
526 max_size
= htobe16(size
);
527 r
= dhcp_option_append(&packet
->dhcp
, client
->mtu
, &optoffset
, 0,
528 DHCP_OPTION_MAXIMUM_MESSAGE_SIZE
,
534 *_optoffset
= optoffset
;
541 static int dhcp_client_send_raw(sd_dhcp_client
*client
, DHCPPacket
*packet
,
543 dhcp_packet_append_ip_headers(packet
, INADDR_ANY
, DHCP_PORT_CLIENT
,
544 INADDR_BROADCAST
, DHCP_PORT_SERVER
, len
);
546 return dhcp_network_send_raw_socket(client
->fd
, &client
->link
,
550 static int client_send_discover(sd_dhcp_client
*client
) {
551 _cleanup_free_ DHCPPacket
*discover
= NULL
;
552 size_t optoffset
, optlen
;
556 assert(client
->state
== DHCP_STATE_INIT
||
557 client
->state
== DHCP_STATE_SELECTING
);
559 r
= client_message_init(client
, &discover
, DHCP_DISCOVER
,
560 &optlen
, &optoffset
);
564 /* the client may suggest values for the network address
565 and lease time in the DHCPDISCOVER message. The client may include
566 the ’requested IP address’ option to suggest that a particular IP
567 address be assigned, and may include the ’IP address lease time’
568 option to suggest the lease time it would like.
570 if (client
->last_addr
!= INADDR_ANY
) {
571 r
= dhcp_option_append(&discover
->dhcp
, optlen
, &optoffset
, 0,
572 DHCP_OPTION_REQUESTED_IP_ADDRESS
,
573 4, &client
->last_addr
);
578 /* it is unclear from RFC 2131 if client should send hostname in
579 DHCPDISCOVER but dhclient does and so we do as well
581 if (client
->hostname
) {
582 r
= dhcp_option_append(&discover
->dhcp
, optlen
, &optoffset
, 0,
583 DHCP_OPTION_HOST_NAME
,
584 strlen(client
->hostname
), client
->hostname
);
589 if (client
->vendor_class_identifier
) {
590 r
= dhcp_option_append(&discover
->dhcp
, optlen
, &optoffset
, 0,
591 DHCP_OPTION_VENDOR_CLASS_IDENTIFIER
,
592 strlen(client
->vendor_class_identifier
),
593 client
->vendor_class_identifier
);
598 r
= dhcp_option_append(&discover
->dhcp
, optlen
, &optoffset
, 0,
599 DHCP_OPTION_END
, 0, NULL
);
603 /* We currently ignore:
604 The client SHOULD wait a random time between one and ten seconds to
605 desynchronize the use of DHCP at startup.
607 r
= dhcp_client_send_raw(client
, discover
, sizeof(DHCPPacket
) + optoffset
);
611 log_dhcp_client(client
, "DISCOVER");
616 static int client_send_request(sd_dhcp_client
*client
) {
617 _cleanup_free_ DHCPPacket
*request
= NULL
;
618 size_t optoffset
, optlen
;
621 r
= client_message_init(client
, &request
, DHCP_REQUEST
,
622 &optlen
, &optoffset
);
626 switch (client
->state
) {
627 /* See RFC2131 section 4.3.2 (note that there is a typo in the RFC,
628 SELECTING should be REQUESTING)
631 case DHCP_STATE_REQUESTING
:
632 /* Client inserts the address of the selected server in ’server
633 identifier’, ’ciaddr’ MUST be zero, ’requested IP address’ MUST be
634 filled in with the yiaddr value from the chosen DHCPOFFER.
637 r
= dhcp_option_append(&request
->dhcp
, optlen
, &optoffset
, 0,
638 DHCP_OPTION_SERVER_IDENTIFIER
,
639 4, &client
->lease
->server_address
);
643 r
= dhcp_option_append(&request
->dhcp
, optlen
, &optoffset
, 0,
644 DHCP_OPTION_REQUESTED_IP_ADDRESS
,
645 4, &client
->lease
->address
);
651 case DHCP_STATE_INIT_REBOOT
:
652 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
653 option MUST be filled in with client’s notion of its previously
654 assigned address. ’ciaddr’ MUST be zero.
656 r
= dhcp_option_append(&request
->dhcp
, optlen
, &optoffset
, 0,
657 DHCP_OPTION_REQUESTED_IP_ADDRESS
,
658 4, &client
->last_addr
);
663 case DHCP_STATE_RENEWING
:
664 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
665 option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
666 client’s IP address.
670 case DHCP_STATE_REBINDING
:
671 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
672 option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
673 client’s IP address.
675 This message MUST be broadcast to the 0xffffffff IP broadcast address.
677 request
->dhcp
.ciaddr
= client
->lease
->address
;
681 case DHCP_STATE_INIT
:
682 case DHCP_STATE_SELECTING
:
683 case DHCP_STATE_REBOOTING
:
684 case DHCP_STATE_BOUND
:
685 case DHCP_STATE_STOPPED
:
689 if (client
->hostname
) {
690 r
= dhcp_option_append(&request
->dhcp
, optlen
, &optoffset
, 0,
691 DHCP_OPTION_HOST_NAME
,
692 strlen(client
->hostname
), client
->hostname
);
697 r
= dhcp_option_append(&request
->dhcp
, optlen
, &optoffset
, 0,
698 DHCP_OPTION_END
, 0, NULL
);
702 if (client
->state
== DHCP_STATE_RENEWING
) {
703 r
= dhcp_network_send_udp_socket(client
->fd
,
704 client
->lease
->server_address
,
707 sizeof(DHCPMessage
) + optoffset
);
709 r
= dhcp_client_send_raw(client
, request
, sizeof(DHCPPacket
) + optoffset
);
714 switch (client
->state
) {
715 case DHCP_STATE_REQUESTING
:
716 log_dhcp_client(client
, "REQUEST (requesting)");
718 case DHCP_STATE_INIT_REBOOT
:
719 log_dhcp_client(client
, "REQUEST (init-reboot)");
721 case DHCP_STATE_RENEWING
:
722 log_dhcp_client(client
, "REQUEST (renewing)");
724 case DHCP_STATE_REBINDING
:
725 log_dhcp_client(client
, "REQUEST (rebinding)");
728 log_dhcp_client(client
, "REQUEST (invalid)");
735 static int client_start(sd_dhcp_client
*client
);
737 static int client_timeout_resend(sd_event_source
*s
, uint64_t usec
,
739 sd_dhcp_client
*client
= userdata
;
740 DHCP_CLIENT_DONT_DESTROY(client
);
741 usec_t next_timeout
= 0;
748 assert(client
->event
);
750 r
= sd_event_now(client
->event
, clock_boottime_or_monotonic(), &time_now
);
754 switch (client
->state
) {
755 case DHCP_STATE_RENEWING
:
757 time_left
= (client
->lease
->t2
- client
->lease
->t1
) / 2;
761 next_timeout
= time_now
+ time_left
* USEC_PER_SEC
;
765 case DHCP_STATE_REBINDING
:
767 time_left
= (client
->lease
->lifetime
- client
->lease
->t2
) / 2;
771 next_timeout
= time_now
+ time_left
* USEC_PER_SEC
;
774 case DHCP_STATE_REBOOTING
:
775 /* start over as we did not receive a timely ack or nak */
776 r
= client_initialize(client
);
780 r
= client_start(client
);
784 log_dhcp_client(client
, "REBOOTED");
788 case DHCP_STATE_INIT
:
789 case DHCP_STATE_INIT_REBOOT
:
790 case DHCP_STATE_SELECTING
:
791 case DHCP_STATE_REQUESTING
:
792 case DHCP_STATE_BOUND
:
794 if (client
->attempt
< 64)
795 client
->attempt
*= 2;
797 next_timeout
= time_now
+ (client
->attempt
- 1) * USEC_PER_SEC
;
801 case DHCP_STATE_STOPPED
:
806 next_timeout
+= (random_u32() & 0x1fffff);
808 client
->timeout_resend
= sd_event_source_unref(client
->timeout_resend
);
810 r
= sd_event_add_time(client
->event
,
811 &client
->timeout_resend
,
812 clock_boottime_or_monotonic(),
813 next_timeout
, 10 * USEC_PER_MSEC
,
814 client_timeout_resend
, client
);
818 r
= sd_event_source_set_priority(client
->timeout_resend
,
819 client
->event_priority
);
823 r
= sd_event_source_set_description(client
->timeout_resend
, "dhcp4-resend-timer");
827 switch (client
->state
) {
828 case DHCP_STATE_INIT
:
829 r
= client_send_discover(client
);
831 client
->state
= DHCP_STATE_SELECTING
;
834 if (client
->attempt
>= 64)
840 case DHCP_STATE_SELECTING
:
841 r
= client_send_discover(client
);
842 if (r
< 0 && client
->attempt
>= 64)
847 case DHCP_STATE_INIT_REBOOT
:
848 case DHCP_STATE_REQUESTING
:
849 case DHCP_STATE_RENEWING
:
850 case DHCP_STATE_REBINDING
:
851 r
= client_send_request(client
);
852 if (r
< 0 && client
->attempt
>= 64)
855 if (client
->state
== DHCP_STATE_INIT_REBOOT
)
856 client
->state
= DHCP_STATE_REBOOTING
;
858 client
->request_sent
= time_now
;
862 case DHCP_STATE_REBOOTING
:
863 case DHCP_STATE_BOUND
:
867 case DHCP_STATE_STOPPED
:
875 client_stop(client
, r
);
877 /* Errors were dealt with when stopping the client, don't spill
878 errors into the event loop handler */
882 static int client_initialize_io_events(sd_dhcp_client
*client
,
883 sd_event_io_handler_t io_callback
) {
887 assert(client
->event
);
889 r
= sd_event_add_io(client
->event
, &client
->receive_message
,
890 client
->fd
, EPOLLIN
, io_callback
,
895 r
= sd_event_source_set_priority(client
->receive_message
,
896 client
->event_priority
);
900 r
= sd_event_source_set_description(client
->receive_message
, "dhcp4-receive-message");
906 client_stop(client
, r
);
911 static int client_initialize_time_events(sd_dhcp_client
*client
) {
915 assert(client
->event
);
917 client
->timeout_resend
= sd_event_source_unref(client
->timeout_resend
);
919 r
= sd_event_add_time(client
->event
,
920 &client
->timeout_resend
,
921 clock_boottime_or_monotonic(),
923 client_timeout_resend
, client
);
927 r
= sd_event_source_set_priority(client
->timeout_resend
,
928 client
->event_priority
);
932 r
= sd_event_source_set_description(client
->timeout_resend
, "dhcp4-resend-timer");
938 client_stop(client
, r
);
944 static int client_initialize_events(sd_dhcp_client
*client
,
945 sd_event_io_handler_t io_callback
) {
946 client_initialize_io_events(client
, io_callback
);
947 client_initialize_time_events(client
);
952 static int client_start(sd_dhcp_client
*client
) {
955 assert_return(client
, -EINVAL
);
956 assert_return(client
->event
, -EINVAL
);
957 assert_return(client
->index
> 0, -EINVAL
);
958 assert_return(client
->fd
< 0, -EBUSY
);
959 assert_return(client
->xid
== 0, -EINVAL
);
960 assert_return(client
->state
== DHCP_STATE_INIT
||
961 client
->state
== DHCP_STATE_INIT_REBOOT
, -EBUSY
);
963 client
->xid
= random_u32();
965 r
= dhcp_network_bind_raw_socket(client
->index
, &client
->link
,
966 client
->xid
, client
->mac_addr
,
967 client
->mac_addr_len
, client
->arp_type
);
969 client_stop(client
, r
);
974 if (client
->state
== DHCP_STATE_INIT
|| client
->state
== DHCP_STATE_INIT_REBOOT
)
975 client
->start_time
= now(clock_boottime_or_monotonic());
977 return client_initialize_events(client
, client_receive_message_raw
);
980 static int client_timeout_expire(sd_event_source
*s
, uint64_t usec
,
982 sd_dhcp_client
*client
= userdata
;
983 DHCP_CLIENT_DONT_DESTROY(client
);
985 log_dhcp_client(client
, "EXPIRED");
987 client_notify(client
, SD_DHCP_CLIENT_EVENT_EXPIRED
);
989 /* lease was lost, start over if not freed or stopped in callback */
990 if (client
->state
!= DHCP_STATE_STOPPED
) {
991 client_initialize(client
);
992 client_start(client
);
998 static int client_timeout_t2(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
999 sd_dhcp_client
*client
= userdata
;
1000 DHCP_CLIENT_DONT_DESTROY(client
);
1003 client
->receive_message
= sd_event_source_unref(client
->receive_message
);
1004 client
->fd
= asynchronous_close(client
->fd
);
1006 client
->state
= DHCP_STATE_REBINDING
;
1007 client
->attempt
= 1;
1009 r
= dhcp_network_bind_raw_socket(client
->index
, &client
->link
,
1010 client
->xid
, client
->mac_addr
,
1011 client
->mac_addr_len
, client
->arp_type
);
1013 client_stop(client
, r
);
1018 return client_initialize_events(client
, client_receive_message_raw
);
1021 static int client_timeout_t1(sd_event_source
*s
, uint64_t usec
,
1023 sd_dhcp_client
*client
= userdata
;
1024 DHCP_CLIENT_DONT_DESTROY(client
);
1026 client
->state
= DHCP_STATE_RENEWING
;
1027 client
->attempt
= 1;
1029 return client_initialize_time_events(client
);
1032 static int client_handle_offer(sd_dhcp_client
*client
, DHCPMessage
*offer
,
1034 _cleanup_dhcp_lease_unref_ sd_dhcp_lease
*lease
= NULL
;
1037 r
= dhcp_lease_new(&lease
);
1041 if (client
->client_id_len
) {
1042 r
= dhcp_lease_set_client_id(lease
,
1043 (uint8_t *) &client
->client_id
,
1044 client
->client_id_len
);
1049 r
= dhcp_option_parse(offer
, len
, dhcp_lease_parse_options
, lease
);
1050 if (r
!= DHCP_OFFER
) {
1051 log_dhcp_client(client
, "received message was not an OFFER, ignoring");
1055 lease
->next_server
= offer
->siaddr
;
1056 lease
->address
= offer
->yiaddr
;
1058 if (lease
->address
== 0 ||
1059 lease
->server_address
== 0 ||
1060 lease
->lifetime
== 0) {
1061 log_dhcp_client(client
, "received lease lacks address, server address or lease lifetime, ignoring");
1065 if (!lease
->have_subnet_mask
) {
1066 r
= dhcp_lease_set_default_subnet_mask(lease
);
1068 log_dhcp_client(client
, "received lease lacks subnet "
1069 "mask, and a fallback one can not be "
1070 "generated, ignoring");
1075 sd_dhcp_lease_unref(client
->lease
);
1076 client
->lease
= lease
;
1079 log_dhcp_client(client
, "OFFER");
1084 static int client_handle_forcerenew(sd_dhcp_client
*client
, DHCPMessage
*force
,
1088 r
= dhcp_option_parse(force
, len
, NULL
, NULL
);
1089 if (r
!= DHCP_FORCERENEW
)
1092 log_dhcp_client(client
, "FORCERENEW");
1097 static int client_handle_ack(sd_dhcp_client
*client
, DHCPMessage
*ack
,
1099 _cleanup_dhcp_lease_unref_ sd_dhcp_lease
*lease
= NULL
;
1102 r
= dhcp_lease_new(&lease
);
1106 if (client
->client_id_len
) {
1107 r
= dhcp_lease_set_client_id(lease
,
1108 (uint8_t *) &client
->client_id
,
1109 client
->client_id_len
);
1114 r
= dhcp_option_parse(ack
, len
, dhcp_lease_parse_options
, lease
);
1115 if (r
== DHCP_NAK
) {
1116 log_dhcp_client(client
, "NAK");
1117 return -EADDRNOTAVAIL
;
1120 if (r
!= DHCP_ACK
) {
1121 log_dhcp_client(client
, "received message was not an ACK, ignoring");
1125 lease
->next_server
= ack
->siaddr
;
1127 lease
->address
= ack
->yiaddr
;
1129 if (lease
->address
== INADDR_ANY
||
1130 lease
->server_address
== INADDR_ANY
||
1131 lease
->lifetime
== 0) {
1132 log_dhcp_client(client
, "received lease lacks address, server "
1133 "address or lease lifetime, ignoring");
1137 if (lease
->subnet_mask
== INADDR_ANY
) {
1138 r
= dhcp_lease_set_default_subnet_mask(lease
);
1140 log_dhcp_client(client
, "received lease lacks subnet "
1141 "mask, and a fallback one can not be "
1142 "generated, ignoring");
1147 r
= SD_DHCP_CLIENT_EVENT_IP_ACQUIRE
;
1148 if (client
->lease
) {
1149 if (client
->lease
->address
!= lease
->address
||
1150 client
->lease
->subnet_mask
!= lease
->subnet_mask
||
1151 client
->lease
->router
!= lease
->router
) {
1152 r
= SD_DHCP_CLIENT_EVENT_IP_CHANGE
;
1154 r
= SD_DHCP_CLIENT_EVENT_RENEW
;
1156 client
->lease
= sd_dhcp_lease_unref(client
->lease
);
1159 client
->lease
= lease
;
1162 log_dhcp_client(client
, "ACK");
1167 static uint64_t client_compute_timeout(sd_dhcp_client
*client
, uint32_t lifetime
, double factor
) {
1169 assert(client
->request_sent
);
1170 assert(lifetime
> 0);
1177 return client
->request_sent
+ (lifetime
* USEC_PER_SEC
* factor
) +
1178 + (random_u32() & 0x1fffff);
1181 static int client_set_lease_timeouts(sd_dhcp_client
*client
) {
1183 uint64_t lifetime_timeout
;
1184 uint64_t t2_timeout
;
1185 uint64_t t1_timeout
;
1186 char time_string
[FORMAT_TIMESPAN_MAX
];
1190 assert(client
->event
);
1191 assert(client
->lease
);
1192 assert(client
->lease
->lifetime
);
1194 client
->timeout_t1
= sd_event_source_unref(client
->timeout_t1
);
1195 client
->timeout_t2
= sd_event_source_unref(client
->timeout_t2
);
1196 client
->timeout_expire
= sd_event_source_unref(client
->timeout_expire
);
1198 /* don't set timers for infinite leases */
1199 if (client
->lease
->lifetime
== 0xffffffff)
1202 r
= sd_event_now(client
->event
, clock_boottime_or_monotonic(), &time_now
);
1205 assert(client
->request_sent
<= time_now
);
1207 /* convert the various timeouts from relative (secs) to absolute (usecs) */
1208 lifetime_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 1);
1209 if (client
->lease
->t1
> 0 && client
->lease
->t2
> 0) {
1210 /* both T1 and T2 are given */
1211 if (client
->lease
->t1
< client
->lease
->t2
&&
1212 client
->lease
->t2
< client
->lease
->lifetime
) {
1213 /* they are both valid */
1214 t2_timeout
= client_compute_timeout(client
, client
->lease
->t2
, 1);
1215 t1_timeout
= client_compute_timeout(client
, client
->lease
->t1
, 1);
1218 t2_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 7.0 / 8.0);
1219 client
->lease
->t2
= (client
->lease
->lifetime
* 7) / 8;
1220 t1_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 0.5);
1221 client
->lease
->t1
= client
->lease
->lifetime
/ 2;
1223 } else if (client
->lease
->t2
> 0 && client
->lease
->t2
< client
->lease
->lifetime
) {
1224 /* only T2 is given, and it is valid */
1225 t2_timeout
= client_compute_timeout(client
, client
->lease
->t2
, 1);
1226 t1_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 0.5);
1227 client
->lease
->t1
= client
->lease
->lifetime
/ 2;
1228 if (t2_timeout
<= t1_timeout
) {
1229 /* the computed T1 would be invalid, so discard T2 */
1230 t2_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 7.0 / 8.0);
1231 client
->lease
->t2
= (client
->lease
->lifetime
* 7) / 8;
1233 } else if (client
->lease
->t1
> 0 && client
->lease
->t1
< client
->lease
->lifetime
) {
1234 /* only T1 is given, and it is valid */
1235 t1_timeout
= client_compute_timeout(client
, client
->lease
->t1
, 1);
1236 t2_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 7.0 / 8.0);
1237 client
->lease
->t2
= (client
->lease
->lifetime
* 7) / 8;
1238 if (t2_timeout
<= t1_timeout
) {
1239 /* the computed T2 would be invalid, so discard T1 */
1240 t2_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 0.5);
1241 client
->lease
->t2
= client
->lease
->lifetime
/ 2;
1244 /* fall back to the default timeouts */
1245 t1_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 0.5);
1246 client
->lease
->t1
= client
->lease
->lifetime
/ 2;
1247 t2_timeout
= client_compute_timeout(client
, client
->lease
->lifetime
, 7.0 / 8.0);
1248 client
->lease
->t2
= (client
->lease
->lifetime
* 7) / 8;
1251 /* arm lifetime timeout */
1252 r
= sd_event_add_time(client
->event
, &client
->timeout_expire
,
1253 clock_boottime_or_monotonic(),
1254 lifetime_timeout
, 10 * USEC_PER_MSEC
,
1255 client_timeout_expire
, client
);
1259 r
= sd_event_source_set_priority(client
->timeout_expire
,
1260 client
->event_priority
);
1264 r
= sd_event_source_set_description(client
->timeout_expire
, "dhcp4-lifetime");
1268 log_dhcp_client(client
, "lease expires in %s",
1269 format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, lifetime_timeout
- time_now
, USEC_PER_SEC
));
1271 /* don't arm earlier timeouts if this has already expired */
1272 if (lifetime_timeout
<= time_now
)
1275 /* arm T2 timeout */
1276 r
= sd_event_add_time(client
->event
,
1277 &client
->timeout_t2
,
1278 clock_boottime_or_monotonic(),
1281 client_timeout_t2
, client
);
1285 r
= sd_event_source_set_priority(client
->timeout_t2
,
1286 client
->event_priority
);
1290 r
= sd_event_source_set_description(client
->timeout_t2
, "dhcp4-t2-timeout");
1294 log_dhcp_client(client
, "T2 expires in %s",
1295 format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, t2_timeout
- time_now
, USEC_PER_SEC
));
1297 /* don't arm earlier timeout if this has already expired */
1298 if (t2_timeout
<= time_now
)
1301 /* arm T1 timeout */
1302 r
= sd_event_add_time(client
->event
,
1303 &client
->timeout_t1
,
1304 clock_boottime_or_monotonic(),
1305 t1_timeout
, 10 * USEC_PER_MSEC
,
1306 client_timeout_t1
, client
);
1310 r
= sd_event_source_set_priority(client
->timeout_t1
,
1311 client
->event_priority
);
1315 r
= sd_event_source_set_description(client
->timeout_t1
, "dhcp4-t1-timer");
1319 log_dhcp_client(client
, "T1 expires in %s",
1320 format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, t1_timeout
- time_now
, USEC_PER_SEC
));
1325 static int client_handle_message(sd_dhcp_client
*client
, DHCPMessage
*message
,
1327 DHCP_CLIENT_DONT_DESTROY(client
);
1328 int r
= 0, notify_event
= 0;
1331 assert(client
->event
);
1334 switch (client
->state
) {
1335 case DHCP_STATE_SELECTING
:
1337 r
= client_handle_offer(client
, message
, len
);
1340 client
->timeout_resend
=
1341 sd_event_source_unref(client
->timeout_resend
);
1343 client
->state
= DHCP_STATE_REQUESTING
;
1344 client
->attempt
= 1;
1346 r
= sd_event_add_time(client
->event
,
1347 &client
->timeout_resend
,
1348 clock_boottime_or_monotonic(),
1350 client_timeout_resend
, client
);
1354 r
= sd_event_source_set_priority(client
->timeout_resend
,
1355 client
->event_priority
);
1359 r
= sd_event_source_set_description(client
->timeout_resend
, "dhcp4-resend-timer");
1362 } else if (r
== -ENOMSG
)
1363 /* invalid message, let's ignore it */
1368 case DHCP_STATE_REBOOTING
:
1369 case DHCP_STATE_REQUESTING
:
1370 case DHCP_STATE_RENEWING
:
1371 case DHCP_STATE_REBINDING
:
1373 r
= client_handle_ack(client
, message
, len
);
1375 client
->timeout_resend
=
1376 sd_event_source_unref(client
->timeout_resend
);
1377 client
->receive_message
=
1378 sd_event_source_unref(client
->receive_message
);
1379 client
->fd
= asynchronous_close(client
->fd
);
1381 if (IN_SET(client
->state
, DHCP_STATE_REQUESTING
,
1382 DHCP_STATE_REBOOTING
))
1383 notify_event
= SD_DHCP_CLIENT_EVENT_IP_ACQUIRE
;
1384 else if (r
!= SD_DHCP_CLIENT_EVENT_IP_ACQUIRE
)
1387 client
->state
= DHCP_STATE_BOUND
;
1388 client
->attempt
= 1;
1390 client
->last_addr
= client
->lease
->address
;
1392 r
= client_set_lease_timeouts(client
);
1394 log_dhcp_client(client
, "could not set lease timeouts");
1398 r
= dhcp_network_bind_udp_socket(client
->lease
->address
,
1401 log_dhcp_client(client
, "could not bind UDP socket");
1407 client_initialize_io_events(client
, client_receive_message_udp
);
1410 client_notify(client
, notify_event
);
1411 if (client
->state
== DHCP_STATE_STOPPED
)
1415 } else if (r
== -EADDRNOTAVAIL
) {
1416 /* got a NAK, let's restart the client */
1417 client
->timeout_resend
=
1418 sd_event_source_unref(client
->timeout_resend
);
1420 r
= client_initialize(client
);
1424 r
= client_start(client
);
1428 log_dhcp_client(client
, "REBOOTED");
1431 } else if (r
== -ENOMSG
)
1432 /* invalid message, let's ignore it */
1437 case DHCP_STATE_BOUND
:
1438 r
= client_handle_forcerenew(client
, message
, len
);
1440 r
= client_timeout_t1(NULL
, 0, client
);
1443 } else if (r
== -ENOMSG
)
1444 /* invalid message, let's ignore it */
1449 case DHCP_STATE_INIT
:
1450 case DHCP_STATE_INIT_REBOOT
:
1454 case DHCP_STATE_STOPPED
:
1461 client_stop(client
, r
);
1466 static int client_receive_message_udp(sd_event_source
*s
, int fd
,
1467 uint32_t revents
, void *userdata
) {
1468 sd_dhcp_client
*client
= userdata
;
1469 _cleanup_free_ DHCPMessage
*message
= NULL
;
1470 int buflen
= 0, len
, r
;
1471 const struct ether_addr zero_mac
= { { 0, 0, 0, 0, 0, 0 } };
1472 const struct ether_addr
*expected_chaddr
= NULL
;
1473 uint8_t expected_hlen
= 0;
1478 r
= ioctl(fd
, FIONREAD
, &buflen
);
1483 /* this can't be right */
1486 message
= malloc0(buflen
);
1490 len
= read(fd
, message
, buflen
);
1492 log_dhcp_client(client
, "could not receive message from UDP "
1495 } else if ((size_t)len
< sizeof(DHCPMessage
)) {
1496 log_dhcp_client(client
, "too small to be a DHCP message: ignoring");
1500 if (be32toh(message
->magic
) != DHCP_MAGIC_COOKIE
) {
1501 log_dhcp_client(client
, "not a DHCP message: ignoring");
1505 if (message
->op
!= BOOTREPLY
) {
1506 log_dhcp_client(client
, "not a BOOTREPLY message: ignoring");
1510 if (message
->htype
!= client
->arp_type
) {
1511 log_dhcp_client(client
, "packet type does not match client type");
1515 if (client
->arp_type
== ARPHRD_ETHER
) {
1516 expected_hlen
= ETH_ALEN
;
1517 expected_chaddr
= (const struct ether_addr
*) &client
->mac_addr
;
1519 /* Non-ethernet links expect zero chaddr */
1521 expected_chaddr
= &zero_mac
;
1524 if (message
->hlen
!= expected_hlen
) {
1525 log_dhcp_client(client
, "unexpected packet hlen %d", message
->hlen
);
1529 if (memcmp(&message
->chaddr
[0], expected_chaddr
, ETH_ALEN
)) {
1530 log_dhcp_client(client
, "received chaddr does not match "
1531 "expected: ignoring");
1535 if (client
->state
!= DHCP_STATE_BOUND
&&
1536 be32toh(message
->xid
) != client
->xid
) {
1537 /* in BOUND state, we may receive FORCERENEW with xid set by server,
1538 so ignore the xid in this case */
1539 log_dhcp_client(client
, "received xid (%u) does not match "
1540 "expected (%u): ignoring",
1541 be32toh(message
->xid
), client
->xid
);
1545 return client_handle_message(client
, message
, len
);
1548 static int client_receive_message_raw(sd_event_source
*s
, int fd
,
1549 uint32_t revents
, void *userdata
) {
1550 sd_dhcp_client
*client
= userdata
;
1551 _cleanup_free_ DHCPPacket
*packet
= NULL
;
1552 uint8_t cmsgbuf
[CMSG_LEN(sizeof(struct tpacket_auxdata
))];
1553 struct iovec iov
= {};
1554 struct msghdr msg
= {
1557 .msg_control
= cmsgbuf
,
1558 .msg_controllen
= sizeof(cmsgbuf
),
1560 struct cmsghdr
*cmsg
;
1561 bool checksum
= true;
1562 int buflen
= 0, len
, r
;
1567 r
= ioctl(fd
, FIONREAD
, &buflen
);
1572 /* this can't be right */
1575 packet
= malloc0(buflen
);
1579 iov
.iov_base
= packet
;
1580 iov
.iov_len
= buflen
;
1582 len
= recvmsg(fd
, &msg
, 0);
1584 log_dhcp_client(client
, "could not receive message from raw "
1587 } else if ((size_t)len
< sizeof(DHCPPacket
))
1590 CMSG_FOREACH(cmsg
, &msg
) {
1591 if (cmsg
->cmsg_level
== SOL_PACKET
&&
1592 cmsg
->cmsg_type
== PACKET_AUXDATA
&&
1593 cmsg
->cmsg_len
== CMSG_LEN(sizeof(struct tpacket_auxdata
))) {
1594 struct tpacket_auxdata
*aux
= (struct tpacket_auxdata
*)CMSG_DATA(cmsg
);
1596 checksum
= !(aux
->tp_status
& TP_STATUS_CSUMNOTREADY
);
1601 r
= dhcp_packet_verify_headers(packet
, len
, checksum
);
1605 len
-= DHCP_IP_UDP_SIZE
;
1607 return client_handle_message(client
, &packet
->dhcp
, len
);
1610 int sd_dhcp_client_start(sd_dhcp_client
*client
) {
1613 assert_return(client
, -EINVAL
);
1615 r
= client_initialize(client
);
1619 if (client
->last_addr
)
1620 client
->state
= DHCP_STATE_INIT_REBOOT
;
1622 r
= client_start(client
);
1624 log_dhcp_client(client
, "STARTED on ifindex %i", client
->index
);
1629 int sd_dhcp_client_stop(sd_dhcp_client
*client
) {
1630 DHCP_CLIENT_DONT_DESTROY(client
);
1632 assert_return(client
, -EINVAL
);
1634 client_stop(client
, SD_DHCP_CLIENT_EVENT_STOP
);
1635 client
->state
= DHCP_STATE_STOPPED
;
1640 int sd_dhcp_client_attach_event(sd_dhcp_client
*client
, sd_event
*event
,
1644 assert_return(client
, -EINVAL
);
1645 assert_return(!client
->event
, -EBUSY
);
1648 client
->event
= sd_event_ref(event
);
1650 r
= sd_event_default(&client
->event
);
1655 client
->event_priority
= priority
;
1660 int sd_dhcp_client_detach_event(sd_dhcp_client
*client
) {
1661 assert_return(client
, -EINVAL
);
1663 client
->event
= sd_event_unref(client
->event
);
1668 sd_event
*sd_dhcp_client_get_event(sd_dhcp_client
*client
) {
1672 return client
->event
;
1675 sd_dhcp_client
*sd_dhcp_client_ref(sd_dhcp_client
*client
) {
1680 assert(client
->n_ref
>= 1);
1686 sd_dhcp_client
*sd_dhcp_client_unref(sd_dhcp_client
*client
) {
1691 assert(client
->n_ref
>= 1);
1694 if (client
->n_ref
> 0)
1697 log_dhcp_client(client
, "FREE");
1699 client_initialize(client
);
1701 client
->receive_message
= sd_event_source_unref(client
->receive_message
);
1703 sd_dhcp_client_detach_event(client
);
1705 sd_dhcp_lease_unref(client
->lease
);
1707 free(client
->req_opts
);
1708 free(client
->hostname
);
1709 free(client
->vendor_class_identifier
);
1715 int sd_dhcp_client_new(sd_dhcp_client
**ret
) {
1716 _cleanup_dhcp_client_unref_ sd_dhcp_client
*client
= NULL
;
1718 assert_return(ret
, -EINVAL
);
1720 client
= new0(sd_dhcp_client
, 1);
1725 client
->state
= DHCP_STATE_INIT
;
1728 client
->attempt
= 1;
1729 client
->mtu
= DHCP_DEFAULT_MIN_SIZE
;
1731 client
->req_opts_size
= ELEMENTSOF(default_req_opts
);
1733 client
->req_opts
= memdup(default_req_opts
, client
->req_opts_size
);
1734 if (!client
->req_opts
)