]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/libsystemd-network/sd-dhcp-client.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tree-wide: define iterator inside of the macro
[thirdparty/systemd.git] / src / libsystemd-network / sd-dhcp-client.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
011feef8 2/***
810adae9 3 Copyright © 2013 Intel Corporation. All rights reserved.
011feef8
PF		 4***/
5
011feef8 6#include <errno.h>
46a66b79 7#include <net/ethernet.h>
3b7ca119 8#include <net/if_arp.h>
07630cea
LP		 9#include <stdio.h>
10#include <stdlib.h>
5266a81e 11#include <sys/ioctl.h>
07630cea 12#include <linux/if_infiniband.h>
011feef8 13
07630cea 14#include "sd-dhcp-client.h"
011feef8 15
b5efdb8a 16#include "alloc-util.h"
07630cea
LP		 17#include "async.h"
18#include "dhcp-identifier.h"
46a66b79 19#include "dhcp-internal.h"
fe8db0c5 20#include "dhcp-lease-internal.h"
07630cea 21#include "dhcp-protocol.h"
23873e25 22#include "dns-domain.h"
a3fa4287 23#include "event-util.h"
23873e25 24#include "hostname-util.h"
cb310866 25#include "io-util.h"
0a970718 26#include "memory-util.h"
07630cea
LP		 27#include "random-util.h"
28#include "string-util.h"
af1c0de0 29#include "strv.h"
7be32612 30#include "utf8.h"
d11d4a64 31#include "web-util.h"
011feef8 32
5bac5235 33#define MAX_CLIENT_ID_LEN (sizeof(uint32_t) + MAX_DUID_LEN) /* Arbitrary limit */
dd168445 34#define MAX_MAC_ADDR_LEN CONST_MAX(INFINIBAND_ALEN, ETH_ALEN)
76253e73 35
1d1a3e0a
BG		 36#define RESTART_AFTER_NAK_MIN_USEC (1 * USEC_PER_SEC)
37#define RESTART_AFTER_NAK_MAX_USEC (30 * USEC_PER_MINUTE)
38
00ebe011
MAL		 39typedef struct sd_dhcp_client_id {
40 uint8_t type;
41 union {
42 struct {
43 /* 0: Generic (non-LL) (RFC 2132) */
44 uint8_t data[MAX_CLIENT_ID_LEN];
45 } _packed_ gen;
46 struct {
47 /* 1: Ethernet Link-Layer (RFC 2132) */
48 uint8_t haddr[ETH_ALEN];
49 } _packed_ eth;
50 struct {
51 /* 2 - 254: ARP/Link-Layer (RFC 2132) */
52 uint8_t haddr[0];
53 } _packed_ ll;
54 struct {
55 /* 255: Node-specific (RFC 4361) */
56 be32_t iaid;
57 struct duid duid;
58 } _packed_ ns;
59 struct {
60 uint8_t data[MAX_CLIENT_ID_LEN];
61 } _packed_ raw;
62 };
63} _packed_ sd_dhcp_client_id;
64
011feef8 65struct sd_dhcp_client {
3733eec3 66 unsigned n_ref;
e5b04c8d 67
011feef8 68 DHCPState state;
d3d8ac2f 69 sd_event *event;
b25ef18b 70 int event_priority;
d3d8ac2f 71 sd_event_source *timeout_resend;
2f8e7633 72 int ifindex;
8c00042c 73 int fd;
9faed222 74 uint16_t port;
8c00042c
PF		 75 union sockaddr_union link;
76 sd_event_source *receive_message;
f5de5b00 77 bool request_broadcast;
011feef8 78 uint8_t *req_opts;
7a7c74ca 79 size_t req_opts_allocated;
011feef8 80 size_t req_opts_size;
db3d2358 81 bool anonymize;
3b349af6 82 be32_t last_addr;
76253e73
DW		 83 uint8_t mac_addr[MAX_MAC_ADDR_LEN];
84 size_t mac_addr_len;
85 uint16_t arp_type;
00ebe011 86 sd_dhcp_client_id client_id;
ba6c0fd6 87 size_t client_id_len;
4cc7a82c 88 char *hostname;
edb85f0d 89 char *vendor_class_identifier;
d11d4a64 90 char *mudurl;
af1c0de0 91 char **user_class;
324f8187 92 uint32_t mtu;
4c0b8d56 93 uint32_t fallback_lease_lifetime;
46a66b79 94 uint32_t xid;
d3d8ac2f 95 usec_t start_time;
715cedfb
SS		 96 uint64_t attempt;
97 uint64_t max_attempts;
7354900d
DW		 98 OrderedHashmap *extra_options;
99 OrderedHashmap *vendor_options;
51debc1e
PF		 100 usec_t request_sent;
101 sd_event_source *timeout_t1;
102 sd_event_source *timeout_t2;
103 sd_event_source *timeout_expire;
45aa74c7 104 sd_dhcp_client_callback_t callback;
751246ee 105 void *userdata;
a6cc569e 106 sd_dhcp_lease *lease;
1d1a3e0a 107 usec_t start_delay;
afe42aef 108 int ip_service_type;
011feef8
PF		 109};
110
111static const uint8_t default_req_opts[] = {
22805d92
BG		 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,
011feef8
PF		 117};
118
db3d2358 119/* RFC7844 section 3:
120 MAY contain the Parameter Request List option.
121 RFC7844 section 3.6:
122 The client intending to protect its privacy SHOULD only request a
123 minimal number of options in the PRL and SHOULD also randomly shuffle
124 the ordering of option codes in the PRL. If this random ordering
125 cannot be implemented, the client MAY order the option codes in the
126 PRL by option code number (lowest to highest).
127*/
128/* NOTE: using PRL options that Windows 10 RFC7844 implementation uses */
129static const uint8_t default_req_opts_anonymize[] = {
75924885
YW		 130 SD_DHCP_OPTION_SUBNET_MASK, /* 1 */
131 SD_DHCP_OPTION_ROUTER, /* 3 */
132 SD_DHCP_OPTION_DOMAIN_NAME_SERVER, /* 6 */
133 SD_DHCP_OPTION_DOMAIN_NAME, /* 15 */
134 SD_DHCP_OPTION_ROUTER_DISCOVER, /* 31 */
135 SD_DHCP_OPTION_STATIC_ROUTE, /* 33 */
136 SD_DHCP_OPTION_VENDOR_SPECIFIC, /* 43 */
137 SD_DHCP_OPTION_NETBIOS_NAMESERVER, /* 44 */
138 SD_DHCP_OPTION_NETBIOS_NODETYPE, /* 46 */
139 SD_DHCP_OPTION_NETBIOS_SCOPE, /* 47 */
140 SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE, /* 121 */
141 SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE, /* 249 */
142 SD_DHCP_OPTION_PRIVATE_PROXY_AUTODISCOVERY, /* 252 */
db3d2358 143};
144
4b558378
ZJS		 145static int client_receive_message_raw(
146 sd_event_source *s,
147 int fd,
148 uint32_t revents,
149 void *userdata);
150static int client_receive_message_udp(
151 sd_event_source *s,
152 int fd,
153 uint32_t revents,
154 void *userdata);
574cc928 155static void client_stop(sd_dhcp_client *client, int error);
aba26854 156
7be32612
MAL		 157int sd_dhcp_client_id_to_string(const void *data, size_t len, char **ret) {
158 const sd_dhcp_client_id *client_id = data;
159 _cleanup_free_ char *t = NULL;
160 int r = 0;
161
162 assert_return(data, -EINVAL);
163 assert_return(len >= 1, -EINVAL);
164 assert_return(ret, -EINVAL);
165
166 len -= 1;
167 if (len > MAX_CLIENT_ID_LEN)
168 return -EINVAL;
169
170 switch (client_id->type) {
171 case 0:
172 if (utf8_is_printable((char *) client_id->gen.data, len))
173 r = asprintf(&t, "%.*s", (int) len, client_id->gen.data);
174 else
175 r = asprintf(&t, "DATA");
176 break;
177 case 1:
178 if (len != sizeof_field(sd_dhcp_client_id, eth))
179 return -EINVAL;
180
181 r = asprintf(&t, "%x:%x:%x:%x:%x:%x",
182 client_id->eth.haddr[0],
183 client_id->eth.haddr[1],
184 client_id->eth.haddr[2],
185 client_id->eth.haddr[3],
186 client_id->eth.haddr[4],
187 client_id->eth.haddr[5]);
188 break;
189 case 2 ... 254:
190 r = asprintf(&t, "ARP/LL");
191 break;
192 case 255:
193 if (len < 6)
194 return -EINVAL;
195
196 uint32_t iaid = be32toh(client_id->ns.iaid);
197 uint16_t duid_type = be16toh(client_id->ns.duid.type);
198 if (dhcp_validate_duid_len(duid_type, len - 6, true) < 0)
199 return -EINVAL;
200
201 r = asprintf(&t, "IAID:0x%x/DUID", iaid);
202 break;
203 }
204
205 if (r < 0)
206 return -ENOMEM;
207 *ret = TAKE_PTR(t);
208 return 0;
209}
210
4b558378
ZJS		 211int sd_dhcp_client_set_callback(
212 sd_dhcp_client *client,
213 sd_dhcp_client_callback_t cb,
214 void *userdata) {
45aa74c7 215
751246ee
PF		 216 assert_return(client, -EINVAL);
217
45aa74c7 218 client->callback = cb;
751246ee
PF		 219 client->userdata = userdata;
220
221 return 0;
222}
223
f5de5b00
TG		 224int sd_dhcp_client_set_request_broadcast(sd_dhcp_client *client, int broadcast) {
225 assert_return(client, -EINVAL);
226
227 client->request_broadcast = !!broadcast;
228
229 return 0;
230}
231
5ee482df 232int sd_dhcp_client_set_request_option(sd_dhcp_client *client, uint8_t option) {
011feef8
PF		 233 size_t i;
234
235 assert_return(client, -EINVAL);
a1140666 236 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY);
011feef8
PF		 237
238 switch(option) {
a1140666 239
22805d92
BG		 240 case SD_DHCP_OPTION_PAD:
241 case SD_DHCP_OPTION_OVERLOAD:
242 case SD_DHCP_OPTION_MESSAGE_TYPE:
243 case SD_DHCP_OPTION_PARAMETER_REQUEST_LIST:
244 case SD_DHCP_OPTION_END:
011feef8
PF		 245 return -EINVAL;
246
247 default:
248 break;
249 }
250
251 for (i = 0; i < client->req_opts_size; i++)
252 if (client->req_opts[i] == option)
253 return -EEXIST;
254
7a7c74ca 255 if (!GREEDY_REALLOC(client->req_opts, client->req_opts_allocated,
011feef8
PF		 256 client->req_opts_size + 1))
257 return -ENOMEM;
258
7a7c74ca 259 client->req_opts[client->req_opts_size++] = option;
011feef8
PF		 260
261 return 0;
262}
263
4b558378
ZJS		 264int sd_dhcp_client_set_request_address(
265 sd_dhcp_client *client,
266 const struct in_addr *last_addr) {
a1140666 267
011feef8 268 assert_return(client, -EINVAL);
a1140666 269 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY);
011feef8
PF		 270
271 if (last_addr)
272 client->last_addr = last_addr->s_addr;
273 else
274 client->last_addr = INADDR_ANY;
275
276 return 0;
277}
278
2f8e7633 279int sd_dhcp_client_set_ifindex(sd_dhcp_client *client, int ifindex) {
011feef8 280
2f8e7633
LP		 281 assert_return(client, -EINVAL);
282 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED), -EBUSY);
283 assert_return(ifindex > 0, -EINVAL);
011feef8 284
2f8e7633 285 client->ifindex = ifindex;
011feef8
PF		 286 return 0;
287}
288
4b558378
ZJS		 289int sd_dhcp_client_set_mac(
290 sd_dhcp_client *client,
291 const uint8_t *addr,
292 size_t addr_len,
293 uint16_t arp_type) {
294
574cc928 295 DHCP_CLIENT_DONT_DESTROY(client);
4644fee0 296 bool need_restart = false;
944e23b8 297 int r;
4644fee0 298
46a66b79 299 assert_return(client, -EINVAL);
4644fee0 300 assert_return(addr, -EINVAL);
76253e73
DW		 301 assert_return(addr_len > 0 && addr_len <= MAX_MAC_ADDR_LEN, -EINVAL);
302 assert_return(arp_type > 0, -EINVAL);
303
304 if (arp_type == ARPHRD_ETHER)
305 assert_return(addr_len == ETH_ALEN, -EINVAL);
306 else if (arp_type == ARPHRD_INFINIBAND)
307 assert_return(addr_len == INFINIBAND_ALEN, -EINVAL);
308 else
309 return -EINVAL;
46a66b79 310
76253e73
DW		 311 if (client->mac_addr_len == addr_len &&
312 memcmp(&client->mac_addr, addr, addr_len) == 0)
4644fee0
TG		 313 return 0;
314
781ca7a1 315 if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
a1140666 316 log_dhcp_client(client, "Changing MAC address on running DHCP client, restarting");
4644fee0 317 need_restart = true;
03748142 318 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
4644fee0 319 }
02ec5cd7 320
76253e73
DW		 321 memcpy(&client->mac_addr, addr, addr_len);
322 client->mac_addr_len = addr_len;
323 client->arp_type = arp_type;
324
944e23b8
YW		 325 if (need_restart && client->state != DHCP_STATE_STOPPED) {
326 r = sd_dhcp_client_start(client);
327 if (r < 0)
328 return log_dhcp_client_errno(client, r, "Failed to restart DHCPv4 client: %m");
329 }
ba6c0fd6
DW		 330
331 return 0;
332}
333
4b558378
ZJS		 334int sd_dhcp_client_get_client_id(
335 sd_dhcp_client *client,
336 uint8_t *type,
337 const uint8_t **data,
338 size_t *data_len) {
ba6c0fd6
DW		 339
340 assert_return(client, -EINVAL);
341 assert_return(type, -EINVAL);
342 assert_return(data, -EINVAL);
343 assert_return(data_len, -EINVAL);
344
345 *type = 0;
346 *data = NULL;
347 *data_len = 0;
348 if (client->client_id_len) {
5bac5235 349 *type = client->client_id.type;
ba6c0fd6 350 *data = client->client_id.raw.data;
5bac5235 351 *data_len = client->client_id_len - sizeof(client->client_id.type);
ba6c0fd6
DW		 352 }
353
354 return 0;
355}
356
4b558378
ZJS		 357int sd_dhcp_client_set_client_id(
358 sd_dhcp_client *client,
359 uint8_t type,
360 const uint8_t *data,
361 size_t data_len) {
362
ba6c0fd6
DW		 363 DHCP_CLIENT_DONT_DESTROY(client);
364 bool need_restart = false;
944e23b8 365 int r;
ba6c0fd6
DW		 366
367 assert_return(client, -EINVAL);
368 assert_return(data, -EINVAL);
369 assert_return(data_len > 0 && data_len <= MAX_CLIENT_ID_LEN, -EINVAL);
370
5bac5235
TG		 371 if (client->client_id_len == data_len + sizeof(client->client_id.type) &&
372 client->client_id.type == type &&
ba6c0fd6
DW		 373 memcmp(&client->client_id.raw.data, data, data_len) == 0)
374 return 0;
375
bfda0d0f
TH		 376 /* For hardware types, log debug message about unexpected data length.
377 *
378 * Note that infiniband's INFINIBAND_ALEN is 20 bytes long, but only
d7b34e38 379 * the last 8 bytes of the address are stable and suitable to put into
bfda0d0f
TH		 380 * the client-id. The caller is advised to account for that. */
381 if ((type == ARPHRD_ETHER && data_len != ETH_ALEN) ||
382 (type == ARPHRD_INFINIBAND && data_len != 8))
383 log_dhcp_client(client, "Changing client ID to hardware type %u with "
384 "unexpected address length %zu",
385 type, data_len);
386
ba6c0fd6
DW		 387 if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
388 log_dhcp_client(client, "Changing client ID on running DHCP "
389 "client, restarting");
390 need_restart = true;
03748142 391 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
ba6c0fd6
DW		 392 }
393
5bac5235 394 client->client_id.type = type;
ba6c0fd6 395 memcpy(&client->client_id.raw.data, data, data_len);
5bac5235 396 client->client_id_len = data_len + sizeof (client->client_id.type);
46a66b79 397
944e23b8
YW		 398 if (need_restart && client->state != DHCP_STATE_STOPPED) {
399 r = sd_dhcp_client_start(client);
400 if (r < 0)
401 return log_dhcp_client_errno(client, r, "Failed to restart DHCPv4 client: %m");
402 }
4644fee0 403
46a66b79
PF		 404 return 0;
405}
406
d7df2fd3
ZJS		 407/**
408 * Sets IAID and DUID. If duid is non-null, the DUID is set to duid_type + duid
409 * without further modification. Otherwise, if duid_type is supported, DUID
410 * is set based on that type. Otherwise, an error is returned.
411 */
7e90a499 412static int dhcp_client_set_iaid_duid_internal(
4b558378 413 sd_dhcp_client *client,
8217ed5e
TH		 414 bool iaid_append,
415 bool iaid_set,
4b558378
ZJS		 416 uint32_t iaid,
417 uint16_t duid_type,
f7a92d1a 418 const void *duid,
7e90a499
YW		 419 size_t duid_len,
420 usec_t llt_time) {
4b558378 421
413708d1
VK		 422 DHCP_CLIENT_DONT_DESTROY(client);
423 int r;
d7df2fd3
ZJS		 424 size_t len;
425
413708d1 426 assert_return(client, -EINVAL);
da3c49e9 427 assert_return(duid_len == 0 || duid, -EINVAL);
d7df2fd3 428
da3c49e9 429 if (duid) {
ab4a88bc 430 r = dhcp_validate_duid_len(duid_type, duid_len, true);
d7df2fd3 431 if (r < 0)
f515c345 432 return log_dhcp_client_errno(client, r, "Failed to validate length of DUID: %m");
d7df2fd3 433 }
413708d1 434
d7df2fd3 435 zero(client->client_id);
413708d1
VK		 436 client->client_id.type = 255;
437
8217ed5e
TH		 438 if (iaid_append) {
439 if (iaid_set)
440 client->client_id.ns.iaid = htobe32(iaid);
441 else {
dace710c
YW		 442 r = dhcp_identifier_set_iaid(client->ifindex, client->mac_addr,
443 client->mac_addr_len,
6d13616b 444 true,
dace710c
YW		 445 &client->client_id.ns.iaid);
446 if (r < 0)
f515c345 447 return log_dhcp_client_errno(client, r, "Failed to set IAID: %m");
8217ed5e 448 }
dace710c 449 }
413708d1 450
da3c49e9 451 if (duid) {
413708d1
VK		 452 client->client_id.ns.duid.type = htobe16(duid_type);
453 memcpy(&client->client_id.ns.duid.raw.data, duid, duid_len);
d7df2fd3 454 len = sizeof(client->client_id.ns.duid.type) + duid_len;
d7df2fd3 455 } else
27eba50e 456 switch (duid_type) {
335f80a6 457 case DUID_TYPE_LLT:
339697f0 458 if (client->mac_addr_len == 0)
f515c345 459 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EOPNOTSUPP), "Failed to set DUID-LLT, MAC address is not set.");
335f80a6 460
7e90a499 461 r = dhcp_identifier_set_duid_llt(&client->client_id.ns.duid, llt_time, client->mac_addr, client->mac_addr_len, client->arp_type, &len);
335f80a6 462 if (r < 0)
f515c345 463 return log_dhcp_client_errno(client, r, "Failed to set DUID-LLT: %m");
335f80a6 464 break;
27eba50e
YW		 465 case DUID_TYPE_EN:
466 r = dhcp_identifier_set_duid_en(&client->client_id.ns.duid, &len);
467 if (r < 0)
f515c345 468 return log_dhcp_client_errno(client, r, "Failed to set DUID-EN: %m");
27eba50e 469 break;
335f80a6 470 case DUID_TYPE_LL:
339697f0 471 if (client->mac_addr_len == 0)
f515c345 472 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EOPNOTSUPP), "Failed to set DUID-LL, MAC address is not set.");
335f80a6
YW		 473
474 r = dhcp_identifier_set_duid_ll(&client->client_id.ns.duid, client->mac_addr, client->mac_addr_len, client->arp_type, &len);
475 if (r < 0)
f515c345 476 return log_dhcp_client_errno(client, r, "Failed to set DUID-LL: %m");
335f80a6 477 break;
27eba50e
YW		 478 case DUID_TYPE_UUID:
479 r = dhcp_identifier_set_duid_uuid(&client->client_id.ns.duid, &len);
480 if (r < 0)
f515c345 481 return log_dhcp_client_errno(client, r, "Failed to set DUID-UUID: %m");
27eba50e
YW		 482 break;
483 default:
f515c345 484 return log_dhcp_client_errno(client, SYNTHETIC_ERRNO(EINVAL), "Invalid DUID type");
27eba50e 485 }
413708d1 486
d7df2fd3 487 client->client_id_len = sizeof(client->client_id.type) + len +
8217ed5e 488 (iaid_append ? sizeof(client->client_id.ns.iaid) : 0);
413708d1
VK		 489
490 if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) {
8217ed5e 491 log_dhcp_client(client, "Configured %sDUID, restarting.", iaid_append ? "IAID+" : "");
413708d1 492 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
944e23b8
YW		 493 r = sd_dhcp_client_start(client);
494 if (r < 0)
495 return log_dhcp_client_errno(client, r, "Failed to restart DHCPv4 client: %m");
413708d1
VK		 496 }
497
498 return 0;
499}
500
dace710c
YW		 501int sd_dhcp_client_set_iaid_duid(
502 sd_dhcp_client *client,
8217ed5e 503 bool iaid_set,
dace710c
YW		 504 uint32_t iaid,
505 uint16_t duid_type,
506 const void *duid,
507 size_t duid_len) {
8217ed5e 508 return dhcp_client_set_iaid_duid_internal(client, true, iaid_set, iaid, duid_type, duid, duid_len, 0);
7e90a499
YW		 509}
510
511int sd_dhcp_client_set_iaid_duid_llt(
512 sd_dhcp_client *client,
8217ed5e 513 bool iaid_set,
7e90a499
YW		 514 uint32_t iaid,
515 usec_t llt_time) {
8217ed5e 516 return dhcp_client_set_iaid_duid_internal(client, true, iaid_set, iaid, DUID_TYPE_LLT, NULL, 0, llt_time);
dace710c
YW		 517}
518
519int sd_dhcp_client_set_duid(
520 sd_dhcp_client *client,
521 uint16_t duid_type,
522 const void *duid,
523 size_t duid_len) {
8217ed5e 524 return dhcp_client_set_iaid_duid_internal(client, false, false, 0, duid_type, duid, duid_len, 0);
7e90a499
YW		 525}
526
527int sd_dhcp_client_set_duid_llt(
528 sd_dhcp_client *client,
529 usec_t llt_time) {
8217ed5e 530 return dhcp_client_set_iaid_duid_internal(client, false, false, 0, DUID_TYPE_LLT, NULL, 0, llt_time);
dace710c
YW		 531}
532
4b558378
ZJS		 533int sd_dhcp_client_set_hostname(
534 sd_dhcp_client *client,
535 const char *hostname) {
536
4cc7a82c
EY		 537 assert_return(client, -EINVAL);
538
9740eae6 539 /* Make sure hostnames qualify as DNS and as Linux hostnames */
ef8b0084 540 if (hostname &&
9740eae6 541 !(hostname_is_valid(hostname, false) && dns_name_is_valid(hostname) > 0))
23873e25
BG		 542 return -EINVAL;
543
ef8b0084 544 return free_and_strdup(&client->hostname, hostname);
4cc7a82c
EY		 545}
546
4b558378
ZJS		 547int sd_dhcp_client_set_vendor_class_identifier(
548 sd_dhcp_client *client,
549 const char *vci) {
550
edb85f0d
SS		 551 assert_return(client, -EINVAL);
552
ef8b0084 553 return free_and_strdup(&client->vendor_class_identifier, vci);
edb85f0d
SS		 554}
555
d11d4a64
SS		 556int sd_dhcp_client_set_mud_url(
557 sd_dhcp_client *client,
558 const char *mudurl) {
559
560 assert_return(client, -EINVAL);
561 assert_return(mudurl, -EINVAL);
562 assert_return(strlen(mudurl) <= 255, -EINVAL);
563 assert_return(http_url_is_valid(mudurl), -EINVAL);
564
565 return free_and_strdup(&client->mudurl, mudurl);
566}
567
af1c0de0
SS		 568int sd_dhcp_client_set_user_class(
569 sd_dhcp_client *client,
570 const char* const* user_class) {
571
572 _cleanup_strv_free_ char **s = NULL;
573 char **p;
574
575 STRV_FOREACH(p, (char **) user_class)
576 if (strlen(*p) > 255)
577 return -ENAMETOOLONG;
578
579 s = strv_copy((char **) user_class);
580 if (!s)
581 return -ENOMEM;
582
583 client->user_class = TAKE_PTR(s);
584
585 return 0;
586}
587
9faed222
SS		 588int sd_dhcp_client_set_client_port(
589 sd_dhcp_client *client,
590 uint16_t port) {
591
592 assert_return(client, -EINVAL);
593
594 client->port = port;
595
596 return 0;
597}
598
324f8187
TG		 599int sd_dhcp_client_set_mtu(sd_dhcp_client *client, uint32_t mtu) {
600 assert_return(client, -EINVAL);
601 assert_return(mtu >= DHCP_DEFAULT_MIN_SIZE, -ERANGE);
602
603 client->mtu = mtu;
604
605 return 0;
606}
607
715cedfb
SS		 608int sd_dhcp_client_set_max_attempts(sd_dhcp_client *client, uint64_t max_attempts) {
609 assert_return(client, -EINVAL);
610
611 client->max_attempts = max_attempts;
612
613 return 0;
614}
615
7354900d 616int sd_dhcp_client_add_option(sd_dhcp_client *client, sd_dhcp_option *v) {
cb29c156
SS		 617 int r;
618
619 assert_return(client, -EINVAL);
620 assert_return(v, -EINVAL);
621
7354900d 622 r = ordered_hashmap_ensure_allocated(&client->extra_options, &dhcp_option_hash_ops);
cb29c156
SS		 623 if (r < 0)
624 return r;
625
7354900d 626 r = ordered_hashmap_put(client->extra_options, UINT_TO_PTR(v->option), v);
cb29c156
SS		 627 if (r < 0)
628 return r;
629
630 sd_dhcp_option_ref(v);
631 return 0;
632}
633
7354900d
DW		 634int sd_dhcp_client_add_vendor_option(sd_dhcp_client *client, sd_dhcp_option *v) {
635 int r;
636
637 assert_return(client, -EINVAL);
638 assert_return(v, -EINVAL);
639
640 r = ordered_hashmap_ensure_allocated(&client->vendor_options, &dhcp_option_hash_ops);
641 if (r < 0)
642 return -ENOMEM;
643
644 r = ordered_hashmap_put(client->vendor_options, v, v);
645 if (r < 0)
646 return r;
647
648 sd_dhcp_option_ref(v);
649
650 return 1;
651}
652
a6cc569e 653int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) {
751246ee 654 assert_return(client, -EINVAL);
751246ee 655
727b5734 656 if (!IN_SET(client->state, DHCP_STATE_SELECTING, DHCP_STATE_BOUND, DHCP_STATE_RENEWING, DHCP_STATE_REBINDING))
a6cc569e 657 return -EADDRNOTAVAIL;
751246ee 658
a1140666
LP		 659 if (ret)
660 *ret = client->lease;
4f882b2a
TG		 661
662 return 0;
663}
664
afe42aef
SC		 665int sd_dhcp_client_set_service_type(sd_dhcp_client *client, int type) {
666 assert_return(client, -EINVAL);
667
668 client->ip_service_type = type;
669
670 return 0;
671}
672
4c0b8d56
SS		 673int sd_dhcp_client_set_fallback_lease_lifetime(sd_dhcp_client *client, uint32_t fallback_lease_lifetime) {
674 assert_return(client, -EINVAL);
675 assert_return(fallback_lease_lifetime > 0, -EINVAL);
676
677 client->fallback_lease_lifetime = fallback_lease_lifetime;
678
679 return 0;
680}
681
727b5734 682static int client_notify(sd_dhcp_client *client, int event) {
45aa74c7
LP		 683 assert(client);
684
685 if (client->callback)
727b5734
SS		 686 return client->callback(client, event, client->userdata);
687
688 return 0;
3e3d8f78
PF		 689}
690
0f941add 691static int client_initialize(sd_dhcp_client *client) {
bbdf06d9 692 assert_return(client, -EINVAL);
bbdf06d9 693
a1140666 694 client->receive_message = sd_event_source_unref(client->receive_message);
8c00042c 695
22fc2420 696 client->fd = asynchronous_close(client->fd);
8c00042c 697
a3fa4287
YW		 698 (void) event_source_disable(client->timeout_resend);
699 (void) event_source_disable(client->timeout_t1);
700 (void) event_source_disable(client->timeout_t2);
701 (void) event_source_disable(client->timeout_expire);
51debc1e 702
11793fcd 703 client->attempt = 0;
e2dfc79f 704
f8fdefe4 705 client->state = DHCP_STATE_INIT;
0f941add 706 client->xid = 0;
bbdf06d9 707
0339cd77 708 client->lease = sd_dhcp_lease_unref(client->lease);
8c00042c 709
0f941add
PF		 710 return 0;
711}
712
574cc928
TG		 713static void client_stop(sd_dhcp_client *client, int error) {
714 assert(client);
0f941add 715
ccfdc9a1 716 if (error < 0)
7fa6223f 717 log_dhcp_client_errno(client, error, "STOPPED: %m");
03748142 718 else if (error == SD_DHCP_CLIENT_EVENT_STOP)
2d2349cc
TG		 719 log_dhcp_client(client, "STOPPED");
720 else
721 log_dhcp_client(client, "STOPPED: Unknown event");
0f941add 722
574cc928 723 client_notify(client, error);
ee57a737 724
574cc928 725 client_initialize(client);
bbdf06d9
PF		 726}
727
4b558378
ZJS		 728static int client_message_init(
729 sd_dhcp_client *client,
730 DHCPPacket **ret,
731 uint8_t type,
732 size_t *_optlen,
733 size_t *_optoffset) {
734
3587161a 735 _cleanup_free_ DHCPPacket *packet = NULL;
424a8732 736 size_t optlen, optoffset, size;
8a9e7616 737 be16_t max_size;
d8d74ef0
DW		 738 usec_t time_now;
739 uint16_t secs;
cf597f65 740 int r;
46a66b79 741
6236f49b 742 assert(client);
d8d74ef0 743 assert(client->start_time);
424a8732
TG		 744 assert(ret);
745 assert(_optlen);
746 assert(_optoffset);
0f3ff4ea 747 assert(IN_SET(type, DHCP_DISCOVER, DHCP_REQUEST, DHCP_RELEASE, DHCP_DECLINE));
0a1b6da8 748
424a8732
TG		 749 optlen = DHCP_MIN_OPTIONS_SIZE;
750 size = sizeof(DHCPPacket) + optlen;
751
752 packet = malloc0(size);
753 if (!packet)
754 return -ENOMEM;
755
756 r = dhcp_message_init(&packet->dhcp, BOOTREQUEST, client->xid, type,
76253e73 757 client->arp_type, optlen, &optoffset);
cf597f65
TG		 758 if (r < 0)
759 return r;
46a66b79 760
0a1b6da8
TG		 761 /* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers
762 refuse to issue an DHCP lease if 'secs' is set to zero */
d8d74ef0
DW		 763 r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
764 if (r < 0)
765 return r;
766 assert(time_now >= client->start_time);
767
768 /* seconds between sending first and last DISCOVER
769 * must always be strictly positive to deal with broken servers */
770 secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1;
771 packet->dhcp.secs = htobe16(secs);
0a1b6da8 772
63a07041
CA		 773 /* RFC2132 section 4.1
774 A client that cannot receive unicast IP datagrams until its protocol
775 software has been configured with an IP address SHOULD set the
776 BROADCAST bit in the 'flags' field to 1 in any DHCPDISCOVER or
777 DHCPREQUEST messages that client sends. The BROADCAST bit will
778 provide a hint to the DHCP server and BOOTP relay agent to broadcast
f5de5b00
TG		 779 any messages to the client on the client's subnet.
780
781 Note: some interfaces needs this to be enabled, but some networks
782 needs this to be disabled as broadcasts are filteretd, so this
783 needs to be configurable */
76253e73 784 if (client->request_broadcast || client->arp_type != ARPHRD_ETHER)
f5de5b00 785 packet->dhcp.flags = htobe16(0x8000);
63a07041 786
50d6810e
TG		 787 /* RFC2132 section 4.1.1:
788 The client MUST include its hardware address in the ’chaddr’ field, if
76253e73
DW		 789 necessary for delivery of DHCP reply messages. Non-Ethernet
790 interfaces will leave 'chaddr' empty and use the client identifier
791 instead (eg, RFC 4390 section 2.1).
50d6810e 792 */
76253e73
DW		 793 if (client->arp_type == ARPHRD_ETHER)
794 memcpy(&packet->dhcp.chaddr, &client->mac_addr, ETH_ALEN);
f5a70de7 795
afec4539 796 /* If no client identifier exists, construct an RFC 4361-compliant one */
5bac5235
TG		 797 if (client->client_id_len == 0) {
798 size_t duid_len;
799
800 client->client_id.type = 255;
801
6d13616b
TH		 802 r = dhcp_identifier_set_iaid(client->ifindex, client->mac_addr, client->mac_addr_len,
803 true, &client->client_id.ns.iaid);
5bac5235
TG		 804 if (r < 0)
805 return r;
806
807 r = dhcp_identifier_set_duid_en(&client->client_id.ns.duid, &duid_len);
808 if (r < 0)
809 return r;
810
811 client->client_id_len = sizeof(client->client_id.type) + sizeof(client->client_id.ns.iaid) + duid_len;
ba6c0fd6
DW		 812 }
813
ee57a737 814 /* Some DHCP servers will refuse to issue an DHCP lease if the Client
46a66b79 815 Identifier option is not set */
ba6c0fd6
DW		 816 if (client->client_id_len) {
817 r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0,
22805d92 818 SD_DHCP_OPTION_CLIENT_IDENTIFIER,
ba6c0fd6 819 client->client_id_len,
5bac5235 820 &client->client_id);
ba6c0fd6
DW		 821 if (r < 0)
822 return r;
823 }
50d6810e
TG		 824
825 /* RFC2131 section 3.5:
826 in its initial DHCPDISCOVER or DHCPREQUEST message, a
827 client may provide the server with a list of specific
828 parameters the client is interested in. If the client
829 includes a list of parameters in a DHCPDISCOVER message,
830 it MUST include that list in any subsequent DHCPREQUEST
831 messages.
832 */
5e77a146 833
834 /* RFC7844 section 3:
835 MAY contain the Parameter Request List option. */
836 /* NOTE: in case that there would be an option to do not send
837 * any PRL at all, the size should be checked before sending */
1501b429 838 if (client->req_opts_size > 0 && type != DHCP_RELEASE) {
5e77a146 839 r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0,
840 SD_DHCP_OPTION_PARAMETER_REQUEST_LIST,
841 client->req_opts_size, client->req_opts);
842 if (r < 0)
843 return r;
844 }
8a9e7616 845
50d6810e
TG		 846 /* RFC2131 section 3.5:
847 The client SHOULD include the ’maximum DHCP message size’ option to
848 let the server know how large the server may make its DHCP messages.
849
850 Note (from ConnMan): Some DHCP servers will send bigger DHCP packets
f21f31b2 851 than the defined default size unless the Maximum Message Size option
f131770b 852 is explicitly set
324f8187
TG		 853
854 RFC3442 "Requirements to Avoid Sizing Constraints":
855 Because a full routing table can be quite large, the standard 576
856 octet maximum size for a DHCP message may be too short to contain
857 some legitimate Classless Static Route options. Because of this,
858 clients implementing the Classless Static Route option SHOULD send a
859 Maximum DHCP Message Size [4] option if the DHCP client's TCP/IP
860 stack is capable of receiving larger IP datagrams. In this case, the
861 client SHOULD set the value of this option to at least the MTU of the
862 interface that the client is configuring. The client MAY set the
863 value of this option higher, up to the size of the largest UDP packet
864 it is prepared to accept. (Note that the value specified in the
865 Maximum DHCP Message Size option is the total maximum packet size,
866 including IP and UDP headers.)
50d6810e 867 */
1b41b815 868 /* RFC7844 section 3:
869 SHOULD NOT contain any other option. */
1501b429 870 if (!client->anonymize && type != DHCP_RELEASE) {
1b41b815 871 max_size = htobe16(size);
872 r = dhcp_option_append(&packet->dhcp, client->mtu, &optoffset, 0,
873 SD_DHCP_OPTION_MAXIMUM_MESSAGE_SIZE,
874 2, &max_size);
875 if (r < 0)
876 return r;
877 }
46a66b79 878
424a8732
TG		 879 *_optlen = optlen;
880 *_optoffset = optoffset;
1cc6c93a 881 *ret = TAKE_PTR(packet);
424a8732 882
46a66b79
PF		 883 return 0;
884}
885
4b558378
ZJS		 886static int client_append_fqdn_option(
887 DHCPMessage *message,
888 size_t optlen,
889 size_t *optoffset,
890 const char *fqdn) {
891
23873e25
BG		 892 uint8_t buffer[3 + DHCP_MAX_FQDN_LENGTH];
893 int r;
894
895 buffer[0] = DHCP_FQDN_FLAG_S | /* Request server to perform A RR DNS updates */
896 DHCP_FQDN_FLAG_E; /* Canonical wire format */
897 buffer[1] = 0; /* RCODE1 (deprecated) */
898 buffer[2] = 0; /* RCODE2 (deprecated) */
899
3cd03457 900 r = dns_name_to_wire_format(fqdn, buffer + 3, sizeof(buffer) - 3, false);
23873e25
BG		 901 if (r > 0)
902 r = dhcp_option_append(message, optlen, optoffset, 0,
22805d92 903 SD_DHCP_OPTION_FQDN, 3 + r, buffer);
23873e25
BG		 904
905 return r;
906}
907
4b558378
ZJS		 908static int dhcp_client_send_raw(
909 sd_dhcp_client *client,
910 DHCPPacket *packet,
911 size_t len) {
912
9faed222 913 dhcp_packet_append_ip_headers(packet, INADDR_ANY, client->port,
afe42aef 914 INADDR_BROADCAST, DHCP_PORT_SERVER, len, client->ip_service_type);
63edaa62
TG		 915
916 return dhcp_network_send_raw_socket(client->fd, &client->link,
917 packet, len);
918}
919
579ca0a2 920static int client_append_common_discover_request_options(sd_dhcp_client *client, DHCPPacket *packet, size_t *optoffset, size_t optlen) {
cb29c156 921 sd_dhcp_option *j;
6236f49b
TG		 922 int r;
923
924 assert(client);
46a66b79 925
4cc7a82c 926 if (client->hostname) {
23873e25
BG		 927 /* According to RFC 4702 "clients that send the Client FQDN option in
928 their messages MUST NOT also send the Host Name option". Just send
929 one of the two depending on the hostname type.
930 */
dc477e73 931 if (dns_name_is_single_label(client->hostname)) {
23873e25
BG		 932 /* it is unclear from RFC 2131 if client should send hostname in
933 DHCPDISCOVER but dhclient does and so we do as well
934 */
579ca0a2 935 r = dhcp_option_append(&packet->dhcp, optlen, optoffset, 0,
22805d92 936 SD_DHCP_OPTION_HOST_NAME,
23873e25
BG		 937 strlen(client->hostname), client->hostname);
938 } else
579ca0a2 939 r = client_append_fqdn_option(&packet->dhcp, optlen, optoffset,
23873e25 940 client->hostname);
4cc7a82c
EY		 941 if (r < 0)
942 return r;
943 }
944
edb85f0d 945 if (client->vendor_class_identifier) {
579ca0a2 946 r = dhcp_option_append(&packet->dhcp, optlen, optoffset, 0,
22805d92 947 SD_DHCP_OPTION_VENDOR_CLASS_IDENTIFIER,
edb85f0d
SS		 948 strlen(client->vendor_class_identifier),
949 client->vendor_class_identifier);
950 if (r < 0)
951 return r;
952 }
953
d11d4a64 954 if (client->mudurl) {
579ca0a2 955 r = dhcp_option_append(&packet->dhcp, optlen, optoffset, 0,
d11d4a64
SS		 956 SD_DHCP_OPTION_MUD_URL,
957 strlen(client->mudurl),
958 client->mudurl);
959 if (r < 0)
960 return r;
961 }
962
af1c0de0 963 if (client->user_class) {
579ca0a2 964 r = dhcp_option_append(&packet->dhcp, optlen, optoffset, 0,
af1c0de0
SS		 965 SD_DHCP_OPTION_USER_CLASS,
966 strv_length(client->user_class),
967 client->user_class);
968 if (r < 0)
969 return r;
970 }
971
90e74a66 972 ORDERED_HASHMAP_FOREACH(j, client->extra_options) {
579ca0a2 973 r = dhcp_option_append(&packet->dhcp, optlen, optoffset, 0,
cb29c156
SS		 974 j->option, j->length, j->data);
975 if (r < 0)
976 return r;
977 }
978
7354900d
DW		 979 if (!ordered_hashmap_isempty(client->vendor_options)) {
980 r = dhcp_option_append(
579ca0a2 981 &packet->dhcp, optlen, optoffset, 0,
7354900d
DW		 982 SD_DHCP_OPTION_VENDOR_SPECIFIC,
983 ordered_hashmap_size(client->vendor_options), client->vendor_options);
984 if (r < 0)
985 return r;
986 }
987
579ca0a2
SS		 988
989 return 0;
990}
991
992static int client_send_discover(sd_dhcp_client *client) {
993 _cleanup_free_ DHCPPacket *discover = NULL;
994 size_t optoffset, optlen;
995 int r;
996
997 assert(client);
998 assert(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_SELECTING));
999
1000 r = client_message_init(client, &discover, DHCP_DISCOVER,
1001 &optlen, &optoffset);
1002 if (r < 0)
1003 return r;
1004
1005 /* the client may suggest values for the network address
1006 and lease time in the DHCPDISCOVER message. The client may include
1007 the ’requested IP address’ option to suggest that a particular IP
1008 address be assigned, and may include the ’IP address lease time’
1009 option to suggest the lease time it would like.
1010 */
1011 /* RFC7844 section 3:
1012 SHOULD NOT contain any other option. */
1013 if (!client->anonymize && client->last_addr != INADDR_ANY) {
1014 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
1015 SD_DHCP_OPTION_REQUESTED_IP_ADDRESS,
1016 4, &client->last_addr);
1017 if (r < 0)
1018 return r;
1019 }
1020
1021 r = client_append_common_discover_request_options(client, discover, &optoffset, optlen);
1022 if (r < 0)
1023 return r;
1024
04b28be1 1025 r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0,
22805d92 1026 SD_DHCP_OPTION_END, 0, NULL);
f7926298
TA		 1027 if (r < 0)
1028 return r;
46a66b79 1029
50d6810e
TG		 1030 /* We currently ignore:
1031 The client SHOULD wait a random time between one and ten seconds to
1032 desynchronize the use of DHCP at startup.
1033 */
20b958bf 1034 r = dhcp_client_send_raw(client, discover, sizeof(DHCPPacket) + optoffset);
6236f49b
TG		 1035 if (r < 0)
1036 return r;
e2dfc79f 1037
ee57a737
TG		 1038 log_dhcp_client(client, "DISCOVER");
1039
63edaa62 1040 return 0;
e2dfc79f
PF		 1041}
1042
6236f49b 1043static int client_send_request(sd_dhcp_client *client) {
8186d9dd 1044 _cleanup_free_ DHCPPacket *request = NULL;
424a8732 1045 size_t optoffset, optlen;
6236f49b 1046 int r;
e2dfc79f 1047
a1140666
LP		 1048 assert(client);
1049
1050 r = client_message_init(client, &request, DHCP_REQUEST, &optlen, &optoffset);
6236f49b
TG		 1051 if (r < 0)
1052 return r;
46a66b79 1053
8b1243f7 1054 switch (client->state) {
50d6810e
TG		 1055 /* See RFC2131 section 4.3.2 (note that there is a typo in the RFC,
1056 SELECTING should be REQUESTING)
1057 */
1058
1059 case DHCP_STATE_REQUESTING:
1060 /* Client inserts the address of the selected server in ’server
1061 identifier’, ’ciaddr’ MUST be zero, ’requested IP address’ MUST be
1062 filled in with the yiaddr value from the chosen DHCPOFFER.
1063 */
8b1243f7 1064
04b28be1 1065 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
22805d92 1066 SD_DHCP_OPTION_SERVER_IDENTIFIER,
50d6810e 1067 4, &client->lease->server_address);
6236f49b
TG		 1068 if (r < 0)
1069 return r;
8b1243f7 1070
04b28be1 1071 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
22805d92 1072 SD_DHCP_OPTION_REQUESTED_IP_ADDRESS,
6236f49b
TG		 1073 4, &client->lease->address);
1074 if (r < 0)
1075 return r;
1076
50d6810e
TG		 1077 break;
1078
1079 case DHCP_STATE_INIT_REBOOT:
1080 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
1081 option MUST be filled in with client’s notion of its previously
1082 assigned address. ’ciaddr’ MUST be zero.
1083 */
04b28be1 1084 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
22805d92 1085 SD_DHCP_OPTION_REQUESTED_IP_ADDRESS,
50d6810e 1086 4, &client->last_addr);
6236f49b
TG		 1087 if (r < 0)
1088 return r;
8b1243f7
PF		 1089 break;
1090
8b1243f7 1091 case DHCP_STATE_RENEWING:
50d6810e
TG		 1092 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
1093 option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
1094 client’s IP address.
1095 */
1096
8b1243f7 1097 case DHCP_STATE_REBINDING:
50d6810e
TG		 1098 /* ’server identifier’ MUST NOT be filled in, ’requested IP address’
1099 option MUST NOT be filled in, ’ciaddr’ MUST be filled in with
1100 client’s IP address.
1101
1102 This message MUST be broadcast to the 0xffffffff IP broadcast address.
1103 */
1104 request->dhcp.ciaddr = client->lease->address;
8b1243f7
PF		 1105
1106 break;
781ca7a1 1107
50d6810e
TG		 1108 case DHCP_STATE_INIT:
1109 case DHCP_STATE_SELECTING:
1110 case DHCP_STATE_REBOOTING:
1111 case DHCP_STATE_BOUND:
781ca7a1
PF		 1112 case DHCP_STATE_STOPPED:
1113 return -EINVAL;
e2dfc79f 1114 }
46a66b79 1115
579ca0a2
SS		 1116 r = client_append_common_discover_request_options(client, request, &optoffset, optlen);
1117 if (r < 0)
1118 return r;
d11d4a64 1119
04b28be1 1120 r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0,
22805d92 1121 SD_DHCP_OPTION_END, 0, NULL);
6236f49b
TG		 1122 if (r < 0)
1123 return r;
46a66b79 1124
bdbb98d9 1125 if (client->state == DHCP_STATE_RENEWING)
6236f49b
TG		 1126 r = dhcp_network_send_udp_socket(client->fd,
1127 client->lease->server_address,
1128 DHCP_PORT_SERVER,
1129 &request->dhcp,
20b958bf 1130 sizeof(DHCPMessage) + optoffset);
bdbb98d9 1131 else
20b958bf 1132 r = dhcp_client_send_raw(client, request, sizeof(DHCPPacket) + optoffset);
6236f49b
TG		 1133 if (r < 0)
1134 return r;
46a66b79 1135
998d8047 1136 switch (client->state) {
a1140666 1137
998d8047
TG		 1138 case DHCP_STATE_REQUESTING:
1139 log_dhcp_client(client, "REQUEST (requesting)");
1140 break;
a1140666 1141
998d8047
TG		 1142 case DHCP_STATE_INIT_REBOOT:
1143 log_dhcp_client(client, "REQUEST (init-reboot)");
1144 break;
a1140666 1145
998d8047
TG		 1146 case DHCP_STATE_RENEWING:
1147 log_dhcp_client(client, "REQUEST (renewing)");
1148 break;
a1140666 1149
998d8047
TG		 1150 case DHCP_STATE_REBINDING:
1151 log_dhcp_client(client, "REQUEST (rebinding)");
1152 break;
a1140666 1153
998d8047
TG		 1154 default:
1155 log_dhcp_client(client, "REQUEST (invalid)");
1156 break;
1157 }
ee57a737 1158
63edaa62 1159 return 0;
46a66b79
PF		 1160}
1161
7739a40b
TG		 1162static int client_start(sd_dhcp_client *client);
1163
4b558378
ZJS		 1164static int client_timeout_resend(
1165 sd_event_source *s,
1166 uint64_t usec,
1167 void *userdata) {
1168
d3d8ac2f 1169 sd_dhcp_client *client = userdata;
574cc928 1170 DHCP_CLIENT_DONT_DESTROY(client);
aba26854 1171 usec_t next_timeout = 0;
d23c45bf 1172 uint64_t time_now;
aba26854 1173 uint32_t time_left;
d23c45bf 1174 int r;
b25ef18b
TG		 1175
1176 assert(s);
1177 assert(client);
1178 assert(client->event);
d3d8ac2f 1179
fa94c34b 1180 r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
d23c45bf
TG		 1181 if (r < 0)
1182 goto error;
1183
aba26854 1184 switch (client->state) {
a1140666 1185
aba26854
PF		 1186 case DHCP_STATE_RENEWING:
1187
e5002702 1188 time_left = (client->lease->t2 - client->lease->t1) / 2;
aba26854
PF		 1189 if (time_left < 60)
1190 time_left = 60;
d3d8ac2f 1191
d23c45bf 1192 next_timeout = time_now + time_left * USEC_PER_SEC;
d3d8ac2f 1193
aba26854
PF		 1194 break;
1195
3dd71400
PF		 1196 case DHCP_STATE_REBINDING:
1197
e5002702 1198 time_left = (client->lease->lifetime - client->lease->t2) / 2;
3dd71400
PF		 1199 if (time_left < 60)
1200 time_left = 60;
1201
d23c45bf 1202 next_timeout = time_now + time_left * USEC_PER_SEC;
3dd71400
PF		 1203 break;
1204
8b1243f7
PF		 1205 case DHCP_STATE_REBOOTING:
1206 /* start over as we did not receive a timely ack or nak */
7739a40b 1207 r = client_initialize(client);
eb105b96
TG		 1208 if (r < 0)
1209 goto error;
8b1243f7 1210
998d8047
TG		 1211 r = client_start(client);
1212 if (r < 0)
1213 goto error;
1214 else {
1215 log_dhcp_client(client, "REBOOTED");
1216 return 0;
1217 }
7739a40b 1218
aba26854
PF		 1219 case DHCP_STATE_INIT:
1220 case DHCP_STATE_INIT_REBOOT:
aba26854
PF		 1221 case DHCP_STATE_SELECTING:
1222 case DHCP_STATE_REQUESTING:
1223 case DHCP_STATE_BOUND:
aba26854 1224
715cedfb 1225 if (client->attempt < client->max_attempts)
11793fcd 1226 client->attempt++;
8bc17bb3
SS		 1227 else
1228 goto error;
aba26854 1229
715cedfb 1230 next_timeout = time_now + ((UINT64_C(1) << MIN(client->attempt, (uint64_t) 6)) - 1) * USEC_PER_SEC;
aba26854
PF		 1231
1232 break;
781ca7a1
PF		 1233
1234 case DHCP_STATE_STOPPED:
1235 r = -EINVAL;
1236 goto error;
aba26854
PF		 1237 }
1238
9bf3b535 1239 next_timeout += (random_u32() & 0x1fffff);
d3d8ac2f 1240
a3fa4287
YW		 1241 r = event_reset_time(client->event, &client->timeout_resend,
1242 clock_boottime_or_monotonic(),
1243 next_timeout, 10 * USEC_PER_MSEC,
1244 client_timeout_resend, client,
1245 client->event_priority, "dhcp4-resend-timer", true);
9021bb9f
TG		 1246 if (r < 0)
1247 goto error;
1248
e2dfc79f
PF		 1249 switch (client->state) {
1250 case DHCP_STATE_INIT:
6236f49b 1251 r = client_send_discover(client);
b25ef18b 1252 if (r >= 0) {
e2dfc79f 1253 client->state = DHCP_STATE_SELECTING;
11793fcd 1254 client->attempt = 0;
715cedfb
SS		 1255 } else if (client->attempt >= client->max_attempts)
1256 goto error;
e2dfc79f
PF		 1257
1258 break;
1259
1260 case DHCP_STATE_SELECTING:
6236f49b 1261 r = client_send_discover(client);
715cedfb 1262 if (r < 0 && client->attempt >= client->max_attempts)
d3d8ac2f
PF		 1263 goto error;
1264
e2dfc79f
PF		 1265 break;
1266
8b1243f7 1267 case DHCP_STATE_INIT_REBOOT:
e2dfc79f 1268 case DHCP_STATE_REQUESTING:
aba26854 1269 case DHCP_STATE_RENEWING:
3dd71400 1270 case DHCP_STATE_REBINDING:
6236f49b 1271 r = client_send_request(client);
715cedfb 1272 if (r < 0 && client->attempt >= client->max_attempts)
e2dfc79f 1273 goto error;
d3d8ac2f 1274
8b1243f7
PF		 1275 if (client->state == DHCP_STATE_INIT_REBOOT)
1276 client->state = DHCP_STATE_REBOOTING;
1277
d23c45bf 1278 client->request_sent = time_now;
51debc1e 1279
d3d8ac2f
PF		 1280 break;
1281
d3d8ac2f 1282 case DHCP_STATE_REBOOTING:
d3d8ac2f 1283 case DHCP_STATE_BOUND:
d3d8ac2f
PF		 1284
1285 break;
781ca7a1
PF		 1286
1287 case DHCP_STATE_STOPPED:
1288 r = -EINVAL;
1289 goto error;
d3d8ac2f
PF		 1290 }
1291
1292 return 0;
1293
1294error:
b25ef18b 1295 client_stop(client, r);
d3d8ac2f
PF		 1296
1297 /* Errors were dealt with when stopping the client, don't spill
1298 errors into the event loop handler */
1299 return 0;
1300}
1301
4b558378
ZJS		 1302static int client_initialize_io_events(
1303 sd_dhcp_client *client,
1304 sd_event_io_handler_t io_callback) {
1305
6a1cd41e
PF		 1306 int r;
1307
b25ef18b
TG		 1308 assert(client);
1309 assert(client->event);
1310
151b9b96
LP		 1311 r = sd_event_add_io(client->event, &client->receive_message,
1312 client->fd, EPOLLIN, io_callback,
1313 client);
6a1cd41e
PF		 1314 if (r < 0)
1315 goto error;
1316
e5002702
TG		 1317 r = sd_event_source_set_priority(client->receive_message,
1318 client->event_priority);
b25ef18b
TG		 1319 if (r < 0)
1320 goto error;
1321
356779df 1322 r = sd_event_source_set_description(client->receive_message, "dhcp4-receive-message");
9021bb9f
TG		 1323 if (r < 0)
1324 goto error;
1325
0af03ba5
TG		 1326error:
1327 if (r < 0)
1328 client_stop(client, r);
1329
1330 return 0;
1331}
1332
1333static int client_initialize_time_events(sd_dhcp_client *client) {
1d1a3e0a 1334 uint64_t usec = 0;
0af03ba5
TG		 1335 int r;
1336
1337 assert(client);
1338 assert(client->event);
1339
bdbb98d9 1340 if (client->start_delay > 0) {
8ecdcb55 1341 assert_se(sd_event_now(client->event, clock_boottime_or_monotonic(), &usec) >= 0);
1d1a3e0a
BG		 1342 usec += client->start_delay;
1343 }
1344
a3fa4287
YW		 1345 r = event_reset_time(client->event, &client->timeout_resend,
1346 clock_boottime_or_monotonic(),
1347 usec, 0,
1348 client_timeout_resend, client,
1349 client->event_priority, "dhcp4-resend-timer", true);
6a1cd41e
PF		 1350 if (r < 0)
1351 client_stop(client, r);
1352
1353 return 0;
1354
1355}
1356
4b558378 1357static int client_initialize_events(sd_dhcp_client *client, sd_event_io_handler_t io_callback) {
0af03ba5
TG		 1358 client_initialize_io_events(client, io_callback);
1359 client_initialize_time_events(client);
1360
1361 return 0;
1362}
1363
1d1a3e0a 1364static int client_start_delayed(sd_dhcp_client *client) {
0f941add
PF		 1365 int r;
1366
1367 assert_return(client, -EINVAL);
1368 assert_return(client->event, -EINVAL);
2f8e7633 1369 assert_return(client->ifindex > 0, -EINVAL);
0f941add
PF		 1370 assert_return(client->fd < 0, -EBUSY);
1371 assert_return(client->xid == 0, -EINVAL);
a1140666 1372 assert_return(IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_INIT_REBOOT), -EBUSY);
0f941add
PF		 1373
1374 client->xid = random_u32();
1375
2f8e7633 1376 r = dhcp_network_bind_raw_socket(client->ifindex, &client->link,
76253e73 1377 client->xid, client->mac_addr,
9faed222 1378 client->mac_addr_len, client->arp_type, client->port);
0f941add
PF		 1379 if (r < 0) {
1380 client_stop(client, r);
1381 return r;
1382 }
0f941add 1383 client->fd = r;
58ec2d3e 1384
3742095b 1385 if (IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_INIT_REBOOT))
fa94c34b 1386 client->start_time = now(clock_boottime_or_monotonic());
0f941add 1387
0f941add
PF		 1388 return client_initialize_events(client, client_receive_message_raw);
1389}
1390
1d1a3e0a
BG		 1391static int client_start(sd_dhcp_client *client) {
1392 client->start_delay = 0;
1393 return client_start_delayed(client);
1394}
1395
4b558378 1396static int client_timeout_expire(sd_event_source *s, uint64_t usec, void *userdata) {
751246ee 1397 sd_dhcp_client *client = userdata;
574cc928 1398 DHCP_CLIENT_DONT_DESTROY(client);
751246ee 1399
ee57a737
TG		 1400 log_dhcp_client(client, "EXPIRED");
1401
03748142 1402 client_notify(client, SD_DHCP_CLIENT_EVENT_EXPIRED);
0f941add 1403
781ca7a1 1404 /* lease was lost, start over if not freed or stopped in callback */
574cc928 1405 if (client->state != DHCP_STATE_STOPPED) {
e5b04c8d
PF		 1406 client_initialize(client);
1407 client_start(client);
1408 }
751246ee 1409
51debc1e
PF		 1410 return 0;
1411}
1412
5ee482df 1413static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) {
3dd71400 1414 sd_dhcp_client *client = userdata;
574cc928 1415 DHCP_CLIENT_DONT_DESTROY(client);
3dd71400
PF		 1416 int r;
1417
a1140666
LP		 1418 assert(client);
1419
03e334a1 1420 client->receive_message = sd_event_source_unref(client->receive_message);
22fc2420 1421 client->fd = asynchronous_close(client->fd);
3dd71400
PF		 1422
1423 client->state = DHCP_STATE_REBINDING;
11793fcd 1424 client->attempt = 0;
3dd71400 1425
2f8e7633 1426 r = dhcp_network_bind_raw_socket(client->ifindex, &client->link,
76253e73 1427 client->xid, client->mac_addr,
9faed222
SS		 1428 client->mac_addr_len, client->arp_type,
1429 client->port);
3dd71400
PF		 1430 if (r < 0) {
1431 client_stop(client, r);
1432 return 0;
1433 }
3dd71400
PF		 1434 client->fd = r;
1435
d23c45bf 1436 return client_initialize_events(client, client_receive_message_raw);
51debc1e
PF		 1437}
1438
4b558378 1439static int client_timeout_t1(sd_event_source *s, uint64_t usec, void *userdata) {
aba26854 1440 sd_dhcp_client *client = userdata;
574cc928 1441 DHCP_CLIENT_DONT_DESTROY(client);
aba26854 1442
921693a0
YW		 1443 if (client->lease)
1444 client->state = DHCP_STATE_RENEWING;
1445 else if (client->state != DHCP_STATE_INIT)
1446 client->state = DHCP_STATE_INIT_REBOOT;
11793fcd 1447 client->attempt = 0;
aba26854 1448
0af03ba5 1449 return client_initialize_time_events(client);
51debc1e
PF		 1450}
1451
4b558378 1452static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer, size_t len) {
4afd3348 1453 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
5ee482df 1454 int r;
3e3d8f78 1455
a6cc569e
TG		 1456 r = dhcp_lease_new(&lease);
1457 if (r < 0)
1458 return r;
8c00042c 1459
e37f74a6
DW		 1460 if (client->client_id_len) {
1461 r = dhcp_lease_set_client_id(lease,
5bac5235 1462 (uint8_t *) &client->client_id,
e37f74a6
DW		 1463 client->client_id_len);
1464 if (r < 0)
1465 return r;
1466 }
1467
f693e9b3 1468 r = dhcp_option_parse(offer, len, dhcp_lease_parse_options, lease, NULL);
9e64dd72 1469 if (r != DHCP_OFFER) {
6ff8806e 1470 log_dhcp_client(client, "received message was not an OFFER, ignoring");
5ee482df 1471 return -ENOMSG;
9e64dd72 1472 }
8c00042c 1473
8e34a618 1474 lease->next_server = offer->siaddr;
e5002702 1475 lease->address = offer->yiaddr;
8c00042c 1476
4c0b8d56
SS		 1477 if (lease->lifetime == 0 && client->fallback_lease_lifetime > 0)
1478 lease->lifetime = client->fallback_lease_lifetime;
1479
0339cd77
LP		 1480 if (lease->address == 0 ||
1481 lease->server_address == 0 ||
9e64dd72 1482 lease->lifetime == 0) {
0339cd77 1483 log_dhcp_client(client, "received lease lacks address, server address or lease lifetime, ignoring");
5ee482df 1484 return -ENOMSG;
9e64dd72
TG		 1485 }
1486
0339cd77 1487 if (!lease->have_subnet_mask) {
9e64dd72
TG		 1488 r = dhcp_lease_set_default_subnet_mask(lease);
1489 if (r < 0) {
87ac8d99
ZJS		 1490 log_dhcp_client(client,
1491 "received lease lacks subnet mask, "
1492 "and a fallback one cannot be generated, ignoring");
9e64dd72
TG		 1493 return -ENOMSG;
1494 }
1495 }
8c00042c 1496
6e00a806 1497 sd_dhcp_lease_unref(client->lease);
1cc6c93a 1498 client->lease = TAKE_PTR(lease);
8c00042c 1499
727b5734
SS		 1500 if (client_notify(client, SD_DHCP_CLIENT_EVENT_SELECTING) < 0)
1501 return -ENOMSG;
1502
ee57a737
TG		 1503 log_dhcp_client(client, "OFFER");
1504
8c00042c 1505 return 0;
8c00042c
PF		 1506}
1507
4b558378 1508static int client_handle_forcerenew(sd_dhcp_client *client, DHCPMessage *force, size_t len) {
615c1467
TG		 1509 int r;
1510
f693e9b3 1511 r = dhcp_option_parse(force, len, NULL, NULL, NULL);
615c1467
TG		 1512 if (r != DHCP_FORCERENEW)
1513 return -ENOMSG;
1514
1515 log_dhcp_client(client, "FORCERENEW");
1516
1517 return 0;
1518}
1519
3d9f6707
YW		 1520static bool lease_equal(const sd_dhcp_lease *a, const sd_dhcp_lease *b) {
1521 if (a->address != b->address)
1522 return false;
1523
1524 if (a->subnet_mask != b->subnet_mask)
1525 return false;
1526
1527 if (a->router_size != b->router_size)
1528 return false;
1529
1530 for (size_t i = 0; i < a->router_size; i++)
1531 if (a->router[i].s_addr != b->router[i].s_addr)
1532 return false;
1533
1534 return true;
1535}
1536
4b558378 1537static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack, size_t len) {
4afd3348 1538 _cleanup_(sd_dhcp_lease_unrefp) sd_dhcp_lease *lease = NULL;
f693e9b3 1539 _cleanup_free_ char *error_message = NULL;
5ee482df 1540 int r;
3e3d8f78 1541
a6cc569e
TG		 1542 r = dhcp_lease_new(&lease);
1543 if (r < 0)
1544 return r;
3e3d8f78 1545
e37f74a6
DW		 1546 if (client->client_id_len) {
1547 r = dhcp_lease_set_client_id(lease,
5bac5235 1548 (uint8_t *) &client->client_id,
e37f74a6
DW		 1549 client->client_id_len);
1550 if (r < 0)
1551 return r;
1552 }
1553
f693e9b3 1554 r = dhcp_option_parse(ack, len, dhcp_lease_parse_options, lease, &error_message);
ee57a737 1555 if (r == DHCP_NAK) {
f693e9b3 1556 log_dhcp_client(client, "NAK: %s", strna(error_message));
2d2349cc 1557 return -EADDRNOTAVAIL;
ee57a737 1558 }
3e3d8f78 1559
9e64dd72 1560 if (r != DHCP_ACK) {
6ff8806e 1561 log_dhcp_client(client, "received message was not an ACK, ignoring");
5ee482df 1562 return -ENOMSG;
9e64dd72 1563 }
3e3d8f78 1564
8e34a618
TG		 1565 lease->next_server = ack->siaddr;
1566
e5002702 1567 lease->address = ack->yiaddr;
3e3d8f78
PF		 1568
1569 if (lease->address == INADDR_ANY ||
1570 lease->server_address == INADDR_ANY ||
9e64dd72 1571 lease->lifetime == 0) {
6ff8806e 1572 log_dhcp_client(client, "received lease lacks address, server "
9e64dd72 1573 "address or lease lifetime, ignoring");
5ee482df 1574 return -ENOMSG;
9e64dd72
TG		 1575 }
1576
1577 if (lease->subnet_mask == INADDR_ANY) {
1578 r = dhcp_lease_set_default_subnet_mask(lease);
1579 if (r < 0) {
87ac8d99
ZJS		 1580 log_dhcp_client(client,
1581 "received lease lacks subnet mask, "
1582 "and a fallback one cannot be generated, ignoring");
9e64dd72
TG		 1583 return -ENOMSG;
1584 }
1585 }
3e3d8f78 1586
03748142 1587 r = SD_DHCP_CLIENT_EVENT_IP_ACQUIRE;
3e3d8f78 1588 if (client->lease) {
3d9f6707 1589 if (lease_equal(client->lease, lease))
03748142 1590 r = SD_DHCP_CLIENT_EVENT_RENEW;
3d9f6707
YW		 1591 else
1592 r = SD_DHCP_CLIENT_EVENT_IP_CHANGE;
3e3d8f78 1593
a6cc569e 1594 client->lease = sd_dhcp_lease_unref(client->lease);
3e3d8f78
PF		 1595 }
1596
1cc6c93a 1597 client->lease = TAKE_PTR(lease);
3e3d8f78 1598
ee57a737
TG		 1599 log_dhcp_client(client, "ACK");
1600
3e3d8f78
PF		 1601 return r;
1602}
1603
fbcd420a 1604static uint64_t client_compute_timeout(sd_dhcp_client *client, uint32_t lifetime, double factor) {
022446ad
TG		 1605 assert(client);
1606 assert(client->request_sent);
fbcd420a 1607 assert(lifetime > 0);
022446ad 1608
fbcd420a
LP		 1609 if (lifetime > 3)
1610 lifetime -= 3;
1611 else
1612 lifetime = 0;
1613
1614 return client->request_sent + (lifetime * USEC_PER_SEC * factor) +
9bf3b535 1615 + (random_u32() & 0x1fffff);
51debc1e
PF		 1616}
1617
022446ad
TG		 1618static int client_set_lease_timeouts(sd_dhcp_client *client) {
1619 usec_t time_now;
1620 uint64_t lifetime_timeout;
1621 uint64_t t2_timeout;
1622 uint64_t t1_timeout;
1623 char time_string[FORMAT_TIMESPAN_MAX];
5ee482df 1624 int r;
51debc1e 1625
b25ef18b
TG		 1626 assert(client);
1627 assert(client->event);
022446ad
TG		 1628 assert(client->lease);
1629 assert(client->lease->lifetime);
51debc1e 1630
022446ad 1631 /* don't set timers for infinite leases */
a3fa4287
YW		 1632 if (client->lease->lifetime == 0xffffffff) {
1633 (void) event_source_disable(client->timeout_t1);
1634 (void) event_source_disable(client->timeout_t2);
1635 (void) event_source_disable(client->timeout_expire);
1636
022446ad 1637 return 0;
a3fa4287 1638 }
51debc1e 1639
fa94c34b 1640 r = sd_event_now(client->event, clock_boottime_or_monotonic(), &time_now);
022446ad
TG		 1641 if (r < 0)
1642 return r;
1643 assert(client->request_sent <= time_now);
1644
1645 /* convert the various timeouts from relative (secs) to absolute (usecs) */
1646 lifetime_timeout = client_compute_timeout(client, client->lease->lifetime, 1);
fbcd420a 1647 if (client->lease->t1 > 0 && client->lease->t2 > 0) {
022446ad
TG		 1648 /* both T1 and T2 are given */
1649 if (client->lease->t1 < client->lease->t2 &&
1650 client->lease->t2 < client->lease->lifetime) {
1651 /* they are both valid */
1652 t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
1653 t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
1654 } else {
1655 /* discard both */
1656 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1657 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1658 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1659 client->lease->t1 = client->lease->lifetime / 2;
1660 }
fbcd420a 1661 } else if (client->lease->t2 > 0 && client->lease->t2 < client->lease->lifetime) {
022446ad
TG		 1662 /* only T2 is given, and it is valid */
1663 t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
1664 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1665 client->lease->t1 = client->lease->lifetime / 2;
1666 if (t2_timeout <= t1_timeout) {
1667 /* the computed T1 would be invalid, so discard T2 */
1668 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1669 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1670 }
fbcd420a 1671 } else if (client->lease->t1 > 0 && client->lease->t1 < client->lease->lifetime) {
022446ad
TG		 1672 /* only T1 is given, and it is valid */
1673 t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
1674 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1675 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1676 if (t2_timeout <= t1_timeout) {
1677 /* the computed T2 would be invalid, so discard T1 */
1678 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1679 client->lease->t2 = client->lease->lifetime / 2;
1680 }
1681 } else {
1682 /* fall back to the default timeouts */
1683 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
1684 client->lease->t1 = client->lease->lifetime / 2;
1685 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
1686 client->lease->t2 = (client->lease->lifetime * 7) / 8;
1687 }
51debc1e 1688
022446ad 1689 /* arm lifetime timeout */
a3fa4287
YW		 1690 r = event_reset_time(client->event, &client->timeout_expire,
1691 clock_boottime_or_monotonic(),
1692 lifetime_timeout, 10 * USEC_PER_MSEC,
1693 client_timeout_expire, client,
1694 client->event_priority, "dhcp4-lifetime", true);
9021bb9f
TG		 1695 if (r < 0)
1696 return r;
1697
022446ad 1698 log_dhcp_client(client, "lease expires in %s",
ed19c567 1699 format_timespan(time_string, FORMAT_TIMESPAN_MAX, lifetime_timeout - time_now, USEC_PER_SEC));
51debc1e 1700
022446ad
TG		 1701 /* don't arm earlier timeouts if this has already expired */
1702 if (lifetime_timeout <= time_now)
1703 return 0;
51debc1e 1704
022446ad 1705 /* arm T2 timeout */
a3fa4287
YW		 1706 r = event_reset_time(client->event, &client->timeout_t2,
1707 clock_boottime_or_monotonic(),
1708 t2_timeout, 10 * USEC_PER_MSEC,
1709 client_timeout_t2, client,
1710 client->event_priority, "dhcp4-t2-timeout", true);
9021bb9f
TG		 1711 if (r < 0)
1712 return r;
1713
022446ad 1714 log_dhcp_client(client, "T2 expires in %s",
ed19c567 1715 format_timespan(time_string, FORMAT_TIMESPAN_MAX, t2_timeout - time_now, USEC_PER_SEC));
022446ad
TG		 1716
1717 /* don't arm earlier timeout if this has already expired */
1718 if (t2_timeout <= time_now)
1719 return 0;
51debc1e 1720
022446ad 1721 /* arm T1 timeout */
a3fa4287
YW		 1722 r = event_reset_time(client->event, &client->timeout_t1,
1723 clock_boottime_or_monotonic(),
1724 t1_timeout, 10 * USEC_PER_MSEC,
1725 client_timeout_t1, client,
1726 client->event_priority, "dhcp4-t1-timer", true);
9021bb9f
TG		 1727 if (r < 0)
1728 return r;
1729
022446ad 1730 log_dhcp_client(client, "T1 expires in %s",
ed19c567 1731 format_timespan(time_string, FORMAT_TIMESPAN_MAX, t1_timeout - time_now, USEC_PER_SEC));
022446ad 1732
51debc1e
PF		 1733 return 0;
1734}
1735
4b558378 1736static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, int len) {
574cc928 1737 DHCP_CLIENT_DONT_DESTROY(client);
1d1a3e0a 1738 char time_string[FORMAT_TIMESPAN_MAX];
e5002702 1739 int r = 0, notify_event = 0;
8c00042c 1740
b25ef18b
TG		 1741 assert(client);
1742 assert(client->event);
e5002702 1743 assert(message);
b25ef18b 1744
8c00042c
PF		 1745 switch (client->state) {
1746 case DHCP_STATE_SELECTING:
1747
e5002702
TG		 1748 r = client_handle_offer(client, message, len);
1749 if (r >= 0) {
8c00042c 1750
8c00042c 1751 client->state = DHCP_STATE_REQUESTING;
11793fcd 1752 client->attempt = 0;
e2dfc79f 1753
a3fa4287
YW		 1754 r = event_reset_time(client->event, &client->timeout_resend,
1755 clock_boottime_or_monotonic(),
1756 0, 0,
1757 client_timeout_resend, client,
1758 client->event_priority, "dhcp4-resend-timer", true);
9021bb9f
TG		 1759 if (r < 0)
1760 goto error;
9e64dd72
TG		 1761 } else if (r == -ENOMSG)
1762 /* invalid message, let's ignore it */
1763 return 0;
8c00042c
PF		 1764
1765 break;
1766
8b1243f7 1767 case DHCP_STATE_REBOOTING:
3e3d8f78 1768 case DHCP_STATE_REQUESTING:
aba26854 1769 case DHCP_STATE_RENEWING:
3dd71400 1770 case DHCP_STATE_REBINDING:
aba26854 1771
e5002702 1772 r = client_handle_ack(client, message, len);
2d2349cc 1773 if (r >= 0) {
1d1a3e0a 1774 client->start_delay = 0;
a3fa4287 1775 (void) event_source_disable(client->timeout_resend);
affaa94f
DW		 1776 client->receive_message =
1777 sd_event_source_unref(client->receive_message);
1778 client->fd = asynchronous_close(client->fd);
3e3d8f78 1779
8b1243f7
PF		 1780 if (IN_SET(client->state, DHCP_STATE_REQUESTING,
1781 DHCP_STATE_REBOOTING))
03748142
DH		 1782 notify_event = SD_DHCP_CLIENT_EVENT_IP_ACQUIRE;
1783 else if (r != SD_DHCP_CLIENT_EVENT_IP_ACQUIRE)
aba26854
PF		 1784 notify_event = r;
1785
3e3d8f78 1786 client->state = DHCP_STATE_BOUND;
11793fcd 1787 client->attempt = 0;
3e3d8f78
PF		 1788
1789 client->last_addr = client->lease->address;
1790
022446ad 1791 r = client_set_lease_timeouts(client);
0411760a
TG		 1792 if (r < 0) {
1793 log_dhcp_client(client, "could not set lease timeouts");
51debc1e 1794 goto error;
0411760a 1795 }
51debc1e 1796
afe42aef 1797 r = dhcp_network_bind_udp_socket(client->ifindex, client->lease->address, client->port, client->ip_service_type);
0af03ba5
TG		 1798 if (r < 0) {
1799 log_dhcp_client(client, "could not bind UDP socket");
1800 goto error;
1801 }
1802
1803 client->fd = r;
1804
1805 client_initialize_io_events(client, client_receive_message_udp);
1806
e5b04c8d 1807 if (notify_event) {
574cc928
TG		 1808 client_notify(client, notify_event);
1809 if (client->state == DHCP_STATE_STOPPED)
e5b04c8d
PF		 1810 return 0;
1811 }
3e3d8f78 1812
2d2349cc
TG		 1813 } else if (r == -EADDRNOTAVAIL) {
1814 /* got a NAK, let's restart the client */
cc3981b1
LS		 1815 client_notify(client, SD_DHCP_CLIENT_EVENT_EXPIRED);
1816
2d2349cc
TG		 1817 r = client_initialize(client);
1818 if (r < 0)
1819 goto error;
1820
1d1a3e0a 1821 r = client_start_delayed(client);
2d2349cc
TG		 1822 if (r < 0)
1823 goto error;
1824
1d1a3e0a
BG		 1825 log_dhcp_client(client, "REBOOT in %s", format_timespan(time_string, FORMAT_TIMESPAN_MAX,
1826 client->start_delay, USEC_PER_SEC));
1827
1828 client->start_delay = CLAMP(client->start_delay * 2,
1829 RESTART_AFTER_NAK_MIN_USEC, RESTART_AFTER_NAK_MAX_USEC);
2d2349cc
TG		 1830
1831 return 0;
9e64dd72
TG		 1832 } else if (r == -ENOMSG)
1833 /* invalid message, let's ignore it */
1834 return 0;
97b9372d 1835
3e3d8f78
PF		 1836 break;
1837
615c1467
TG		 1838 case DHCP_STATE_BOUND:
1839 r = client_handle_forcerenew(client, message, len);
1840 if (r >= 0) {
1841 r = client_timeout_t1(NULL, 0, client);
1842 if (r < 0)
1843 goto error;
1844 } else if (r == -ENOMSG)
1845 /* invalid message, let's ignore it */
1846 return 0;
1847
1848 break;
1849
8c00042c
PF		 1850 case DHCP_STATE_INIT:
1851 case DHCP_STATE_INIT_REBOOT:
8c00042c
PF		 1852
1853 break;
781ca7a1
PF		 1854
1855 case DHCP_STATE_STOPPED:
1856 r = -EINVAL;
1857 goto error;
8c00042c
PF		 1858 }
1859
1860error:
2d2349cc 1861 if (r < 0)
e5b04c8d 1862 client_stop(client, r);
e2dfc79f 1863
e5b04c8d 1864 return r;
8c00042c
PF		 1865}
1866
4b558378
ZJS		 1867static int client_receive_message_udp(
1868 sd_event_source *s,
1869 int fd,
1870 uint32_t revents,
1871 void *userdata) {
1872
e5002702 1873 sd_dhcp_client *client = userdata;
5266a81e 1874 _cleanup_free_ DHCPMessage *message = NULL;
13f1fd03 1875 const uint8_t *expected_chaddr = NULL;
76253e73 1876 uint8_t expected_hlen = 0;
4edc2c9b 1877 ssize_t len, buflen;
e5002702
TG		 1878
1879 assert(s);
1880 assert(client);
e5002702 1881
4edc2c9b 1882 buflen = next_datagram_size_fd(fd);
22a3fd2d
BG		 1883 if (buflen == -ENETDOWN) {
1884 /* the link is down. Don't return an error or the I/O event
1885 source will be disconnected and we won't be able to receive
1886 packets again when the link comes back. */
1887 return 0;
1888 }
4edc2c9b
LP		 1889 if (buflen < 0)
1890 return buflen;
5266a81e
TG		 1891
1892 message = malloc0(buflen);
1893 if (!message)
1894 return -ENOMEM;
1895
cf447cb6 1896 len = recv(fd, message, buflen, 0);
0c79c68d 1897 if (len < 0) {
22a3fd2d
BG		 1898 /* see comment above for why we shouldn't error out on ENETDOWN. */
1899 if (IN_SET(errno, EAGAIN, EINTR, ENETDOWN))
0d43d2fc
TG		 1900 return 0;
1901
25f027c5
ZJS		 1902 return log_dhcp_client_errno(client, errno,
1903 "Could not receive message from UDP socket: %m");
004845d1
LP		 1904 }
1905 if ((size_t) len < sizeof(DHCPMessage)) {
0d43d2fc 1906 log_dhcp_client(client, "Too small to be a DHCP message: ignoring");
e5002702 1907 return 0;
9fbc2523
TG		 1908 }
1909
1910 if (be32toh(message->magic) != DHCP_MAGIC_COOKIE) {
0d43d2fc 1911 log_dhcp_client(client, "Not a DHCP message: ignoring");
9fbc2523
TG		 1912 return 0;
1913 }
1914
1915 if (message->op != BOOTREPLY) {
0d43d2fc 1916 log_dhcp_client(client, "Not a BOOTREPLY message: ignoring");
9fbc2523
TG		 1917 return 0;
1918 }
1919
76253e73 1920 if (message->htype != client->arp_type) {
0d43d2fc 1921 log_dhcp_client(client, "Packet type does not match client type");
76253e73
DW		 1922 return 0;
1923 }
1924
1925 if (client->arp_type == ARPHRD_ETHER) {
1926 expected_hlen = ETH_ALEN;
13f1fd03 1927 expected_chaddr = &client->mac_addr[0];
76253e73
DW		 1928 }
1929
1930 if (message->hlen != expected_hlen) {
0d43d2fc 1931 log_dhcp_client(client, "Unexpected packet hlen %d", message->hlen);
9fbc2523
TG		 1932 return 0;
1933 }
1934
13f1fd03 1935 if (expected_hlen > 0 && memcmp(&message->chaddr[0], expected_chaddr, expected_hlen)) {
0d43d2fc 1936 log_dhcp_client(client, "Received chaddr does not match expected: ignoring");
9fbc2523
TG		 1937 return 0;
1938 }
e5002702 1939
615c1467
TG		 1940 if (client->state != DHCP_STATE_BOUND &&
1941 be32toh(message->xid) != client->xid) {
1942 /* in BOUND state, we may receive FORCERENEW with xid set by server,
1943 so ignore the xid in this case */
0d43d2fc 1944 log_dhcp_client(client, "Received xid (%u) does not match expected (%u): ignoring",
615c1467
TG		 1945 be32toh(message->xid), client->xid);
1946 return 0;
1947 }
1948
022446ad 1949 return client_handle_message(client, message, len);
e5002702
TG		 1950}
1951
4b558378
ZJS		 1952static int client_receive_message_raw(
1953 sd_event_source *s,
1954 int fd,
1955 uint32_t revents,
1956 void *userdata) {
1957
e5002702 1958 sd_dhcp_client *client = userdata;
5266a81e 1959 _cleanup_free_ DHCPPacket *packet = NULL;
fb29cdbe 1960 CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct tpacket_auxdata))) control;
55dab2ed
TG		 1961 struct iovec iov = {};
1962 struct msghdr msg = {
1963 .msg_iov = &iov,
1964 .msg_iovlen = 1,
fb29cdbe
LP		 1965 .msg_control = &control,
1966 .msg_controllen = sizeof(control),
55dab2ed
TG		 1967 };
1968 struct cmsghdr *cmsg;
1969 bool checksum = true;
4edc2c9b
LP		 1970 ssize_t buflen, len;
1971 int r;
e5002702
TG		 1972
1973 assert(s);
1974 assert(client);
e5002702 1975
4edc2c9b 1976 buflen = next_datagram_size_fd(fd);
22a3fd2d
BG		 1977 if (buflen == -ENETDOWN)
1978 return 0;
4edc2c9b
LP		 1979 if (buflen < 0)
1980 return buflen;
5266a81e
TG		 1981
1982 packet = malloc0(buflen);
1983 if (!packet)
1984 return -ENOMEM;
1985
cb310866 1986 iov = IOVEC_MAKE(packet, buflen);
55dab2ed 1987
84b5d3e5
LP		 1988 len = recvmsg_safe(fd, &msg, 0);
1989 if (IN_SET(len, -EAGAIN, -EINTR, -ENETDOWN))
1990 return 0;
1991 if (len < 0)
1992 return log_dhcp_client_errno(client, len,
25f027c5 1993 "Could not receive message from raw socket: %m");
84b5d3e5
LP		 1994
1995 if ((size_t) len < sizeof(DHCPPacket))
0c79c68d 1996 return 0;
55dab2ed 1997
dac556fa
LP		 1998 cmsg = cmsg_find(&msg, SOL_PACKET, PACKET_AUXDATA, CMSG_LEN(sizeof(struct tpacket_auxdata)));
1999 if (cmsg) {
2000 struct tpacket_auxdata *aux = (struct tpacket_auxdata*) CMSG_DATA(cmsg);
2001 checksum = !(aux->tp_status & TP_STATUS_CSUMNOTREADY);
2002 }
e5002702 2003
9faed222 2004 r = dhcp_packet_verify_headers(packet, len, checksum, client->port);
ac4f16ab 2005 if (r < 0)
9fadd4ca 2006 return 0;
e5002702
TG		 2007
2008 len -= DHCP_IP_UDP_SIZE;
2009
022446ad 2010 return client_handle_message(client, &packet->dhcp, len);
e5002702
TG		 2011}
2012
1c9a2e26
YW		 2013int sd_dhcp_client_send_renew(sd_dhcp_client *client) {
2014 assert_return(client, -EINVAL);
2015 assert_return(client->fd >= 0, -EINVAL);
2016
0ded0e40 2017 if (!client->lease)
ceaec54a
YW		 2018 return 0;
2019
1c9a2e26
YW		 2020 client->start_delay = 0;
2021 client->attempt = 1;
2022 client->state = DHCP_STATE_RENEWING;
2023
2024 return client_initialize_time_events(client);
2025}
2026
5ee482df 2027int sd_dhcp_client_start(sd_dhcp_client *client) {
6a1cd41e 2028 int r;
d3d8ac2f 2029
46a66b79 2030 assert_return(client, -EINVAL);
46a66b79 2031
0f941add
PF		 2032 r = client_initialize(client);
2033 if (r < 0)
6a1cd41e 2034 return r;
8c00042c 2035
66173db7 2036 /* RFC7844 section 3.3:
2037 SHOULD perform a complete four-way handshake, starting with a
2038 DHCPDISCOVER, to obtain a new address lease. If the client can
2039 ascertain that this is exactly the same network to which it was
2040 previously connected, and if the link-layer address did not change,
2041 the client MAY issue a DHCPREQUEST to try to reclaim the current
2042 address. */
2043 if (client->last_addr && !client->anonymize)
0f941add 2044 client->state = DHCP_STATE_INIT_REBOOT;
d3d8ac2f 2045
998d8047
TG		 2046 r = client_start(client);
2047 if (r >= 0)
2f8e7633 2048 log_dhcp_client(client, "STARTED on ifindex %i", client->ifindex);
998d8047
TG		 2049
2050 return r;
46a66b79
PF		 2051}
2052
1501b429
SS		 2053int sd_dhcp_client_send_release(sd_dhcp_client *client) {
2054 assert_return(client, -EINVAL);
8ff4585f 2055 assert_return(client->state != DHCP_STATE_STOPPED, -ESTALE);
8bea7e70 2056 assert_return(client->lease, -EUNATCH);
8ff4585f
ZJS		 2057
2058 _cleanup_free_ DHCPPacket *release = NULL;
2059 size_t optoffset, optlen;
2060 int r;
2061
2062 r = client_message_init(client, &release, DHCP_RELEASE, &optlen, &optoffset);
2063 if (r < 0)
2064 return r;
2065
2066 /* Fill up release IP and MAC */
2067 release->dhcp.ciaddr = client->lease->address;
2068 memcpy(&release->dhcp.chaddr, &client->mac_addr, client->mac_addr_len);
1501b429 2069
8ff4585f
ZJS		 2070 r = dhcp_option_append(&release->dhcp, optlen, &optoffset, 0,
2071 SD_DHCP_OPTION_END, 0, NULL);
2072 if (r < 0)
2073 return r;
2074
2075 r = dhcp_network_send_udp_socket(client->fd,
2076 client->lease->server_address,
2077 DHCP_PORT_SERVER,
2078 &release->dhcp,
2079 sizeof(DHCPMessage) + optoffset);
2080 if (r < 0)
2081 return r;
2082
2083 log_dhcp_client(client, "RELEASE");
1501b429
SS		 2084
2085 return 0;
2086}
2087
0f3ff4ea
SS		 2088int sd_dhcp_client_send_decline(sd_dhcp_client *client) {
2089 assert_return(client, -EINVAL);
2090 assert_return(client->state != DHCP_STATE_STOPPED, -ESTALE);
2091 assert_return(client->lease, -EUNATCH);
2092
2093 _cleanup_free_ DHCPPacket *release = NULL;
2094 size_t optoffset, optlen;
2095 int r;
2096
2097 r = client_message_init(client, &release, DHCP_DECLINE, &optlen, &optoffset);
2098 if (r < 0)
2099 return r;
2100
2101 release->dhcp.ciaddr = client->lease->address;
2102 memcpy(&release->dhcp.chaddr, &client->mac_addr, client->mac_addr_len);
2103
2104 r = dhcp_option_append(&release->dhcp, optlen, &optoffset, 0,
2105 SD_DHCP_OPTION_END, 0, NULL);
2106 if (r < 0)
2107 return r;
2108
2109 r = dhcp_network_send_udp_socket(client->fd,
2110 client->lease->server_address,
2111 DHCP_PORT_SERVER,
2112 &release->dhcp,
2113 sizeof(DHCPMessage) + optoffset);
2114 if (r < 0)
2115 return r;
2116
2117 log_dhcp_client(client, "DECLINE");
2118
2119 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
2120
2121 if (client->state != DHCP_STATE_STOPPED) {
2122 r = sd_dhcp_client_start(client);
2123 if (r < 0)
2124 return r;
2125 }
2126
2127 return 0;
2128}
2129
5ee482df 2130int sd_dhcp_client_stop(sd_dhcp_client *client) {
574cc928
TG		 2131 DHCP_CLIENT_DONT_DESTROY(client);
2132
e5b04c8d
PF		 2133 assert_return(client, -EINVAL);
2134
03748142 2135 client_stop(client, SD_DHCP_CLIENT_EVENT_STOP);
574cc928 2136 client->state = DHCP_STATE_STOPPED;
e5b04c8d
PF		 2137
2138 return 0;
bbdf06d9
PF		 2139}
2140
32d20645 2141int sd_dhcp_client_attach_event(sd_dhcp_client *client, sd_event *event, int64_t priority) {
b25ef18b
TG		 2142 int r;
2143
2144 assert_return(client, -EINVAL);
2145 assert_return(!client->event, -EBUSY);
2146
2147 if (event)
2148 client->event = sd_event_ref(event);
2149 else {
2150 r = sd_event_default(&client->event);
2151 if (r < 0)
2152 return 0;
2153 }
2154
2155 client->event_priority = priority;
2156
2157 return 0;
2158}
2159
2160int sd_dhcp_client_detach_event(sd_dhcp_client *client) {
2161 assert_return(client, -EINVAL);
2162
2163 client->event = sd_event_unref(client->event);
2164
2165 return 0;
2166}
2167
2168sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) {
a1140666 2169 assert_return(client, NULL);
b25ef18b
TG		 2170
2171 return client->event;
2172}
2173
8301aa0b 2174static sd_dhcp_client *dhcp_client_free(sd_dhcp_client *client) {
f7af63fd
ZJS		 2175 if (!client)
2176 return NULL;
e5b04c8d 2177
3733eec3 2178 log_dhcp_client(client, "FREE");
6e00a806 2179
a3fa4287
YW		 2180 client->timeout_resend = sd_event_source_unref(client->timeout_resend);
2181 client->timeout_t1 = sd_event_source_unref(client->timeout_t1);
2182 client->timeout_t2 = sd_event_source_unref(client->timeout_t2);
2183 client->timeout_expire = sd_event_source_unref(client->timeout_expire);
3733eec3 2184
a3fa4287 2185 client_initialize(client);
3733eec3
LP		 2186
2187 sd_dhcp_client_detach_event(client);
2188
2189 sd_dhcp_lease_unref(client->lease);
2190
2191 free(client->req_opts);
2192 free(client->hostname);
2193 free(client->vendor_class_identifier);
d11d4a64 2194 free(client->mudurl);
af1c0de0 2195 client->user_class = strv_free(client->user_class);
7354900d
DW		 2196 ordered_hashmap_free(client->extra_options);
2197 ordered_hashmap_free(client->vendor_options);
6b430fdb 2198 return mfree(client);
d2fe46b5
PF		 2199}
2200
8301aa0b
YW		 2201DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_client, sd_dhcp_client, dhcp_client_free);
2202
db3d2358 2203int sd_dhcp_client_new(sd_dhcp_client **ret, int anonymize) {
b25ef18b 2204 assert_return(ret, -EINVAL);
d3d8ac2f 2205
f7af63fd 2206 _cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = new(sd_dhcp_client, 1);
011feef8 2207 if (!client)
b25ef18b 2208 return -ENOMEM;
011feef8 2209
be6bf4a7
YW		 2210 *client = (sd_dhcp_client) {
2211 .n_ref = 1,
2212 .state = DHCP_STATE_INIT,
2213 .ifindex = -1,
2214 .fd = -1,
be6bf4a7
YW		 2215 .mtu = DHCP_DEFAULT_MIN_SIZE,
2216 .port = DHCP_PORT_CLIENT,
2217 .anonymize = !!anonymize,
715cedfb 2218 .max_attempts = (uint64_t) -1,
afe42aef 2219 .ip_service_type = -1,
be6bf4a7 2220 };
db3d2358 2221 /* NOTE: this could be moved to a function. */
2222 if (anonymize) {
2223 client->req_opts_size = ELEMENTSOF(default_req_opts_anonymize);
2224 client->req_opts = memdup(default_req_opts_anonymize, client->req_opts_size);
2225 } else {
2226 client->req_opts_size = ELEMENTSOF(default_req_opts);
2227 client->req_opts = memdup(default_req_opts, client->req_opts_size);
2228 }
b25ef18b
TG		 2229 if (!client->req_opts)
2230 return -ENOMEM;
2231
1cc6c93a 2232 *ret = TAKE_PTR(client);
011feef8 2233
b25ef18b 2234 return 0;
011feef8 2235}
Unnamed repository; edit this file 'description' to name the repository.