morgan/systemd
1
0
Fork 0
mirror of https://github.com/morgan9e/systemd synced 2026-04-14 00:14:32 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #29091 from yuwata/sd-dhcp-client-use-usec

Browse Source 
sd-dhcp-client: use usec_t for time values
This commit is contained in:
Luca Boccassi
2023-09-05 22:23:06 +01:00
committed by GitHub
parent 0f9a2b802b 0ad8d953de
commit d5bfee578c
13 changed files with 163 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/basic/time-util.c
View File

@@ -156,6 +156,25 @@ triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u)
return ts;
}
triple_timestamp* triple_timestamp_from_boottime(triple_timestamp *ts, usec_t u) {
usec_t nowb;
assert(ts);
if (u == USEC_INFINITY) {
ts->realtime = ts->monotonic = ts->boottime = u;
return ts;
}
nowb = now(CLOCK_BOOTTIME);
ts->boottime = u;
ts->monotonic = map_clock_usec_internal(u, nowb, now(CLOCK_MONOTONIC));
ts->realtime = map_clock_usec_internal(u, nowb, now(CLOCK_REALTIME));
return ts;
}
dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
assert(ts);

1
src/basic/time-util.h
View File

@@ -86,6 +86,7 @@ dual_timestamp* dual_timestamp_from_boottime(dual_timestamp *ts, usec_t u);
triple_timestamp* triple_timestamp_get(triple_timestamp *ts);
triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u);
triple_timestamp* triple_timestamp_from_boottime(triple_timestamp *ts, usec_t u);
#define DUAL_TIMESTAMP_HAS_CLOCK(clock) \
IN_SET(clock, CLOCK_REALTIME, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC)

8
src/libsystemd-network/dhcp-lease-internal.h
View File

@@ -10,6 +10,7 @@
#include "dhcp-internal.h"
#include "dhcp-protocol.h"
#include "list.h"
#include "time-util.h"
struct sd_dhcp_route {
struct in_addr dst_addr;
@@ -29,9 +30,10 @@ struct sd_dhcp_lease {
unsigned n_ref;
/* each 0 if unset */
uint32_t t1;
uint32_t t2;
uint32_t lifetime;
usec_t t1;
usec_t t2;
usec_t lifetime;
triple_timestamp timestamp;
/* each 0 if unset */
be32_t address;

42
src/libsystemd-network/sd-dhcp-client.c
View File

@@ -102,7 +102,7 @@ struct sd_dhcp_client {
char *mudurl;
char **user_class;
uint32_t mtu;
uint32_t fallback_lease_lifetime;
usec_t fallback_lease_lifetime;
uint32_t xid;
usec_t start_time;
usec_t t1_time;
@@ -716,18 +716,6 @@ int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) {
return 0;
}
int sd_dhcp_client_get_lease_timestamp(sd_dhcp_client *client, uint64_t *timestamp) {
assert_return(client, -EINVAL);
if (!IN_SET(client->state, DHCP_STATE_BOUND, DHCP_STATE_RENEWING, DHCP_STATE_REBINDING))
return -ENODATA;
if(timestamp)
*timestamp = client->request_sent;
return 0;
}
int sd_dhcp_client_set_service_type(sd_dhcp_client *client, int type) {
assert_return(client, -EINVAL);
assert_return(!sd_dhcp_client_is_running(client), -EBUSY);
@@ -747,11 +735,12 @@ int sd_dhcp_client_set_socket_priority(sd_dhcp_client *client, int socket_priori
return 0;
}
int sd_dhcp_client_set_fallback_lease_lifetime(sd_dhcp_client *client, uint32_t fallback_lease_lifetime) {
int sd_dhcp_client_set_fallback_lease_lifetime(sd_dhcp_client *client, uint64_t fallback_lease_lifetime) {
assert_return(client, -EINVAL);
assert_return(!sd_dhcp_client_is_running(client), -EBUSY);
assert_return(fallback_lease_lifetime > 0, -EINVAL);
assert_cc(sizeof(usec_t) == sizeof(uint64_t));
client->fallback_lease_lifetime = fallback_lease_lifetime;
return 0;
@@ -1290,8 +1279,7 @@ static int client_timeout_resend(
sd_dhcp_client *client = ASSERT_PTR(userdata);
DHCP_CLIENT_DONT_DESTROY(client);
usec_t next_timeout;
uint64_t time_now;
usec_t time_now, next_timeout;
int r;
assert(s);
@@ -1439,7 +1427,7 @@ error:
}
static int client_initialize_time_events(sd_dhcp_client *client) {
uint64_t usec = 0;
usec_t usec = 0;
int r;
assert(client);
@@ -1447,7 +1435,7 @@ static int client_initialize_time_events(sd_dhcp_client *client) {
if (client->start_delay > 0) {
assert_se(sd_event_now(client->event, CLOCK_BOOTTIME, &usec) >= 0);
usec += client->start_delay;
usec = usec_add(usec, client->start_delay);
}
r = event_reset_time(client->event, &client->timeout_resend,
@@ -1725,10 +1713,12 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
assert(client);
assert(client->event);
assert(client->lease);
assert(client->lease->lifetime);
assert(client->lease->lifetime > 0);
triple_timestamp_from_boottime(&client->lease->timestamp, client->request_sent);
/* don't set timers for infinite leases */
if (client->lease->lifetime == 0xffffffff) {
if (client->lease->lifetime == USEC_INFINITY) {
(void) event_source_disable(client->timeout_t1);
(void) event_source_disable(client->timeout_t2);
(void) event_source_disable(client->timeout_expire);
@@ -1748,14 +1738,18 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
if (client->lease->t1 == 0 || client->lease->t1 >= client->lease->t2)
client->lease->t1 = T1_DEFAULT(client->lease->lifetime);
/* now, if t1 >= t2, t1 *must* be T1_DEFAULT, since the previous check
* could not evalate to false if t1 >= t2; so setting t2 to T2_DEFAULT
* could not evaluate to false if t1 >= t2; so setting t2 to T2_DEFAULT
* guarantees t1 < t2. */
if (client->lease->t1 >= client->lease->t2)
client->lease->t2 = T2_DEFAULT(client->lease->lifetime);
client->expire_time = client->request_sent + client->lease->lifetime * USEC_PER_SEC;
client->t1_time = client->request_sent + client->lease->t1 * USEC_PER_SEC;
client->t2_time = client->request_sent + client->lease->t2 * USEC_PER_SEC;
assert(client->lease->t1 > 0);
assert(client->lease->t1 < client->lease->t2);
assert(client->lease->t2 < client->lease->lifetime);
client->expire_time = usec_add(client->request_sent, client->lease->lifetime);
client->t1_time = usec_add(client->request_sent, client->lease->t1);
client->t2_time = usec_add(client->request_sent, client->lease->t2);
/* RFC2131 section 4.4.5:
* Times T1 and T2 SHOULD be chosen with some random "fuzz".

108
src/libsystemd-network/sd-dhcp-lease.c
View File

@@ -29,9 +29,23 @@
#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
#include "tmpfile-util.h"
#include "unaligned.h"
int sd_dhcp_lease_get_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret) {
assert_return(lease, -EINVAL);
assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
assert_return(clock_supported(clock), -EOPNOTSUPP);
assert_return(ret, -EINVAL);
if (!triple_timestamp_is_set(&lease->timestamp))
return -ENODATA;
*ret = triple_timestamp_by_clock(&lease->timestamp, clock);
return 0;
}
int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr) {
assert_return(lease, -EINVAL);
assert_return(addr, -EINVAL);
@@ -54,39 +68,66 @@ int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr) {
return 0;
}
int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime) {
int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint64_t *ret) {
assert_return(lease, -EINVAL);
assert_return(lifetime, -EINVAL);
assert_return(ret, -EINVAL);
if (lease->lifetime <= 0)
return -ENODATA;
*lifetime = lease->lifetime;
*ret = lease->lifetime;
return 0;
}
int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1) {
int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint64_t *ret) {
assert_return(lease, -EINVAL);
assert_return(t1, -EINVAL);
assert_return(ret, -EINVAL);
if (lease->t1 <= 0)
return -ENODATA;
*t1 = lease->t1;
*ret = lease->t1;
return 0;
}
int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2) {
int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint64_t *ret) {
assert_return(lease, -EINVAL);
assert_return(t2, -EINVAL);
assert_return(ret, -EINVAL);
if (lease->t2 <= 0)
return -ENODATA;
*t2 = lease->t2;
*ret = lease->t2;
return 0;
}
#define DEFINE_GET_TIMESTAMP(name) \
int sd_dhcp_lease_get_##name##_timestamp( \
sd_dhcp_lease *lease, \
clockid_t clock, \
uint64_t *ret) { \
\
usec_t t, timestamp; \
int r; \
\
assert_return(ret, -EINVAL); \
\
r = sd_dhcp_lease_get_##name(lease, &t); \
if (r < 0) \
return r; \
\
r = sd_dhcp_lease_get_timestamp(lease, clock, &timestamp); \
if (r < 0) \
return r; \
\
*ret = usec_add(t, timestamp); \
return 0; \
}
DEFINE_GET_TIMESTAMP(lifetime);
DEFINE_GET_TIMESTAMP(t1);
DEFINE_GET_TIMESTAMP(t2);
int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
assert_return(lease, -EINVAL);
assert_return(mtu, -EINVAL);
@@ -331,6 +372,10 @@ int sd_dhcp_lease_get_6rd(
return 0;
}
int sd_dhcp_lease_has_6rd(sd_dhcp_lease *lease) {
return lease && lease->sixrd_n_br_addresses > 0;
}
int sd_dhcp_lease_get_vendor_specific(sd_dhcp_lease *lease, const void **data, size_t *data_len) {
assert_return(lease, -EINVAL);
assert_return(data, -EINVAL);
@@ -389,6 +434,25 @@ static int lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uin
return 0;
}
static int lease_parse_u32_seconds(const uint8_t *option, size_t len, usec_t *ret) {
uint32_t val;
int r;
assert(option);
assert(ret);
r = lease_parse_u32(option, len, &val, 1);
if (r < 0)
return r;
if (val == UINT32_MAX)
*ret = USEC_INFINITY;
else
*ret = val * USEC_PER_SEC;
return 0;
}
static int lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
assert(option);
assert(ret);
@@ -658,7 +722,7 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
switch (code) {
case SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
r = lease_parse_u32(option, len, &lease->lifetime, 1);
r = lease_parse_u32_seconds(option, len, &lease->lifetime);
if (r < 0)
log_debug_errno(r, "Failed to parse lease time, ignoring: %m");
@@ -783,13 +847,13 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
break;
case SD_DHCP_OPTION_RENEWAL_TIME:
r = lease_parse_u32(option, len, &lease->t1, 1);
r = lease_parse_u32_seconds(option, len, &lease->t1);
if (r < 0)
log_debug_errno(r, "Failed to parse T1 time, ignoring: %m");
break;
case SD_DHCP_OPTION_REBINDING_TIME:
r = lease_parse_u32(option, len, &lease->t2, 1);
r = lease_parse_u32_seconds(option, len, &lease->t2);
if (r < 0)
log_debug_errno(r, "Failed to parse T2 time, ignoring: %m");
break;
@@ -1002,7 +1066,7 @@ int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
uint16_t mtu;
_cleanup_free_ sd_dhcp_route **routes = NULL;
char **search_domains;
uint32_t t1, t2, lifetime;
usec_t t;
int r;
assert(lease);
@@ -1048,17 +1112,17 @@ int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
if (r >= 0)
fprintf(f, "MTU=%" PRIu16 "\n", mtu);
r = sd_dhcp_lease_get_t1(lease, &t1);
r = sd_dhcp_lease_get_t1(lease, &t);
if (r >= 0)
fprintf(f, "T1=%" PRIu32 "\n", t1);
fprintf(f, "T1=%s\n", FORMAT_TIMESPAN(t, USEC_PER_SEC));
r = sd_dhcp_lease_get_t2(lease, &t2);
r = sd_dhcp_lease_get_t2(lease, &t);
if (r >= 0)
fprintf(f, "T2=%" PRIu32 "\n", t2);
fprintf(f, "T2=%s\n", FORMAT_TIMESPAN(t, USEC_PER_SEC));
r = sd_dhcp_lease_get_lifetime(lease, &lifetime);
r = sd_dhcp_lease_get_lifetime(lease, &t);
if (r >= 0)
fprintf(f, "LIFETIME=%" PRIu32 "\n", lifetime);
fprintf(f, "LIFETIME=%s\n", FORMAT_TIMESPAN(t, USEC_PER_SEC));
r = sd_dhcp_lease_get_dns(lease, &addresses);
if (r > 0) {
@@ -1390,19 +1454,19 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
}
if (lifetime) {
r = safe_atou32(lifetime, &lease->lifetime);
r = parse_sec(lifetime, &lease->lifetime);
if (r < 0)
log_debug_errno(r, "Failed to parse lifetime %s, ignoring: %m", lifetime);
}
if (t1) {
r = safe_atou32(t1, &lease->t1);
r = parse_sec(t1, &lease->t1);
if (r < 0)
log_debug_errno(r, "Failed to parse T1 %s, ignoring: %m", t1);
}
if (t2) {
r = safe_atou32(t2, &lease->t2);
r = parse_sec(t2, &lease->t2);
if (r < 0)
log_debug_errno(r, "Failed to parse T2 %s, ignoring: %m", t2);
}

28
src/network/networkd-dhcp-prefix-delegation.c
View File

@@ -51,13 +51,6 @@ bool dhcp_pd_is_uplink(Link *link, Link *target, bool accept_auto) {
return accept_auto;
}
bool dhcp4_lease_has_pd_prefix(sd_dhcp_lease *lease) {
if (!lease)
return false;
return sd_dhcp_lease_get_6rd(lease, NULL, NULL, NULL, NULL, NULL) >= 0;
}
bool dhcp6_lease_has_pd_prefix(sd_dhcp6_lease *lease) {
uint32_t lifetime_preferred_sec, lifetime_valid_sec;
struct in6_addr pd_prefix;
@@ -855,8 +848,7 @@ static int dhcp4_pd_assign_subnet_prefix(Link *link, Link *uplink) {
struct in6_addr sixrd_prefix, pd_prefix;
const struct in_addr *br_addresses;
struct in_addr ipv4address;
uint32_t lifetime_sec;
usec_t lifetime_usec, now_usec;
usec_t lifetime_usec;
int r;
assert(link);
@@ -868,13 +860,10 @@ static int dhcp4_pd_assign_subnet_prefix(Link *link, Link *uplink) {
if (r < 0)
return log_link_warning_errno(uplink, r, "Failed to get DHCPv4 address: %m");
r = sd_dhcp_lease_get_lifetime(uplink->dhcp_lease, &lifetime_sec);
r = sd_dhcp_lease_get_lifetime_timestamp(uplink->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
if (r < 0)
return log_link_warning_errno(uplink, r, "Failed to get lifetime of DHCPv4 lease: %m");
assert_se(sd_event_now(uplink->manager->event, CLOCK_BOOTTIME, &now_usec) >= 0);
lifetime_usec = sec_to_usec(lifetime_sec, now_usec);
r = sd_dhcp_lease_get_6rd(uplink->dhcp_lease, &ipv4masklen, &sixrd_prefixlen, &sixrd_prefix, &br_addresses, NULL);
if (r < 0)
return log_link_warning_errno(uplink, r, "Failed to get DHCPv4 6rd option: %m");
@@ -929,8 +918,7 @@ int dhcp4_pd_prefix_acquired(Link *uplink) {
struct in_addr ipv4address;
union in_addr_union server_address;
const struct in_addr *br_addresses;
uint32_t lifetime_sec;
usec_t lifetime_usec, now_usec;
usec_t lifetime_usec;
Link *link;
int r;
@@ -942,13 +930,10 @@ int dhcp4_pd_prefix_acquired(Link *uplink) {
if (r < 0)
return log_link_warning_errno(uplink, r, "Failed to get DHCPv4 address: %m");
r = sd_dhcp_lease_get_lifetime(uplink->dhcp_lease, &lifetime_sec);
r = sd_dhcp_lease_get_lifetime_timestamp(uplink->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
if (r < 0)
return log_link_warning_errno(uplink, r, "Failed to get lifetime of DHCPv4 lease: %m");
assert_se(sd_event_now(uplink->manager->event, CLOCK_BOOTTIME, &now_usec) >= 0);
lifetime_usec = sec_to_usec(lifetime_sec, now_usec);
r = sd_dhcp_lease_get_server_identifier(uplink->dhcp_lease, &server_address.in);
if (r < 0)
return log_link_warning_errno(uplink, r, "Failed to get server address of DHCPv4 lease: %m");
@@ -1148,10 +1133,7 @@ static bool dhcp4_pd_uplink_is_ready(Link *link) {
if (sd_dhcp_client_is_running(link->dhcp_client) <= 0)
return false;
if (!link->dhcp_lease)
return false;
return dhcp4_lease_has_pd_prefix(link->dhcp_lease);
return sd_dhcp_lease_has_6rd(link->dhcp_lease);
}
static bool dhcp6_pd_uplink_is_ready(Link *link) {

1
src/network/networkd-dhcp-prefix-delegation.h
View File

@@ -13,7 +13,6 @@ typedef struct Link Link;
bool link_dhcp_pd_is_enabled(Link *link);
bool dhcp_pd_is_uplink(Link *link, Link *target, bool accept_auto);
int dhcp_pd_find_uplink(Link *link, Link **ret);
bool dhcp4_lease_has_pd_prefix(sd_dhcp_lease *lease);
bool dhcp6_lease_has_pd_prefix(sd_dhcp6_lease *lease);
int dhcp_pd_remove(Link *link, bool only_marked);
int dhcp_request_prefix_delegation(Link *link);

26
src/network/networkd-dhcp4.c
View File

@@ -839,7 +839,7 @@ int dhcp4_lease_lost(Link *link) {
link->dhcp4_configured = false;
if (link->network->dhcp_use_6rd &&
dhcp4_lease_has_pd_prefix(link->dhcp_lease))
sd_dhcp_lease_has_6rd(link->dhcp_lease))
dhcp4_pd_prefix_lost(link);
k = dhcp4_remove_address_and_routes(link, /* only_marked = */ false);
@@ -910,15 +910,9 @@ static int dhcp4_request_address(Link *link, bool announce) {
return log_link_debug_errno(link, r, "DHCP error: failed to get DHCP server IP address: %m");
if (!FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP)) {
uint32_t lifetime_sec;
usec_t now_usec;
r = sd_dhcp_lease_get_lifetime(link->dhcp_lease, &lifetime_sec);
r = sd_dhcp_lease_get_lifetime_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &lifetime_usec);
if (r < 0)
return log_link_warning_errno(link, r, "DHCP error: no lifetime: %m");
assert_se(sd_event_now(link->manager->event, CLOCK_BOOTTIME, &now_usec) >= 0);
lifetime_usec = sec_to_usec(lifetime_sec, now_usec);
return log_link_warning_errno(link, r, "DHCP error: failed to get lifetime: %m");
} else
lifetime_usec = USEC_INFINITY;
@@ -1033,11 +1027,11 @@ static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
link_dirty(link);
if (link->network->dhcp_use_6rd) {
if (dhcp4_lease_has_pd_prefix(link->dhcp_lease)) {
if (sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
r = dhcp4_pd_prefix_acquired(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
} else if (dhcp4_lease_has_pd_prefix(old_lease))
} else if (sd_dhcp_lease_has_6rd(old_lease))
dhcp4_pd_prefix_lost(link);
}
@@ -1107,7 +1101,7 @@ static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
}
if (link->network->dhcp_use_6rd &&
dhcp4_lease_has_pd_prefix(link->dhcp_lease)) {
sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
r = dhcp4_pd_prefix_acquired(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to process 6rd option: %m");
@@ -1617,8 +1611,8 @@ static int dhcp4_configure(Link *link) {
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set socket priority: %m");
}
if (link->network->dhcp_fallback_lease_lifetime > 0) {
r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime);
if (link->network->dhcp_fallback_lease_lifetime_usec > 0) {
r = sd_dhcp_client_set_fallback_lease_lifetime(link->dhcp_client, link->network->dhcp_fallback_lease_lifetime_usec);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed set to lease lifetime: %m");
}
@@ -1877,7 +1871,7 @@ int config_parse_dhcp_fallback_lease_lifetime(
assert(data);
if (isempty(rvalue)) {
network->dhcp_fallback_lease_lifetime = 0;
network->dhcp_fallback_lease_lifetime_usec = 0;
return 0;
}
@@ -1888,7 +1882,7 @@ int config_parse_dhcp_fallback_lease_lifetime(
return 0;
}
network->dhcp_fallback_lease_lifetime = UINT32_MAX;
network->dhcp_fallback_lease_lifetime_usec = USEC_INFINITY;
return 0;
}

19
src/network/networkd-json.c
View File

@@ -1131,8 +1131,7 @@ static int dhcp6_client_append_json(Link *link, JsonVariant **v) {
static int dhcp_client_lease_append_json(Link *link, JsonVariant **v) {
_cleanup_(json_variant_unrefp) JsonVariant *w = NULL;
uint32_t t1, t2;
uint64_t lease_timestamp_usec;
usec_t lease_timestamp_usec, t1, t2;
int r;
assert(link);
@@ -1141,24 +1140,22 @@ static int dhcp_client_lease_append_json(Link *link, JsonVariant **v) {
if (!link->dhcp_client || !link->dhcp_lease)
return 0;
r = sd_dhcp_lease_get_t1(link->dhcp_lease, &t1);
r = sd_dhcp_lease_get_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &lease_timestamp_usec);
if (r < 0)
return 0;
r = sd_dhcp_lease_get_t2(link->dhcp_lease, &t2);
r = sd_dhcp_lease_get_t1_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &t1);
if (r < 0)
return 0;
r = sd_dhcp_client_get_lease_timestamp(link->dhcp_client, &lease_timestamp_usec);
r = sd_dhcp_lease_get_t2_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &t2);
if (r < 0)
return 0;
r = json_build(&w, JSON_BUILD_OBJECT(
JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec",
sec_to_usec(t1, lease_timestamp_usec)),
JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec",
sec_to_usec(t2, lease_timestamp_usec)),
JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", lease_timestamp_usec)));
JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", lease_timestamp_usec),
JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec", t1),
JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec", t2)));
if (r < 0)
return r;
@@ -1177,7 +1174,7 @@ static int dhcp_client_pd_append_json(Link *link, JsonVariant **v) {
assert(link->network);
assert(v);
if (!link->network->dhcp_use_6rd || !link->dhcp_lease || !dhcp4_lease_has_pd_prefix(link->dhcp_lease))
if (!link->network->dhcp_use_6rd || !sd_dhcp_lease_has_6rd(link->dhcp_lease))
return 0;
r = sd_dhcp_lease_get_6rd(link->dhcp_lease, &ipv4masklen, &sixrd_prefixlen, &sixrd_prefix, &br_addresses, &n_br_addresses);

2
src/network/networkd-link.c
View File

@@ -477,7 +477,7 @@ void link_check_ready(Link *link) {
/* If the uplink for PD is self, then request the corresponding DHCP protocol is also ready. */
if (dhcp_pd_is_uplink(link, link, /* accept_auto = */ false)) {
if (link_dhcp4_enabled(link) && link->network->dhcp_use_6rd &&
link->dhcp_lease && dhcp4_lease_has_pd_prefix(link->dhcp_lease)) {
sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
if (!dhcp4_ready)
return (void) log_link_debug(link, "%s(): DHCPv4 6rd prefix is assigned, but DHCPv4 protocol is not finished yet.", __func__);
if (!dhcp_pd_ready)

2
src/network/networkd-network.h
View File

@@ -127,7 +127,7 @@ struct Network {
bool dhcp_route_metric_set;
uint32_t dhcp_route_table;
bool dhcp_route_table_set;
uint32_t dhcp_fallback_lease_lifetime;
usec_t dhcp_fallback_lease_lifetime_usec;
uint32_t dhcp_route_mtu;
uint16_t dhcp_client_port;
int dhcp_critical;

3
src/systemd/sd-dhcp-client.h
View File

@@ -318,7 +318,7 @@ int sd_dhcp_client_set_socket_priority(
int so_priority);
int sd_dhcp_client_set_fallback_lease_lifetime(
sd_dhcp_client *client,
uint32_t fallback_lease_lifetime);
uint64_t fallback_lease_lifetime);
int sd_dhcp_client_add_option(sd_dhcp_client *client, sd_dhcp_option *v);
int sd_dhcp_client_add_vendor_option(sd_dhcp_client *client, sd_dhcp_option *v);
@@ -329,7 +329,6 @@ int sd_dhcp_client_start(sd_dhcp_client *client);
int sd_dhcp_client_send_release(sd_dhcp_client *client);
int sd_dhcp_client_send_decline(sd_dhcp_client *client);
int sd_dhcp_client_send_renew(sd_dhcp_client *client);
int sd_dhcp_client_get_lease_timestamp(sd_dhcp_client *client, uint64_t *timestamp);
sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client);
sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client);

11
src/systemd/sd-dhcp-lease.h
View File

@@ -47,9 +47,13 @@ __extension__ typedef enum sd_dhcp_lease_server_type_t {
} sd_dhcp_lease_server_type_t;
int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime);
int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1);
int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2);
int sd_dhcp_lease_get_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint64_t *ret);
int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint64_t *ret);
int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint64_t *ret);
int sd_dhcp_lease_get_lifetime_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
int sd_dhcp_lease_get_t1_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
int sd_dhcp_lease_get_t2_timestamp(sd_dhcp_lease *lease, clockid_t clock, uint64_t *ret);
int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_prefix(sd_dhcp_lease *lease, struct in_addr *ret_prefix, uint8_t *ret_prefixlen);
@@ -81,6 +85,7 @@ int sd_dhcp_lease_get_6rd(
struct in6_addr *ret_prefix,
const struct in_addr **ret_br_addresses,
size_t *ret_n_br_addresses);
int sd_dhcp_lease_has_6rd(sd_dhcp_lease *lease);
int sd_dhcp_route_get_destination(sd_dhcp_route *route, struct in_addr *destination);
int sd_dhcp_route_get_destination_prefix_length(sd_dhcp_route *route, uint8_t *length);