]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd-network/sd-dhcp-client.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #4686 from poettering/machine-id-app-specific
[thirdparty/systemd.git] / src / libsystemd-network / sd-dhcp-client.c
1 /***
2 This file is part of systemd.
3
4 Copyright (C) 2013 Intel Corporation. All rights reserved.
5
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.
10
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.
15
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/>.
18 ***/
19
20 #include <errno.h>
21 #include <net/ethernet.h>
22 #include <net/if_arp.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/ioctl.h>
27 #include <linux/if_infiniband.h>
28
29 #include "sd-dhcp-client.h"
30
31 #include "alloc-util.h"
32 #include "async.h"
33 #include "dhcp-identifier.h"
34 #include "dhcp-internal.h"
35 #include "dhcp-lease-internal.h"
36 #include "dhcp-protocol.h"
37 #include "dns-domain.h"
38 #include "hostname-util.h"
39 #include "random-util.h"
40 #include "string-util.h"
41 #include "util.h"
42
43 #define MAX_CLIENT_ID_LEN (sizeof(uint32_t) + MAX_DUID_LEN) /* Arbitrary limit */
44 #define MAX_MAC_ADDR_LEN CONST_MAX(INFINIBAND_ALEN, ETH_ALEN)
45
46 #define RESTART_AFTER_NAK_MIN_USEC (1 * USEC_PER_SEC)
47 #define RESTART_AFTER_NAK_MAX_USEC (30 * USEC_PER_MINUTE)
48
49 struct sd_dhcp_client {
50 unsigned n_ref;
51
52 DHCPState state;
53 sd_event *event;
54 int event_priority;
55 sd_event_source *timeout_resend;
56 int ifindex;
57 int fd;
58 uint16_t port;
59 union sockaddr_union link;
60 sd_event_source *receive_message;
61 bool request_broadcast;
62 uint8_t *req_opts;
63 size_t req_opts_allocated;
64 size_t req_opts_size;
65 be32_t last_addr;
66 uint8_t mac_addr[MAX_MAC_ADDR_LEN];
67 size_t mac_addr_len;
68 uint16_t arp_type;
69 struct {
70 uint8_t type;
71 union {
72 struct {
73 /* 0: Generic (non-LL) (RFC 2132) */
74 uint8_t data[MAX_CLIENT_ID_LEN];
75 } _packed_ gen;
76 struct {
77 /* 1: Ethernet Link-Layer (RFC 2132) */
78 uint8_t haddr[ETH_ALEN];
79 } _packed_ eth;
80 struct {
81 /* 2 - 254: ARP/Link-Layer (RFC 2132) */
82 uint8_t haddr[0];
83 } _packed_ ll;
84 struct {
85 /* 255: Node-specific (RFC 4361) */
86 be32_t iaid;
87 struct duid duid;
88 } _packed_ ns;
89 struct {
90 uint8_t data[MAX_CLIENT_ID_LEN];
91 } _packed_ raw;
92 };
93 } _packed_ client_id;
94 size_t client_id_len;
95 char *hostname;
96 char *vendor_class_identifier;
97 uint32_t mtu;
98 uint32_t xid;
99 usec_t start_time;
100 unsigned int attempt;
101 usec_t request_sent;
102 sd_event_source *timeout_t1;
103 sd_event_source *timeout_t2;
104 sd_event_source *timeout_expire;
105 sd_dhcp_client_callback_t callback;
106 void *userdata;
107 sd_dhcp_lease *lease;
108 usec_t start_delay;
109 };
110
111 static const uint8_t default_req_opts[] = {
112 SD_DHCP_OPTION_SUBNET_MASK,
113 SD_DHCP_OPTION_ROUTER,
114 SD_DHCP_OPTION_HOST_NAME,
115 SD_DHCP_OPTION_DOMAIN_NAME,
116 SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
117 };
118
119 static int client_receive_message_raw(
120 sd_event_source *s,
121 int fd,
122 uint32_t revents,
123 void *userdata);
124 static int client_receive_message_udp(
125 sd_event_source *s,
126 int fd,
127 uint32_t revents,
128 void *userdata);
129 static void client_stop(sd_dhcp_client *client, int error);
130
131 int sd_dhcp_client_set_callback(
132 sd_dhcp_client *client,
133 sd_dhcp_client_callback_t cb,
134 void *userdata) {
135
136 assert_return(client, -EINVAL);
137
138 client->callback = cb;
139 client->userdata = userdata;
140
141 return 0;
142 }
143
144 int sd_dhcp_client_set_request_broadcast(sd_dhcp_client *client, int broadcast) {
145 assert_return(client, -EINVAL);
146
147 client->request_broadcast = !!broadcast;
148
149 return 0;
150 }
151
152 int sd_dhcp_client_set_request_option(sd_dhcp_client *client, uint8_t option) {
153 size_t i;
154
155 assert_return(client, -EINVAL);
156 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY);
157
158 switch(option) {
159
160 case SD_DHCP_OPTION_PAD:
161 case SD_DHCP_OPTION_OVERLOAD:
162 case SD_DHCP_OPTION_MESSAGE_TYPE:
163 case SD_DHCP_OPTION_PARAMETER_REQUEST_LIST:
164 case SD_DHCP_OPTION_END:
165 return -EINVAL;
166
167 default:
168 break;
169 }
170
171 for (i = 0; i < client->req_opts_size; i++)
172 if (client->req_opts[i] == option)
173 return -EEXIST;
174
175 if (!GREEDY_REALLOC(client->req_opts, client->req_opts_allocated,
176 client->req_opts_size + 1))
177 return -ENOMEM;
178
179 client->req_opts[client->req_opts_size++] = option;
180
181 return 0;
182 }
183
184 int sd_dhcp_client_set_request_address(
185 sd_dhcp_client *client,
186 const struct in_addr *last_addr) {
187
188 assert_return(client, -EINVAL);
189 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY);
190
191 if (last_addr)
192 client->last_addr = last_addr->s_addr;
193 else
194 client->last_addr = INADDR_ANY;
195
196 return 0;
197 }
198
199 int sd_dhcp_client_set_ifindex(sd_dhcp_client *client, int ifindex) {
200
201 assert_return(client, -EINVAL);
202 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY);
203 assert_return(ifindex > 0, -EINVAL);
204
205 client->ifindex = ifindex;
206 return 0;
207 }
208
209 int sd_dhcp_client_set_mac(
210 sd_dhcp_client *client,
211 const uint8_t *addr,
212 size_t addr_len,
213 uint16_t arp_type) {
214
215 DHCP_CLIENT_DONT_DESTROY(client);
216 bool need_restart = false;
217
218 assert_return(client, -EINVAL);
219 assert_return(addr, -EINVAL);
220 assert_return(addr_len > 0 && addr_len <= MAX_MAC_ADDR_LEN, -EINVAL);
221 assert_return(arp_type > 0, -EINVAL);
222
223 if (arp_type == ARPHRD_ETHER)
224 assert_return(addr_len == ETH_ALEN, -EINVAL);
225 else if (arp_type == ARPHRD_INFINIBAND)
226 assert_return(addr_len == INFINIBAND_ALEN, -EINVAL);
227 else
228 return -EINVAL;
229
230 if (client->mac_addr_len == addr_len &&
231 memcmp(&client->mac_addr, addr, addr_len) == 0)
232 return 0;
233
234 if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
235 log_dhcp_client(client, "Changing MAC address on running DHCP client, restarting");
236 need_restart = true;
237 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
238 }
239
240 memcpy(&client->mac_addr, addr, addr_len);
241 client->mac_addr_len = addr_len;
242 client->arp_type = arp_type;
243
244 if (need_restart && client->state != DHCP_STATE_STOPPED)
245 sd_dhcp_client_start(client);
246
247 return 0;
248 }
249
250 int sd_dhcp_client_get_client_id(
251 sd_dhcp_client *client,
252 uint8_t *type,
253 const uint8_t **data,
254 size_t *data_len) {
255
256 assert_return(client, -EINVAL);
257 assert_return(type, -EINVAL);
258 assert_return(data, -EINVAL);
259 assert_return(data_len, -EINVAL);
260
261 *type = 0;
262 *data = NULL;
263 *data_len = 0;
264 if (client->client_id_len) {
265 *type = client->client_id.type;
266 *data = client->client_id.raw.data;
267 *data_len = client->client_id_len - sizeof(client->client_id.type);
268 }
269
270 return 0;
271 }
272
273 int sd_dhcp_client_set_client_id(
274 sd_dhcp_client *client,
275 uint8_t type,
276 const uint8_t *data,
277 size_t data_len) {
278
279 DHCP_CLIENT_DONT_DESTROY(client);
280 bool need_restart = false;
281
282 assert_return(client, -EINVAL);
283 assert_return(data, -EINVAL);
284 assert_return(data_len > 0 && data_len <= MAX_CLIENT_ID_LEN, -EINVAL);
285
286 switch (type) {
287
288 case ARPHRD_ETHER:
289 if (data_len != ETH_ALEN)
290 return -EINVAL;
291 break;
292
293 case ARPHRD_INFINIBAND:
294 if (data_len != INFINIBAND_ALEN)
295 return -EINVAL;
296 break;
297
298 default:
299 break;
300 }
301
302 if (client->client_id_len == data_len + sizeof(client->client_id.type) &&
303 client->client_id.type == type &&
304 memcmp(&client->client_id.raw.data, data, data_len) == 0)
305 return 0;
306
307 if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
308 log_dhcp_client(client, "Changing client ID on running DHCP "
309 "client, restarting");
310 need_restart = true;
311 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
312 }
313
314 client->client_id.type = type;
315 memcpy(&client->client_id.raw.data, data, data_len);
316 client->client_id_len = data_len + sizeof (client->client_id.type);
317
318 if (need_restart && client->state != DHCP_STATE_STOPPED)
319 sd_dhcp_client_start(client);
320
321 return 0;
322 }
323
324 /**
325 * Sets IAID and DUID. If duid is non-null, the DUID is set to duid_type + duid
326 * without further modification. Otherwise, if duid_type is supported, DUID
327 * is set based on that type. Otherwise, an error is returned.
328 */
329 int sd_dhcp_client_set_iaid_duid(
330 sd_dhcp_client *client,
331 uint32_t iaid,
332 uint16_t duid_type,
333 const void *duid,
334 size_t duid_len) {
335
336 DHCP_CLIENT_DONT_DESTROY(client);
337 int r;
338 size_t len;
339
340 assert_return(client, -EINVAL);
341 assert_return(duid_len == 0 || duid != NULL, -EINVAL);
342
343 if (duid != NULL) {
344 r = dhcp_validate_duid_len(duid_type, duid_len);
345 if (r < 0)
346 return r;
347 }
348
349 zero(client->client_id);
350 client->client_id.type = 255;
351
352 /* If IAID is not configured, generate it. */
353 if (iaid == 0) {
354 r = dhcp_identifier_set_iaid(client->ifindex, client->mac_addr,
355 client->mac_addr_len,
356 &client->client_id.ns.iaid);
357 if (r < 0)
358 return r;
359 } else
360 client->client_id.ns.iaid = htobe32(iaid);
361
362 if (duid != NULL) {
363 client->client_id.ns.duid.type = htobe16(duid_type);
364 memcpy(&client->client_id.ns.duid.raw.data, duid, duid_len);
365 len = sizeof(client->client_id.ns.duid.type) + duid_len;
366 } else if (duid_type == DUID_TYPE_EN) {
367 r = dhcp_identifier_set_duid_en(&client->client_id.ns.duid, &len);
368 if (r < 0)
369 return r;
370 } else
371 return -EOPNOTSUPP;
372
373 client->client_id_len = sizeof(client->client_id.type) + len +
374 sizeof(client->client_id.ns.iaid);
375
376 if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
377 log_dhcp_client(client, "Configured IAID+DUID, restarting.");
378 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
379 sd_dhcp_client_start(client);
380 }
381
382 return 0;
383 }
384
385 int sd_dhcp_client_set_hostname(
386 sd_dhcp_client *client,
387 const char *hostname) {
388
389 assert_return(client, -EINVAL);
390
391 /* Refuse hostnames that neither qualify as DNS nor as Linux hosntames */
392 if (hostname &&
393 !(hostname_is_valid(hostname, false) || dns_name_is_valid(hostname) > 0))
394 return -EINVAL;
395
396 return free_and_strdup(&client->hostname, hostname);
397 }
398
399 int sd_dhcp_client_set_vendor_class_identifier(
400 sd_dhcp_client *client,
401 const char *vci) {
402
403 assert_return(client, -EINVAL);
404
405 return free_and_strdup(&client->vendor_class_identifier, vci);
406 }
407
408 int sd_dhcp_client_set_client_port(
409 sd_dhcp_client *client,
410 uint16_t port) {
411
412 assert_return(client, -EINVAL);
413
414 client->port = port;
415
416 return 0;
417 }
418
419 int sd_dhcp_client_set_mtu(sd_dhcp_client *client, uint32_t mtu) {
420 assert_return(client, -EINVAL);
421 assert_return(mtu >= DHCP_DEFAULT_MIN_SIZE, -ERANGE);
422
423 client->mtu = mtu;
424
425 return 0;
426 }
427
428 int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) {
429 assert_return(client, -EINVAL);
430
431 if (client->state != DHCP_STATE_BOUND &&
432 client->state != DHCP_STATE_RENEWING &&
433 client->state != DHCP_STATE_REBINDING)
434 return -EADDRNOTAVAIL;
435
436 if (ret)
437 *ret = client->lease;
438
439 return 0;
440 }
441
442 static void client_notify(sd_dhcp_client *client, int event) {
443 assert(client);
444
445 if (client->callback)
446 client->callback(client, event, client->userdata);
447 }
448
449 static int client_initialize(sd_dhcp_client *client) {
450 assert_return(client, -EINVAL);
451
452 client->receive_message = sd_event_source_unref(client->receive_message);
453
454 client->fd = asynchronous_close(client->fd);
455
456 client->timeout_resend = sd_event_source_unref(client->timeout_resend);
457
458 client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
459 client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
460 client->timeout_expire = sd_event_source_unref(client->timeout_expire);
461
462 client->attempt = 1;
463
464 client->state = DHCP_STATE_INIT;
465 client->xid = 0;
466
467 client->lease = sd_dhcp_lease_unref(client->lease);
468
469 return 0;
470 }
471
472 static void client_stop(sd_dhcp_client *client, int error) {
473 assert(client);
474
475 if (error < 0)
476 log_dhcp_client(client, "STOPPED: %s", strerror(-error));
477 else if (error == SD_DHCP_CLIENT_EVENT_STOP)
478 log_dhcp_client(client, "STOPPED");
479 else
480 log_dhcp_client(client, "STOPPED: Unknown event");
481
482 client_notify(client, error);
483
484 client_initialize(client);
485 }
486
487 static int client_message_init(
488 sd_dhcp_client *client,
489 DHCPPacket **ret,
490 uint8_t type,
491 size_t *_optlen,
492 size_t *_optoffset) {
493
494 _cleanup_free_ DHCPPacket *packet = NULL;
495 size_t optlen, optoffset, size;
496 be16_t max_size;
497 usec_t time_now;
498 uint16_t secs;
499 int r;
500
501 assert(client);
502 assert(client->start_time);
503 assert(ret);
504 assert(_optlen);
505 assert(_optoffset);
506 assert(type == DHCP_DISCOVER || type == DHCP_REQUEST);
507
508 optlen = DHCP_MIN_OPTIONS_SIZE;
509 size = sizeof(DHCPPacket) + optlen;
510
511 packet = malloc0(size);
512 if (!packet)
513 return -ENOMEM;
514
515 r = dhcp_message_init(&packet->dhcp, BOOTREQUEST, client->xid, type,
516 client->arp_type, optlen, &optoffset);
517 if (r < 0)
518 return r;
519
520 /* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers
521 refuse to issue an DHCP lease if 'secs' is set to zero */
522 r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
523 if (r < 0)
524 return r;
525 assert(time_now >= client->start_time);
526
527 /* seconds between sending first and last DISCOVER
528 * must always be strictly positive to deal with broken servers */
529 secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1;
530 packet->dhcp.secs = htobe16(secs);
531
532 /* RFC2132 section 4.1
533 A client that cannot receive unicast IP datagrams until its protocol
534 software has been configured with an IP address SHOULD set the
535 BROADCAST bit in the 'flags' field to 1 in any DHCPDISCOVER or
536 DHCPREQUEST messages that client sends. The BROADCAST bit will
537 provide a hint to the DHCP server and BOOTP relay agent to broadcast
538 any messages to the client on the client's subnet.
539
540 Note: some interfaces needs this to be enabled, but some networks
541 needs this to be disabled as broadcasts are filteretd, so this
542 needs to be configurable */
543 if (client->request_broadcast || client->arp_type != ARPHRD_ETHER)
544 packet->dhcp.flags = htobe16(0x8000);
545
546 /* RFC2132 section 4.1.1:
547 The client MUST include its hardware address in the ’chaddr’ field, if
548 necessary for delivery of DHCP reply messages. Non-Ethernet
549 interfaces will leave 'chaddr' empty and use the client identifier
550 instead (eg, RFC 4390 section 2.1).
551 */
552 if (client->arp_type == ARPHRD_ETHER)
553 memcpy(&packet->dhcp.chaddr, &client->mac_addr, ETH_ALEN);
554
555 /* If no client identifier exists, construct an RFC 4361-compliant one */
556 if (client->client_id_len == 0) {
557 size_t duid_len;
558
559 client->client_id.type = 255;
560
561 r = dhcp_identifier_set_iaid(client->ifindex, client->mac_addr, client->mac_addr_len, &client->client_id.ns.iaid);
562 if (r < 0)
563 return r;
564
565 r = dhcp_identifier_set_duid_en(&client->client_id.ns.duid, &duid_len);
566 if (r < 0)
567 return r;
568
569 client->client_id_len = sizeof(client->client_id.type) + sizeof(client->client_id.ns.iaid) + duid_len;
570 }
571
572 /* Some DHCP servers will refuse to issue an DHCP lease if the Client
573 Identifier option is not set */
574 if (client->client_id_len) {
575 r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0,
576 SD_DHCP_OPTION_CLIENT_IDENTIFIER,
577 client->client_id_len,
578 &client->client_id);
579 if (r < 0)
580 return r;
581 }
582
583 /* RFC2131 section 3.5:
584 in its initial DHCPDISCOVER or DHCPREQUEST message, a
585 client may provide the server with a list of specific
586 parameters the client is interested in. If the client
587 includes a list of parameters in a DHCPDISCOVER message,
588 it MUST include that list in any subsequent DHCPREQUEST
589 messages.
590 */
591 r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0,
592 SD_DHCP_OPTION_PARAMETER_REQUEST_LIST,
593 client->req_opts_size, client->req_opts);
594 if (r < 0)
595 return r;
596
597 /* RFC2131 section 3.5:
598 The client SHOULD include the ’maximum DHCP message size’ option to
599 let the server know how large the server may make its DHCP messages.
600
601 Note (from ConnMan): Some DHCP servers will send bigger DHCP packets
602 than the defined default size unless the Maximum Messge Size option
603 is explicitly set
604
605 RFC3442 "Requirements to Avoid Sizing Constraints":
606 Because a full routing table can be quite large, the standard 576
607 octet maximum size for a DHCP message may be too short to contain
608 some legitimate Classless Static Route options. Because of this,
609 clients implementing the Classless Static Route option SHOULD send a
610 Maximum DHCP Message Size [4] option if the DHCP client's TCP/IP
611 stack is capable of receiving larger IP datagrams. In this case, the
612 client SHOULD set the value of this option to at least the MTU of the
613 interface that the client is configuring. The client MAY set the
614 value of this option higher, up to the size of the largest UDP packet
615 it is prepared to accept. (Note that the value specified in the
616 Maximum DHCP Message Size option is the total maximum packet size,
617 including IP and UDP headers.)
618 */
619 max_size = htobe16(size);
620 r = dhcp_option_append(&packet->dhcp, client->mtu, &optoffset, 0,
621 SD_DHCP_OPTION_MAXIMUM_MESSAGE_SIZE,
622 2, &max_size);
623 if (r < 0)
624 return r;
625
626 *_optlen = optlen;
627 *_optoffset = optoffset;
628 *ret = packet;
629 packet = NULL;
630
631 return 0;
632 }
633
634 static int client_append_fqdn_option(
635 DHCPMessage *message,
636 size_t optlen,
637 size_t *optoffset,
638 const char *fqdn) {
639
640 uint8_t buffer[3 + DHCP_MAX_FQDN_LENGTH];
641 int r;
642
643 buffer[0] = DHCP_FQDN_FLAG_S | /* Request server to perform A RR DNS updates */
644 DHCP_FQDN_FLAG_E; /* Canonical wire format */
645 buffer[1] = 0; /* RCODE1 (deprecated) */
646 buffer[2] = 0; /* RCODE2 (deprecated) */
647
648 r = dns_name_to_wire_format(fqdn, buffer + 3, sizeof(buffer) - 3, false);
649 if (r > 0)
650 r = dhcp_option_append(message, optlen, optoffset, 0,
651 SD_DHCP_OPTION_FQDN, 3 + r, buffer);
652
653 return r;
654 }
655
656 static int dhcp_client_send_raw(
657 sd_dhcp_client *client,
658 DHCPPacket *packet,
659 size_t len) {
660
661 dhcp_packet_append_ip_headers(packet, INADDR_ANY, client->port,
662 INADDR_BROADCAST, DHCP_PORT_SERVER, len);
663
664 return dhcp_network_send_raw_socket(client->fd, &client->link,
665 packet, len);
666 }
667
668 static int client_send_discover(sd_dhcp_client *client) {
669 _cleanup_free_ DHCPPacket *discover = NULL;
670 size_t optoffset, optlen;
671 int r;
672
673 assert(client);
674 assert(client->state == DHCP_STATE_INIT ||
675 client->state == DHCP_STATE_SELECTING);
676
677 r = client_message_init(client, &discover, DHCP_DISCOVER,
678 &optlen, &optoffset);
679 if (r < 0)
680 return r;
681
682 /* the client may suggest values for the network address
683 and lease time in the DHCPDISCOVER message. The client may include
684 the ’requested IP address’ option to suggest that a particular IP
685 address be assigned, and may include the ’IP address lease time’
686 option to suggest the lease time it would like.
687 */
688 if (client->last_addr != INADDR_ANY) {
689 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
690 SD_DHCP_OPTION_REQUESTED_IP_ADDRESS,
691 4, &client->last_addr);
692 if (r < 0)
693 return r;
694 }
695
696 if (client->hostname) {
697 /* According to RFC 4702 "clients that send the Client FQDN option in
698 their messages MUST NOT also send the Host Name option". Just send
699 one of the two depending on the hostname type.
700 */
701 if (dns_name_is_single_label(client->hostname)) {
702 /* it is unclear from RFC 2131 if client should send hostname in
703 DHCPDISCOVER but dhclient does and so we do as well
704 */
705 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
706 SD_DHCP_OPTION_HOST_NAME,
707 strlen(client->hostname), client->hostname);
708 } else
709 r = client_append_fqdn_option(&discover->dhcp, optlen, &optoffset,
710 client->hostname);
711 if (r < 0)
712 return r;
713 }
714
715 if (client->vendor_class_identifier) {
716 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
717 SD_DHCP_OPTION_VENDOR_CLASS_IDENTIFIER,
718 strlen(client->vendor_class_identifier),
719 client->vendor_class_identifier);
720 if (r < 0)
721 return r;
722 }
723
724 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
725 SD_DHCP_OPTION_END, 0, NULL);
726 if (r < 0)
727 return r;
728
729 /* We currently ignore:
730 The client SHOULD wait a random time between one and ten seconds to
731 desynchronize the use of DHCP at startup.
732 */
733 r = dhcp_client_send_raw(client, discover, sizeof(DHCPPacket) + optoffset);
734 if (r < 0)
735 return r;
736
737 log_dhcp_client(client, "DISCOVER");
738
739 return 0;
740 }
741
742 static int client_send_request(sd_dhcp_client *client) {
743 _cleanup_free_ DHCPPacket *request = NULL;
744 size_t optoffset, optlen;
745 int r;
746
747 assert(client);
748
749 r = client_message_init(client, &request, DHCP_REQUEST, &optlen, &optoffset);
750 if (r < 0)
751 return r;
752
753 switch (client->state) {
754 /* See RFC2131 section 4.3.2 (note that there is a typo in the RFC,
755 SELECTING should be REQUESTING)
756 */
757
758 case DHCP_STATE_REQUESTING:
759 /* Client inserts the address of the selected server in ’server
760 identifier’, ’ciaddr’ MUST be zero, ’requested IP address’ MUST be
761 filled in with the yiaddr value from the chosen DHCPOFFER.
762 */
763
764 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
765 SD_DHCP_OPTION_SERVER_IDENTIFIER,
766 4, &client->lease->server_address);
767 if (r < 0)
768 return r;
769
770 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
771 SD_DHCP_OPTION_REQUESTED_IP_ADDRESS,
772 4, &client->lease->address);
773 if (r < 0)
774 return r;
775
776 break;
777
778 case DHCP_STATE_INIT_REBOOT:
779 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
780 option MUST be filled in with client’s notion of its previously
781 assigned address. ’ciaddr’ MUST be zero.
782 */
783 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
784 SD_DHCP_OPTION_REQUESTED_IP_ADDRESS,
785 4, &client->last_addr);
786 if (r < 0)
787 return r;
788 break;
789
790 case DHCP_STATE_RENEWING:
791 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
792 option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
793 client’s IP address.
794 */
795
796 /* fall through */
797 case DHCP_STATE_REBINDING:
798 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
799 option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
800 client’s IP address.
801
802 This message MUST be broadcast to the 0xffffffff IP broadcast address.
803 */
804 request->dhcp.ciaddr = client->lease->address;
805
806 break;
807
808 case DHCP_STATE_INIT:
809 case DHCP_STATE_SELECTING:
810 case DHCP_STATE_REBOOTING:
811 case DHCP_STATE_BOUND:
812 case DHCP_STATE_STOPPED:
813 return -EINVAL;
814 }
815
816 if (client->hostname) {
817 if (dns_name_is_single_label(client->hostname))
818 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
819 SD_DHCP_OPTION_HOST_NAME,
820 strlen(client->hostname), client->hostname);
821 else
822 r = client_append_fqdn_option(&request->dhcp, optlen, &optoffset,
823 client->hostname);
824 if (r < 0)
825 return r;
826 }
827
828 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
829 SD_DHCP_OPTION_END, 0, NULL);
830 if (r < 0)
831 return r;
832
833 if (client->state == DHCP_STATE_RENEWING) {
834 r = dhcp_network_send_udp_socket(client->fd,
835 client->lease->server_address,
836 DHCP_PORT_SERVER,
837 &request->dhcp,
838 sizeof(DHCPMessage) + optoffset);
839 } else {
840 r = dhcp_client_send_raw(client, request, sizeof(DHCPPacket) + optoffset);
841 }
842 if (r < 0)
843 return r;
844
845 switch (client->state) {
846
847 case DHCP_STATE_REQUESTING:
848 log_dhcp_client(client, "REQUEST (requesting)");
849 break;
850
851 case DHCP_STATE_INIT_REBOOT:
852 log_dhcp_client(client, "REQUEST (init-reboot)");
853 break;
854
855 case DHCP_STATE_RENEWING:
856 log_dhcp_client(client, "REQUEST (renewing)");
857 break;
858
859 case DHCP_STATE_REBINDING:
860 log_dhcp_client(client, "REQUEST (rebinding)");
861 break;
862
863 default:
864 log_dhcp_client(client, "REQUEST (invalid)");
865 break;
866 }
867
868 return 0;
869 }
870
871 static int client_start(sd_dhcp_client *client);
872
873 static int client_timeout_resend(
874 sd_event_source *s,
875 uint64_t usec,
876 void *userdata) {
877
878 sd_dhcp_client *client = userdata;
879 DHCP_CLIENT_DONT_DESTROY(client);
880 usec_t next_timeout = 0;
881 uint64_t time_now;
882 uint32_t time_left;
883 int r;
884
885 assert(s);
886 assert(client);
887 assert(client->event);
888
889 r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
890 if (r < 0)
891 goto error;
892
893 switch (client->state) {
894
895 case DHCP_STATE_RENEWING:
896
897 time_left = (client->lease->t2 - client->lease->t1) / 2;
898 if (time_left < 60)
899 time_left = 60;
900
901 next_timeout = time_now + time_left * USEC_PER_SEC;
902
903 break;
904
905 case DHCP_STATE_REBINDING:
906
907 time_left = (client->lease->lifetime - client->lease->t2) / 2;
908 if (time_left < 60)
909 time_left = 60;
910
911 next_timeout = time_now + time_left * USEC_PER_SEC;
912 break;
913
914 case DHCP_STATE_REBOOTING:
915 /* start over as we did not receive a timely ack or nak */
916 r = client_initialize(client);
917 if (r < 0)
918 goto error;
919
920 r = client_start(client);
921 if (r < 0)
922 goto error;
923 else {
924 log_dhcp_client(client, "REBOOTED");
925 return 0;
926 }
927
928 case DHCP_STATE_INIT:
929 case DHCP_STATE_INIT_REBOOT:
930 case DHCP_STATE_SELECTING:
931 case DHCP_STATE_REQUESTING:
932 case DHCP_STATE_BOUND:
933
934 if (client->attempt < 64)
935 client->attempt *= 2;
936
937 next_timeout = time_now + (client->attempt - 1) * USEC_PER_SEC;
938
939 break;
940
941 case DHCP_STATE_STOPPED:
942 r = -EINVAL;
943 goto error;
944 }
945
946 next_timeout += (random_u32() & 0x1fffff);
947
948 client->timeout_resend = sd_event_source_unref(client->timeout_resend);
949
950 r = sd_event_add_time(client->event,
951 &client->timeout_resend,
952 clock_boottime_or_monotonic(),
953 next_timeout, 10 * USEC_PER_MSEC,
954 client_timeout_resend, client);
955 if (r < 0)
956 goto error;
957
958 r = sd_event_source_set_priority(client->timeout_resend,
959 client->event_priority);
960 if (r < 0)
961 goto error;
962
963 r = sd_event_source_set_description(client->timeout_resend, "dhcp4-resend-timer");
964 if (r < 0)
965 goto error;
966
967 switch (client->state) {
968 case DHCP_STATE_INIT:
969 r = client_send_discover(client);
970 if (r >= 0) {
971 client->state = DHCP_STATE_SELECTING;
972 client->attempt = 1;
973 } else {
974 if (client->attempt >= 64)
975 goto error;
976 }
977
978 break;
979
980 case DHCP_STATE_SELECTING:
981 r = client_send_discover(client);
982 if (r < 0 && client->attempt >= 64)
983 goto error;
984
985 break;
986
987 case DHCP_STATE_INIT_REBOOT:
988 case DHCP_STATE_REQUESTING:
989 case DHCP_STATE_RENEWING:
990 case DHCP_STATE_REBINDING:
991 r = client_send_request(client);
992 if (r < 0 && client->attempt >= 64)
993 goto error;
994
995 if (client->state == DHCP_STATE_INIT_REBOOT)
996 client->state = DHCP_STATE_REBOOTING;
997
998 client->request_sent = time_now;
999
1000 break;
1001
1002 case DHCP_STATE_REBOOTING:
1003 case DHCP_STATE_BOUND:
1004
1005 break;
1006
1007 case DHCP_STATE_STOPPED:
1008 r = -EINVAL;
1009 goto error;
1010 }
1011
1012 return 0;
1013
1014 error:
1015 client_stop(client, r);
1016
1017 /* Errors were dealt with when stopping the client, don't spill
1018 errors into the event loop handler */
1019 return 0;
1020 }
1021
1022 static int client_initialize_io_events(
1023 sd_dhcp_client *client,
1024 sd_event_io_handler_t io_callback) {
1025
1026 int r;
1027
1028 assert(client);
1029 assert(client->event);
1030
1031 r = sd_event_add_io(client->event, &client->receive_message,
1032 client->fd, EPOLLIN, io_callback,
1033 client);
1034 if (r < 0)
1035 goto error;
1036
1037 r = sd_event_source_set_priority(client->receive_message,
1038 client->event_priority);
1039 if (r < 0)
1040 goto error;
1041
1042 r = sd_event_source_set_description(client->receive_message, "dhcp4-receive-message");
1043 if (r < 0)
1044 goto error;
1045
1046 error:
1047 if (r < 0)
1048 client_stop(client, r);
1049
1050 return 0;
1051 }
1052
1053 static int client_initialize_time_events(sd_dhcp_client *client) {
1054 uint64_t usec = 0;
1055 int r;
1056
1057 assert(client);
1058 assert(client->event);
1059
1060 client->timeout_resend = sd_event_source_unref(client->timeout_resend);
1061
1062 if (client->start_delay) {
1063 assert_se(sd_event_now(client->event, clock_boottime_or_monotonic(), &usec) >= 0);
1064 usec += client->start_delay;
1065 }
1066
1067 r = sd_event_add_time(client->event,
1068 &client->timeout_resend,
1069 clock_boottime_or_monotonic(),
1070 usec, 0,
1071 client_timeout_resend, client);
1072 if (r < 0)
1073 goto error;
1074
1075 r = sd_event_source_set_priority(client->timeout_resend,
1076 client->event_priority);
1077 if (r < 0)
1078 goto error;
1079
1080 r = sd_event_source_set_description(client->timeout_resend, "dhcp4-resend-timer");
1081 if (r < 0)
1082 goto error;
1083
1084 error:
1085 if (r < 0)
1086 client_stop(client, r);
1087
1088 return 0;
1089
1090 }
1091
1092 static int client_initialize_events(sd_dhcp_client *client, sd_event_io_handler_t io_callback) {
1093 client_initialize_io_events(client, io_callback);
1094 client_initialize_time_events(client);
1095
1096 return 0;
1097 }
1098
1099 static int client_start_delayed(sd_dhcp_client *client) {
1100 int r;
1101
1102 assert_return(client, -EINVAL);
1103 assert_return(client->event, -EINVAL);
1104 assert_return(client->ifindex > 0, -EINVAL);
1105 assert_return(client->fd < 0, -EBUSY);
1106 assert_return(client->xid == 0, -EINVAL);
1107 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_INIT_REBOOT), -EBUSY);
1108
1109 client->xid = random_u32();
1110
1111 r = dhcp_network_bind_raw_socket(client->ifindex, &client->link,
1112 client->xid, client->mac_addr,
1113 client->mac_addr_len, client->arp_type, client->port);
1114 if (r < 0) {
1115 client_stop(client, r);
1116 return r;
1117 }
1118 client->fd = r;
1119
1120 if (client->state == DHCP_STATE_INIT || client->state == DHCP_STATE_INIT_REBOOT)
1121 client->start_time = now(clock_boottime_or_monotonic());
1122
1123 return client_initialize_events(client, client_receive_message_raw);
1124 }
1125
1126 static int client_start(sd_dhcp_client *client) {
1127 client->start_delay = 0;
1128 return client_start_delayed(client);
1129 }
1130
1131 static int client_timeout_expire(sd_event_source *s, uint64_t usec, void *userdata) {
1132 sd_dhcp_client *client = userdata;
1133 DHCP_CLIENT_DONT_DESTROY(client);
1134
1135 log_dhcp_client(client, "EXPIRED");
1136
1137 client_notify(client, SD_DHCP_CLIENT_EVENT_EXPIRED);
1138
1139 /* lease was lost, start over if not freed or stopped in callback */
1140 if (client->state != DHCP_STATE_STOPPED) {
1141 client_initialize(client);
1142 client_start(client);
1143 }
1144
1145 return 0;
1146 }
1147
1148 static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) {
1149 sd_dhcp_client *client = userdata;
1150 DHCP_CLIENT_DONT_DESTROY(client);
1151 int r;
1152
1153 assert(client);
1154
1155 client->receive_message = sd_event_source_unref(client->receive_message);
1156 client->fd = asynchronous_close(client->fd);
1157
1158 client->state = DHCP_STATE_REBINDING;
1159 client->attempt = 1;
1160
1161 r = dhcp_network_bind_raw_socket(client->ifindex, &client->link,
1162 client->xid, client->mac_addr,
1163 client->mac_addr_len, client->arp_type,
1164 client->port);
1165 if (r < 0) {
1166 client_stop(client, r);
1167 return 0;
1168 }
1169 client->fd = r;
1170
1171 return client_initialize_events(client, client_receive_message_raw);
1172 }
1173
1174 static int client_timeout_t1(sd_event_source *s, uint64_t usec, void *userdata) {
1175 sd_dhcp_client *client = userdata;
1176 DHCP_CLIENT_DONT_DESTROY(client);
1177
1178 client->state = DHCP_STATE_RENEWING;
1179 client->attempt = 1;
1180
1181 return client_initialize_time_events(client);
1182 }
1183
1184 static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer, size_t len) {
1185 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
1186 int r;
1187
1188 r = dhcp_lease_new(&lease);
1189 if (r < 0)
1190 return r;
1191
1192 if (client->client_id_len) {
1193 r = dhcp_lease_set_client_id(lease,
1194 (uint8_t *) &client->client_id,
1195 client->client_id_len);
1196 if (r < 0)
1197 return r;
1198 }
1199
1200 r = dhcp_option_parse(offer, len, dhcp_lease_parse_options, lease, NULL);
1201 if (r != DHCP_OFFER) {
1202 log_dhcp_client(client, "received message was not an OFFER, ignoring");
1203 return -ENOMSG;
1204 }
1205
1206 lease->next_server = offer->siaddr;
1207 lease->address = offer->yiaddr;
1208
1209 if (lease->address == 0 ||
1210 lease->server_address == 0 ||
1211 lease->lifetime == 0) {
1212 log_dhcp_client(client, "received lease lacks address, server address or lease lifetime, ignoring");
1213 return -ENOMSG;
1214 }
1215
1216 if (!lease->have_subnet_mask) {
1217 r = dhcp_lease_set_default_subnet_mask(lease);
1218 if (r < 0) {
1219 log_dhcp_client(client, "received lease lacks subnet "
1220 "mask, and a fallback one can not be "
1221 "generated, ignoring");
1222 return -ENOMSG;
1223 }
1224 }
1225
1226 sd_dhcp_lease_unref(client->lease);
1227 client->lease = lease;
1228 lease = NULL;
1229
1230 log_dhcp_client(client, "OFFER");
1231
1232 return 0;
1233 }
1234
1235 static int client_handle_forcerenew(sd_dhcp_client *client, DHCPMessage *force, size_t len) {
1236 int r;
1237
1238 r = dhcp_option_parse(force, len, NULL, NULL, NULL);
1239 if (r != DHCP_FORCERENEW)
1240 return -ENOMSG;
1241
1242 log_dhcp_client(client, "FORCERENEW");
1243
1244 return 0;
1245 }
1246
1247 static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack, size_t len) {
1248 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
1249 _cleanup_free_ char *error_message = NULL;
1250 int r;
1251
1252 r = dhcp_lease_new(&lease);
1253 if (r < 0)
1254 return r;
1255
1256 if (client->client_id_len) {
1257 r = dhcp_lease_set_client_id(lease,
1258 (uint8_t *) &client->client_id,
1259 client->client_id_len);
1260 if (r < 0)
1261 return r;
1262 }
1263
1264 r = dhcp_option_parse(ack, len, dhcp_lease_parse_options, lease, &error_message);
1265 if (r == DHCP_NAK) {
1266 log_dhcp_client(client, "NAK: %s", strna(error_message));
1267 return -EADDRNOTAVAIL;
1268 }
1269
1270 if (r != DHCP_ACK) {
1271 log_dhcp_client(client, "received message was not an ACK, ignoring");
1272 return -ENOMSG;
1273 }
1274
1275 lease->next_server = ack->siaddr;
1276
1277 lease->address = ack->yiaddr;
1278
1279 if (lease->address == INADDR_ANY ||
1280 lease->server_address == INADDR_ANY ||
1281 lease->lifetime == 0) {
1282 log_dhcp_client(client, "received lease lacks address, server "
1283 "address or lease lifetime, ignoring");
1284 return -ENOMSG;
1285 }
1286
1287 if (lease->subnet_mask == INADDR_ANY) {
1288 r = dhcp_lease_set_default_subnet_mask(lease);
1289 if (r < 0) {
1290 log_dhcp_client(client, "received lease lacks subnet "
1291 "mask, and a fallback one can not be "
1292 "generated, ignoring");
1293 return -ENOMSG;
1294 }
1295 }
1296
1297 r = SD_DHCP_CLIENT_EVENT_IP_ACQUIRE;
1298 if (client->lease) {
1299 if (client->lease->address != lease->address ||
1300 client->lease->subnet_mask != lease->subnet_mask ||
1301 client->lease->router != lease->router) {
1302 r = SD_DHCP_CLIENT_EVENT_IP_CHANGE;
1303 } else
1304 r = SD_DHCP_CLIENT_EVENT_RENEW;
1305
1306 client->lease = sd_dhcp_lease_unref(client->lease);
1307 }
1308
1309 client->lease = lease;
1310 lease = NULL;
1311
1312 log_dhcp_client(client, "ACK");
1313
1314 return r;
1315 }
1316
1317 static uint64_t client_compute_timeout(sd_dhcp_client *client, uint32_t lifetime, double factor) {
1318 assert(client);
1319 assert(client->request_sent);
1320 assert(lifetime > 0);
1321
1322 if (lifetime > 3)
1323 lifetime -= 3;
1324 else
1325 lifetime = 0;
1326
1327 return client->request_sent + (lifetime * USEC_PER_SEC * factor) +
1328 + (random_u32() & 0x1fffff);
1329 }
1330
1331 static int client_set_lease_timeouts(sd_dhcp_client *client) {
1332 usec_t time_now;
1333 uint64_t lifetime_timeout;
1334 uint64_t t2_timeout;
1335 uint64_t t1_timeout;
1336 char time_string[FORMAT_TIMESPAN_MAX];
1337 int r;
1338
1339 assert(client);
1340 assert(client->event);
1341 assert(client->lease);
1342 assert(client->lease->lifetime);
1343
1344 client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
1345 client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
1346 client->timeout_expire = sd_event_source_unref(client->timeout_expire);
1347
1348 /* don't set timers for infinite leases */
1349 if (client->lease->lifetime == 0xffffffff)
1350 return 0;
1351
1352 r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
1353 if (r < 0)
1354 return r;
1355 assert(client->request_sent <= time_now);
1356
1357 /* convert the various timeouts from relative (secs) to absolute (usecs) */
1358 lifetime_timeout = client_compute_timeout(client, client->lease->lifetime, 1);
1359 if (client->lease->t1 > 0 && client->lease->t2 > 0) {
1360 /* both T1 and T2 are given */
1361 if (client->lease->t1 < client->lease->t2 &&
1362 client->lease->t2 < client->lease->lifetime) {
1363 /* they are both valid */
1364 t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
1365 t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
1366 } else {
1367 /* discard both */
1368 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1369 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1370 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1371 client->lease->t1 = client->lease->lifetime / 2;
1372 }
1373 } else if (client->lease->t2 > 0 && client->lease->t2 < client->lease->lifetime) {
1374 /* only T2 is given, and it is valid */
1375 t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
1376 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1377 client->lease->t1 = client->lease->lifetime / 2;
1378 if (t2_timeout <= t1_timeout) {
1379 /* the computed T1 would be invalid, so discard T2 */
1380 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1381 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1382 }
1383 } else if (client->lease->t1 > 0 && client->lease->t1 < client->lease->lifetime) {
1384 /* only T1 is given, and it is valid */
1385 t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
1386 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1387 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1388 if (t2_timeout <= t1_timeout) {
1389 /* the computed T2 would be invalid, so discard T1 */
1390 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1391 client->lease->t2 = client->lease->lifetime / 2;
1392 }
1393 } else {
1394 /* fall back to the default timeouts */
1395 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1396 client->lease->t1 = client->lease->lifetime / 2;
1397 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1398 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1399 }
1400
1401 /* arm lifetime timeout */
1402 r = sd_event_add_time(client->event, &client->timeout_expire,
1403 clock_boottime_or_monotonic(),
1404 lifetime_timeout, 10 * USEC_PER_MSEC,
1405 client_timeout_expire, client);
1406 if (r < 0)
1407 return r;
1408
1409 r = sd_event_source_set_priority(client->timeout_expire,
1410 client->event_priority);
1411 if (r < 0)
1412 return r;
1413
1414 r = sd_event_source_set_description(client->timeout_expire, "dhcp4-lifetime");
1415 if (r < 0)
1416 return r;
1417
1418 log_dhcp_client(client, "lease expires in %s",
1419 format_timespan(time_string, FORMAT_TIMESPAN_MAX, lifetime_timeout - time_now, USEC_PER_SEC));
1420
1421 /* don't arm earlier timeouts if this has already expired */
1422 if (lifetime_timeout <= time_now)
1423 return 0;
1424
1425 /* arm T2 timeout */
1426 r = sd_event_add_time(client->event,
1427 &client->timeout_t2,
1428 clock_boottime_or_monotonic(),
1429 t2_timeout,
1430 10 * USEC_PER_MSEC,
1431 client_timeout_t2, client);
1432 if (r < 0)
1433 return r;
1434
1435 r = sd_event_source_set_priority(client->timeout_t2,
1436 client->event_priority);
1437 if (r < 0)
1438 return r;
1439
1440 r = sd_event_source_set_description(client->timeout_t2, "dhcp4-t2-timeout");
1441 if (r < 0)
1442 return r;
1443
1444 log_dhcp_client(client, "T2 expires in %s",
1445 format_timespan(time_string, FORMAT_TIMESPAN_MAX, t2_timeout - time_now, USEC_PER_SEC));
1446
1447 /* don't arm earlier timeout if this has already expired */
1448 if (t2_timeout <= time_now)
1449 return 0;
1450
1451 /* arm T1 timeout */
1452 r = sd_event_add_time(client->event,
1453 &client->timeout_t1,
1454 clock_boottime_or_monotonic(),
1455 t1_timeout, 10 * USEC_PER_MSEC,
1456 client_timeout_t1, client);
1457 if (r < 0)
1458 return r;
1459
1460 r = sd_event_source_set_priority(client->timeout_t1,
1461 client->event_priority);
1462 if (r < 0)
1463 return r;
1464
1465 r = sd_event_source_set_description(client->timeout_t1, "dhcp4-t1-timer");
1466 if (r < 0)
1467 return r;
1468
1469 log_dhcp_client(client, "T1 expires in %s",
1470 format_timespan(time_string, FORMAT_TIMESPAN_MAX, t1_timeout - time_now, USEC_PER_SEC));
1471
1472 return 0;
1473 }
1474
1475 static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, int len) {
1476 DHCP_CLIENT_DONT_DESTROY(client);
1477 char time_string[FORMAT_TIMESPAN_MAX];
1478 int r = 0, notify_event = 0;
1479
1480 assert(client);
1481 assert(client->event);
1482 assert(message);
1483
1484 switch (client->state) {
1485 case DHCP_STATE_SELECTING:
1486
1487 r = client_handle_offer(client, message, len);
1488 if (r >= 0) {
1489
1490 client->timeout_resend =
1491 sd_event_source_unref(client->timeout_resend);
1492
1493 client->state = DHCP_STATE_REQUESTING;
1494 client->attempt = 1;
1495
1496 r = sd_event_add_time(client->event,
1497 &client->timeout_resend,
1498 clock_boottime_or_monotonic(),
1499 0, 0,
1500 client_timeout_resend, client);
1501 if (r < 0)
1502 goto error;
1503
1504 r = sd_event_source_set_priority(client->timeout_resend,
1505 client->event_priority);
1506 if (r < 0)
1507 goto error;
1508
1509 r = sd_event_source_set_description(client->timeout_resend, "dhcp4-resend-timer");
1510 if (r < 0)
1511 goto error;
1512 } else if (r == -ENOMSG)
1513 /* invalid message, let's ignore it */
1514 return 0;
1515
1516 break;
1517
1518 case DHCP_STATE_REBOOTING:
1519 case DHCP_STATE_REQUESTING:
1520 case DHCP_STATE_RENEWING:
1521 case DHCP_STATE_REBINDING:
1522
1523 r = client_handle_ack(client, message, len);
1524 if (r >= 0) {
1525 client->start_delay = 0;
1526 client->timeout_resend =
1527 sd_event_source_unref(client->timeout_resend);
1528 client->receive_message =
1529 sd_event_source_unref(client->receive_message);
1530 client->fd = asynchronous_close(client->fd);
1531
1532 if (IN_SET(client->state, DHCP_STATE_REQUESTING,
1533 DHCP_STATE_REBOOTING))
1534 notify_event = SD_DHCP_CLIENT_EVENT_IP_ACQUIRE;
1535 else if (r != SD_DHCP_CLIENT_EVENT_IP_ACQUIRE)
1536 notify_event = r;
1537
1538 client->state = DHCP_STATE_BOUND;
1539 client->attempt = 1;
1540
1541 client->last_addr = client->lease->address;
1542
1543 r = client_set_lease_timeouts(client);
1544 if (r < 0) {
1545 log_dhcp_client(client, "could not set lease timeouts");
1546 goto error;
1547 }
1548
1549 r = dhcp_network_bind_udp_socket(client->ifindex, client->lease->address, client->port);
1550 if (r < 0) {
1551 log_dhcp_client(client, "could not bind UDP socket");
1552 goto error;
1553 }
1554
1555 client->fd = r;
1556
1557 client_initialize_io_events(client, client_receive_message_udp);
1558
1559 if (notify_event) {
1560 client_notify(client, notify_event);
1561 if (client->state == DHCP_STATE_STOPPED)
1562 return 0;
1563 }
1564
1565 } else if (r == -EADDRNOTAVAIL) {
1566 /* got a NAK, let's restart the client */
1567 client->timeout_resend =
1568 sd_event_source_unref(client->timeout_resend);
1569
1570 r = client_initialize(client);
1571 if (r < 0)
1572 goto error;
1573
1574 r = client_start_delayed(client);
1575 if (r < 0)
1576 goto error;
1577
1578 log_dhcp_client(client, "REBOOT in %s", format_timespan(time_string, FORMAT_TIMESPAN_MAX,
1579 client->start_delay, USEC_PER_SEC));
1580
1581 client->start_delay = CLAMP(client->start_delay * 2,
1582 RESTART_AFTER_NAK_MIN_USEC, RESTART_AFTER_NAK_MAX_USEC);
1583
1584 return 0;
1585 } else if (r == -ENOMSG)
1586 /* invalid message, let's ignore it */
1587 return 0;
1588
1589 break;
1590
1591 case DHCP_STATE_BOUND:
1592 r = client_handle_forcerenew(client, message, len);
1593 if (r >= 0) {
1594 r = client_timeout_t1(NULL, 0, client);
1595 if (r < 0)
1596 goto error;
1597 } else if (r == -ENOMSG)
1598 /* invalid message, let's ignore it */
1599 return 0;
1600
1601 break;
1602
1603 case DHCP_STATE_INIT:
1604 case DHCP_STATE_INIT_REBOOT:
1605
1606 break;
1607
1608 case DHCP_STATE_STOPPED:
1609 r = -EINVAL;
1610 goto error;
1611 }
1612
1613 error:
1614 if (r < 0)
1615 client_stop(client, r);
1616
1617 return r;
1618 }
1619
1620 static int client_receive_message_udp(
1621 sd_event_source *s,
1622 int fd,
1623 uint32_t revents,
1624 void *userdata) {
1625
1626 sd_dhcp_client *client = userdata;
1627 _cleanup_free_ DHCPMessage *message = NULL;
1628 const struct ether_addr zero_mac = {};
1629 const struct ether_addr *expected_chaddr = NULL;
1630 uint8_t expected_hlen = 0;
1631 ssize_t len, buflen;
1632
1633 assert(s);
1634 assert(client);
1635
1636 buflen = next_datagram_size_fd(fd);
1637 if (buflen < 0)
1638 return buflen;
1639
1640 message = malloc0(buflen);
1641 if (!message)
1642 return -ENOMEM;
1643
1644 len = recv(fd, message, buflen, 0);
1645 if (len < 0) {
1646 if (errno == EAGAIN || errno == EINTR)
1647 return 0;
1648
1649 return log_dhcp_client_errno(client, errno, "Could not receive message from UDP socket: %m");
1650 }
1651 if ((size_t) len < sizeof(DHCPMessage)) {
1652 log_dhcp_client(client, "Too small to be a DHCP message: ignoring");
1653 return 0;
1654 }
1655
1656 if (be32toh(message->magic) != DHCP_MAGIC_COOKIE) {
1657 log_dhcp_client(client, "Not a DHCP message: ignoring");
1658 return 0;
1659 }
1660
1661 if (message->op != BOOTREPLY) {
1662 log_dhcp_client(client, "Not a BOOTREPLY message: ignoring");
1663 return 0;
1664 }
1665
1666 if (message->htype != client->arp_type) {
1667 log_dhcp_client(client, "Packet type does not match client type");
1668 return 0;
1669 }
1670
1671 if (client->arp_type == ARPHRD_ETHER) {
1672 expected_hlen = ETH_ALEN;
1673 expected_chaddr = (const struct ether_addr *) &client->mac_addr;
1674 } else {
1675 /* Non-Ethernet links expect zero chaddr */
1676 expected_hlen = 0;
1677 expected_chaddr = &zero_mac;
1678 }
1679
1680 if (message->hlen != expected_hlen) {
1681 log_dhcp_client(client, "Unexpected packet hlen %d", message->hlen);
1682 return 0;
1683 }
1684
1685 if (memcmp(&message->chaddr[0], expected_chaddr, ETH_ALEN)) {
1686 log_dhcp_client(client, "Received chaddr does not match expected: ignoring");
1687 return 0;
1688 }
1689
1690 if (client->state != DHCP_STATE_BOUND &&
1691 be32toh(message->xid) != client->xid) {
1692 /* in BOUND state, we may receive FORCERENEW with xid set by server,
1693 so ignore the xid in this case */
1694 log_dhcp_client(client, "Received xid (%u) does not match expected (%u): ignoring",
1695 be32toh(message->xid), client->xid);
1696 return 0;
1697 }
1698
1699 return client_handle_message(client, message, len);
1700 }
1701
1702 static int client_receive_message_raw(
1703 sd_event_source *s,
1704 int fd,
1705 uint32_t revents,
1706 void *userdata) {
1707
1708 sd_dhcp_client *client = userdata;
1709 _cleanup_free_ DHCPPacket *packet = NULL;
1710 uint8_t cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
1711 struct iovec iov = {};
1712 struct msghdr msg = {
1713 .msg_iov = &iov,
1714 .msg_iovlen = 1,
1715 .msg_control = cmsgbuf,
1716 .msg_controllen = sizeof(cmsgbuf),
1717 };
1718 struct cmsghdr *cmsg;
1719 bool checksum = true;
1720 ssize_t buflen, len;
1721 int r;
1722
1723 assert(s);
1724 assert(client);
1725
1726 buflen = next_datagram_size_fd(fd);
1727 if (buflen < 0)
1728 return buflen;
1729
1730 packet = malloc0(buflen);
1731 if (!packet)
1732 return -ENOMEM;
1733
1734 iov.iov_base = packet;
1735 iov.iov_len = buflen;
1736
1737 len = recvmsg(fd, &msg, 0);
1738 if (len < 0) {
1739 if (errno == EAGAIN || errno == EINTR)
1740 return 0;
1741
1742 log_dhcp_client(client, "Could not receive message from raw socket: %m");
1743
1744 return -errno;
1745 } else if ((size_t)len < sizeof(DHCPPacket))
1746 return 0;
1747
1748 CMSG_FOREACH(cmsg, &msg) {
1749 if (cmsg->cmsg_level == SOL_PACKET &&
1750 cmsg->cmsg_type == PACKET_AUXDATA &&
1751 cmsg->cmsg_len == CMSG_LEN(sizeof(struct tpacket_auxdata))) {
1752 struct tpacket_auxdata *aux = (struct tpacket_auxdata*)CMSG_DATA(cmsg);
1753
1754 checksum = !(aux->tp_status & TP_STATUS_CSUMNOTREADY);
1755 break;
1756 }
1757 }
1758
1759 r = dhcp_packet_verify_headers(packet, len, checksum, client->port);
1760 if (r < 0)
1761 return 0;
1762
1763 len -= DHCP_IP_UDP_SIZE;
1764
1765 return client_handle_message(client, &packet->dhcp, len);
1766 }
1767
1768 int sd_dhcp_client_start(sd_dhcp_client *client) {
1769 int r;
1770
1771 assert_return(client, -EINVAL);
1772
1773 r = client_initialize(client);
1774 if (r < 0)
1775 return r;
1776
1777 if (client->last_addr)
1778 client->state = DHCP_STATE_INIT_REBOOT;
1779
1780 r = client_start(client);
1781 if (r >= 0)
1782 log_dhcp_client(client, "STARTED on ifindex %i", client->ifindex);
1783
1784 return r;
1785 }
1786
1787 int sd_dhcp_client_stop(sd_dhcp_client *client) {
1788 DHCP_CLIENT_DONT_DESTROY(client);
1789
1790 assert_return(client, -EINVAL);
1791
1792 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
1793 client->state = DHCP_STATE_STOPPED;
1794
1795 return 0;
1796 }
1797
1798 int sd_dhcp_client_attach_event(sd_dhcp_client *client, sd_event *event, int64_t priority) {
1799 int r;
1800
1801 assert_return(client, -EINVAL);
1802 assert_return(!client->event, -EBUSY);
1803
1804 if (event)
1805 client->event = sd_event_ref(event);
1806 else {
1807 r = sd_event_default(&client->event);
1808 if (r < 0)
1809 return 0;
1810 }
1811
1812 client->event_priority = priority;
1813
1814 return 0;
1815 }
1816
1817 int sd_dhcp_client_detach_event(sd_dhcp_client *client) {
1818 assert_return(client, -EINVAL);
1819
1820 client->event = sd_event_unref(client->event);
1821
1822 return 0;
1823 }
1824
1825 sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) {
1826 assert_return(client, NULL);
1827
1828 return client->event;
1829 }
1830
1831 sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client) {
1832
1833 if (!client)
1834 return NULL;
1835
1836 assert(client->n_ref >= 1);
1837 client->n_ref++;
1838
1839 return client;
1840 }
1841
1842 sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) {
1843
1844 if (!client)
1845 return NULL;
1846
1847 assert(client->n_ref >= 1);
1848 client->n_ref--;
1849
1850 if (client->n_ref > 0)
1851 return NULL;
1852
1853 log_dhcp_client(client, "FREE");
1854
1855 client_initialize(client);
1856
1857 client->receive_message = sd_event_source_unref(client->receive_message);
1858
1859 sd_dhcp_client_detach_event(client);
1860
1861 sd_dhcp_lease_unref(client->lease);
1862
1863 free(client->req_opts);
1864 free(client->hostname);
1865 free(client->vendor_class_identifier);
1866 return mfree(client);
1867 }
1868
1869 int sd_dhcp_client_new(sd_dhcp_client **ret) {
1870 _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL;
1871
1872 assert_return(ret, -EINVAL);
1873
1874 client = new0(sd_dhcp_client, 1);
1875 if (!client)
1876 return -ENOMEM;
1877
1878 client->n_ref = 1;
1879 client->state = DHCP_STATE_INIT;
1880 client->ifindex = -1;
1881 client->fd = -1;
1882 client->attempt = 1;
1883 client->mtu = DHCP_DEFAULT_MIN_SIZE;
1884 client->port = DHCP_PORT_CLIENT;
1885
1886 client->req_opts_size = ELEMENTSOF(default_req_opts);
1887 client->req_opts = memdup(default_req_opts, client->req_opts_size);
1888 if (!client->req_opts)
1889 return -ENOMEM;
1890
1891 *ret = client;
1892 client = NULL;
1893
1894 return 0;
1895 }
Unnamed repository; edit this file 'description' to name the repository.