util-lib: split out allocation calls into alloc-util.[ch]

[thirdparty/systemd.git] / src / libsystemd-network / sd-dhcp6-client.c

diff --git a/src/libsystemd-network/sd-dhcp6-client.c b/src/libsystemd-network/sd-dhcp6-client.c
index 5489c77864e3ef5814f781eccc771eac952335dc..e29de60d2489dba8fe9442d113cfcf599951dde0 100644 (file)
--- a/src/libsystemd-network/sd-dhcp6-client.c
+++ b/src/libsystemd-network/sd-dhcp6-client.c
@@ -24,17 +24,18 @@
 #include <sys/ioctl.h>
 #include <linux/if_infiniband.h>
 
-#include "udev.h"
-#include "udev-util.h"
-#include "util.h"
-#include "random-util.h"
-
-#include "network-internal.h"
 #include "sd-dhcp6-client.h"
-#include "dhcp6-protocol.h"
+
+#include "alloc-util.h"
+#include "dhcp-identifier.h"
 #include "dhcp6-internal.h"
 #include "dhcp6-lease-internal.h"
-#include "dhcp-identifier.h"
+#include "dhcp6-protocol.h"
+#include "fd-util.h"
+#include "network-internal.h"
+#include "random-util.h"
+#include "string-table.h"
+#include "util.h"
 
 #define MAX_MAC_ADDR_LEN INFINIBAND_ALEN
 
@@ -125,6 +126,8 @@ int sd_dhcp6_client_set_index(sd_dhcp6_client *client, int interface_index) {
         assert_return(client, -EINVAL);
         assert_return(interface_index >= -1, -EINVAL);
 
+        assert_return(IN_SET(client->state, DHCP6_STATE_STOPPED), -EBUSY);
+
         client->index = interface_index;
 
         return 0;
@@ -140,6 +143,8 @@ int sd_dhcp6_client_set_mac(
         assert_return(addr_len > 0 && addr_len <= MAX_MAC_ADDR_LEN, -EINVAL);
         assert_return(arp_type > 0, -EINVAL);
 
+        assert_return(IN_SET(client->state, DHCP6_STATE_STOPPED), -EBUSY);
+
         if (arp_type == ARPHRD_ETHER)
                 assert_return(addr_len == ETH_ALEN, -EINVAL);
         else if (arp_type == ARPHRD_INFINIBAND)
@@ -173,6 +178,8 @@ int sd_dhcp6_client_set_duid(
         assert_return(duid, -EINVAL);
         assert_return(duid_len > 0 && duid_len <= MAX_DUID_LEN, -EINVAL);
 
+        assert_return(IN_SET(client->state, DHCP6_STATE_STOPPED), -EBUSY);
+
         switch (type) {
         case DHCP6_DUID_LLT:
                 if (duid_len <= sizeof(client->duid.llt))
@@ -202,15 +209,16 @@ int sd_dhcp6_client_set_duid(
         return 0;
 }
 
-int sd_dhcp6_client_set_information_request(sd_dhcp6_client *client, bool enabled) {
+int sd_dhcp6_client_set_information_request(sd_dhcp6_client *client, int enabled) {
         assert_return(client, -EINVAL);
+        assert_return(IN_SET(client->state, DHCP6_STATE_STOPPED), -EBUSY);
 
         client->information_request = enabled;
 
         return 0;
 }
 
-int sd_dhcp6_client_get_information_request(sd_dhcp6_client *client, bool *enabled) {
+int sd_dhcp6_client_get_information_request(sd_dhcp6_client *client, int *enabled) {
         assert_return(client, -EINVAL);
         assert_return(enabled, -EINVAL);
 
@@ -266,13 +274,18 @@ static void client_notify(sd_dhcp6_client *client, int event) {
                 client->cb(client, event, client->userdata);
 }
 
-static int client_reset(sd_dhcp6_client *client) {
-        assert_return(client, -EINVAL);
-
+static void client_set_lease(sd_dhcp6_client *client, sd_dhcp6_lease *lease) {
         if (client->lease) {
                 dhcp6_lease_clear_timers(&client->lease->ia);
-                client->lease = sd_dhcp6_lease_unref(client->lease);
+                sd_dhcp6_lease_unref(client->lease);
         }
+        client->lease = lease;
+}
+
+static int client_reset(sd_dhcp6_client *client) {
+        assert_return(client, -EINVAL);
+
+        client_set_lease(client, NULL);
 
         client->receive_message =
                 sd_event_source_unref(client->receive_message);
@@ -464,7 +477,7 @@ static int client_timeout_resend_expire(sd_event_source *s, uint64_t usec,
 
         state = client->state;
 
-        client_stop(client, DHCP6_EVENT_RESEND_EXPIRE);
+        client_stop(client, SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE);
 
         /* RFC 3315, section 18.1.4., says that "...the client may choose to
            use a Solicit message to locate a new DHCP server..." */
@@ -554,7 +567,7 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec,
 
         if (max_retransmit_count &&
             client->retransmit_count >= max_retransmit_count) {
-                client_stop(client, DHCP6_EVENT_RETRANS_MAX);
+                client_stop(client, SD_DHCP6_CLIENT_EVENT_RETRANS_MAX);
                 return 0;
         }
 
@@ -582,8 +595,7 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec,
         }
 
         log_dhcp6_client(client, "Next retransmission in %s",
-                         format_timespan(time_string, FORMAT_TIMESPAN_MAX,
-                                         client->retransmit_time, 0));
+                         format_timespan(time_string, FORMAT_TIMESPAN_MAX, client->retransmit_time, USEC_PER_SEC));
 
         r = sd_event_add_time(client->event, &client->timeout_resend,
                               clock_boottime_or_monotonic(),
@@ -826,12 +838,7 @@ static int client_receive_reply(sd_dhcp6_client *client, DHCP6Message *reply, si
                         return 0;
         }
 
-        if (client->lease) {
-                dhcp6_lease_clear_timers(&client->lease->ia);
-                client->lease = sd_dhcp6_lease_unref(client->lease);
-        }
-
-        client->lease = lease;
+        client_set_lease(client, lease);
         lease = NULL;
 
         return DHCP6_STATE_BOUND;
@@ -860,8 +867,7 @@ static int client_receive_advertise(sd_dhcp6_client *client, DHCP6Message *adver
         r = dhcp6_lease_get_preference(client->lease, &pref_lease);
 
         if (r < 0 || pref_advertise > pref_lease) {
-                sd_dhcp6_lease_unref(client->lease);
-                client->lease = lease;
+                client_set_lease(client, lease);
                 lease = NULL;
                 r = 0;
         }
@@ -930,7 +936,7 @@ static int client_receive_message(sd_event_source *s, int fd, uint32_t revents,
                 if (r < 0)
                         return 0;
 
-                client_notify(client, DHCP6_EVENT_INFORMATION_REQUEST);
+                client_notify(client, SD_DHCP6_CLIENT_EVENT_INFORMATION_REQUEST);
 
                 client_start(client, DHCP6_STATE_STOPPED);
 
@@ -962,7 +968,7 @@ static int client_receive_message(sd_event_source *s, int fd, uint32_t revents,
                                 return 0;
                         }
 
-                        client_notify(client, DHCP6_EVENT_IP_ACQUIRE);
+                        client_notify(client, SD_DHCP6_CLIENT_EVENT_IP_ACQUIRE);
                 }
 
                 break;
@@ -1041,9 +1047,7 @@ static int client_start(sd_dhcp6_client *client, enum DHCP6State state) {
                 timeout = client_timeout_compute_random(be32toh(client->lease->ia.lifetime_t1) * USEC_PER_SEC);
 
                 log_dhcp6_client(client, "T1 expires in %s",
-                                 format_timespan(time_string,
-                                                 FORMAT_TIMESPAN_MAX,
-                                                 timeout, 0));
+                                 format_timespan(time_string, FORMAT_TIMESPAN_MAX, timeout, USEC_PER_SEC));
 
                 r = sd_event_add_time(client->event,
                                       &client->lease->ia.timeout_t1,
@@ -1065,9 +1069,7 @@ static int client_start(sd_dhcp6_client *client, enum DHCP6State state) {
                 timeout = client_timeout_compute_random(be32toh(client->lease->ia.lifetime_t2) * USEC_PER_SEC);
 
                 log_dhcp6_client(client, "T2 expires in %s",
-                                 format_timespan(time_string,
-                                                 FORMAT_TIMESPAN_MAX,
-                                                 timeout, 0));
+                                 format_timespan(time_string, FORMAT_TIMESPAN_MAX, timeout, USEC_PER_SEC));
 
                 r = sd_event_add_time(client->event,
                                       &client->lease->ia.timeout_t2,
@@ -1113,7 +1115,7 @@ static int client_start(sd_dhcp6_client *client, enum DHCP6State state) {
 }
 
 int sd_dhcp6_client_stop(sd_dhcp6_client *client) {
-        client_stop(client, DHCP6_EVENT_STOP);
+        client_stop(client, SD_DHCP6_CLIENT_EVENT_STOP);
 
         return 0;
 }
@@ -1126,6 +1128,9 @@ int sd_dhcp6_client_start(sd_dhcp6_client *client) {
         assert_return(client->event, -EINVAL);
         assert_return(client->index > 0, -EINVAL);
 
+        if (!IN_SET(client->state, DHCP6_STATE_STOPPED))
+                return -EALREADY;
+
         r = client_reset(client);
         if (r < 0)
                 return r;
@@ -1233,7 +1238,6 @@ sd_dhcp6_client *sd_dhcp6_client_unref(sd_dhcp6_client *client) {
         client_reset(client);
 
         sd_dhcp6_client_detach_event(client);
-        sd_dhcp6_lease_unref(client->lease);
 
         free(client->req_opts);
         free(client);