sd-dhcp: clean-up of DHCP lease server code

This is an attempt to clean-up the DHCP lease server type code a bit. We
now strictly use the same enum everywhere, and store server info in an
array. Moreover, we use the same nomenclature everywhere.

This only makes the changes in the sd-dhcp code. The networkd code is
untouched so far (but should be fixed up like this too. But it's more
complicated since this would then touch actual settings in .network
files).

Note that this also changes some field names in serialized lease files.
But given that these field names have not been part of a released
version of systemd yet, such a change should be ok.

This is pure renaming/refactoring, shouldn't actually change any
behaviour.

diff --git a/src/libsystemd-network/dhcp-internal.h b/src/libsystemd-network/dhcp-internal.h
index 6a803d7b05d5411ee94867815c50e80b596fe682..7e8149487a8d03cd71ae7072a669655711f752f9 100644 (file)
--- a/src/libsystemd-network/dhcp-internal.h
+++ b/src/libsystemd-network/dhcp-internal.h
@@ -7,7 +7,6 @@
 
 #include <linux/if_packet.h>
 #include <net/ethernet.h>
-#include <net/if_arp.h>
 #include <stdint.h>
 
 #include "sd-dhcp-client.h"
@@ -23,6 +22,11 @@ typedef struct sd_dhcp_option {
         size_t length;
 } sd_dhcp_option;
 
+typedef struct DHCPServerData {
+        struct in_addr *addr;
+        size_t size;
+} DHCPServerData;
+
 extern const struct hash_ops dhcp_option_hash_ops;
 
 int dhcp_network_bind_raw_socket(int ifindex, union sockaddr_union *link,

diff --git a/src/libsystemd-network/dhcp-lease-internal.h b/src/libsystemd-network/dhcp-lease-internal.h
index 67a77eb098c8ebbace3b0267e2d2a6979fea0ca9..aed30d6118b0e034a865f69f2538f31f77acb1fd 100644 (file)
--- a/src/libsystemd-network/dhcp-lease-internal.h
+++ b/src/libsystemd-network/dhcp-lease-internal.h
@@ -5,11 +5,9 @@
   Copyright © 2013 Intel Corporation. All rights reserved.
 ***/
 
-#include <stdint.h>
-#include <linux/if_packet.h>
-
 #include "sd-dhcp-client.h"
 
+#include "dhcp-internal.h"
 #include "dhcp-protocol.h"
 #include "list.h"
 #include "util.h"
@@ -52,23 +50,7 @@ struct sd_dhcp_lease {
         struct in_addr *router;
         size_t router_size;
 
-        struct in_addr *dns;
-        size_t dns_size;
-
-        struct in_addr *ntp;
-        size_t ntp_size;
-
-        struct in_addr *sip;
-        size_t sip_size;
-
-        struct in_addr *pop3_server;
-        size_t pop3_server_size;
-
-        struct in_addr *smtp_server;
-        size_t smtp_server_size;
-
-        struct in_addr *lpr_server;
-        size_t lpr_server_size;
+        DHCPServerData servers[_SD_DHCP_LEASE_SERVER_TYPE_MAX];
 
         struct sd_dhcp_route *static_route;
         size_t static_route_size, static_route_allocated;

diff --git a/src/libsystemd-network/dhcp-server-internal.h b/src/libsystemd-network/dhcp-server-internal.h
index fb42f2f80c92d76d0bf7bc763382c4f34d67bf0e..39899680a5756136a1828e585de8b1c0f0a14af0 100644 (file)
--- a/src/libsystemd-network/dhcp-server-internal.h
+++ b/src/libsystemd-network/dhcp-server-internal.h
@@ -56,8 +56,7 @@ struct sd_dhcp_server {
 
         char *timezone;
 
-        struct in_addr *ntp, *dns, *sip, *pop3_server, *smtp_server, *lpr_server;
-        size_t n_ntp, n_dns, n_sip, n_pop3_server, n_smtp_server, n_lpr_server;
+        DHCPServerData servers[_SD_DHCP_LEASE_SERVER_TYPE_MAX];
 
         OrderedHashmap *extra_options;
         OrderedHashmap *vendor_options;

diff --git a/src/libsystemd-network/sd-dhcp-lease.c b/src/libsystemd-network/sd-dhcp-lease.c
index 3b02530e242f0d76c3fae391caabb6de7fc9e92b..8582302cb48c5997405dbf449e39665c2d34e6e9 100644 (file)
--- a/src/libsystemd-network/sd-dhcp-lease.c
+++ b/src/libsystemd-network/sd-dhcp-lease.c
@@ -98,78 +98,38 @@ int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
 
 int sd_dhcp_lease_get_servers(
                 sd_dhcp_lease *lease,
-                sd_dhcp_lease_info what,
+                sd_dhcp_lease_server_type what,
                 const struct in_addr **addr) {
 
         assert_return(lease, -EINVAL);
+        assert_return(what >= 0, -EINVAL);
+        assert_return(what < _SD_DHCP_LEASE_SERVER_TYPE_MAX, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        switch (what) {
-        case SD_DHCP_LEASE_DNS_SERVERS:
-                if (lease->dns_size <= 0)
-                        return -ENODATA;
-
-                *addr = lease->dns;
-                return (int) lease->dns_size;
-
-        case SD_DHCP_LEASE_NTP_SERVERS:
-                if (lease->ntp_size <= 0)
-                        return -ENODATA;
-
-                *addr = lease->ntp;
-                return (int) lease->ntp_size;
-
-        case SD_DHCP_LEASE_SIP_SERVERS:
-                if (lease->sip_size <= 0)
-                        return -ENODATA;
-
-                *addr = lease->sip;
-                return (int) lease->sip_size;
-
-        case SD_DHCP_LEASE_POP3_SERVERS:
-                if (lease->pop3_server_size <= 0)
-                        return -ENODATA;
-
-                *addr = lease->pop3_server;
-                return (int) lease->pop3_server_size;
-
-        case SD_DHCP_LEASE_SMTP_SERVERS:
-                if (lease->smtp_server_size <= 0)
-                        return -ENODATA;
-
-                *addr = lease->smtp_server;
-                return (int) lease->smtp_server_size;
-
-        case SD_DHCP_LEASE_LPR_SERVERS:
-                if (lease->lpr_server_size <= 0)
-                        return -ENODATA;
-
-                *addr = lease->lpr_server;
-                return (int) lease->lpr_server_size;
+        if (lease->servers[what].size <= 0)
+                return -ENODATA;
 
-        default:
-                return log_debug_errno(SYNTHETIC_ERRNO(ENXIO),
-                                       "Unknown DHCP lease info item %d.", what);
-        }
+        *addr = lease->servers[what].addr;
+        return (int) lease->servers[what].size;
 }
 
 int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr) {
-        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_DNS_SERVERS, addr);
+        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_DNS, addr);
 }
 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr) {
-        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_NTP_SERVERS, addr);
+        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_NTP, addr);
 }
 int sd_dhcp_lease_get_sip(sd_dhcp_lease *lease, const struct in_addr **addr) {
-        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SIP_SERVERS, addr);
+        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SIP, addr);
 }
-int sd_dhcp_lease_get_pop3_server(sd_dhcp_lease *lease, const struct in_addr **addr) {
-        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_POP3_SERVERS, addr);
+int sd_dhcp_lease_get_pop3(sd_dhcp_lease *lease, const struct in_addr **addr) {
+        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_POP3, addr);
 }
-int sd_dhcp_lease_get_smtp_server(sd_dhcp_lease *lease, const struct in_addr **addr) {
-        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SMTP_SERVERS, addr);
+int sd_dhcp_lease_get_smtp(sd_dhcp_lease *lease, const struct in_addr **addr) {
+        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SMTP, addr);
 }
-int sd_dhcp_lease_get_lpr_servers(sd_dhcp_lease *lease, const struct in_addr **addr) {
-        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_LPR_SERVERS, addr);
+int sd_dhcp_lease_get_lpr(sd_dhcp_lease *lease, const struct in_addr **addr) {
+        return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_LPR, addr);
 }
 
 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname) {
@@ -319,12 +279,10 @@ static sd_dhcp_lease *dhcp_lease_free(sd_dhcp_lease *lease) {
         free(lease->timezone);
         free(lease->hostname);
         free(lease->domainname);
-        free(lease->dns);
-        free(lease->ntp);
-        free(lease->sip);
-        free(lease->pop3_server);
-        free(lease->smtp_server);
-        free(lease->lpr_server);
+
+        for (sd_dhcp_lease_server_type i = 0; i < _SD_DHCP_LEASE_SERVER_TYPE_MAX; i++)
+                free(lease->servers[i].addr);
+
         free(lease->static_route);
         free(lease->client_id);
         free(lease->vendor_specific);
@@ -430,7 +388,7 @@ static int lease_parse_domain(const uint8_t *option, size_t len, char **ret) {
 }
 
 static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
-        assert(option);
+        assert(option || len == 0);
         assert(ret);
         assert(n_ret);
 
@@ -459,33 +417,24 @@ static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_add
 }
 
 static int lease_parse_sip_server(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
-        assert(option);
+        assert(option || len == 0);
         assert(ret);
         assert(n_ret);
 
-        if (len <= 0) {
-                *ret = mfree(*ret);
-                *n_ret = 0;
-        } else {
-                size_t n_addresses;
-                struct in_addr *addresses;
-                int l = len - 1;
-
-                if (l % 4 != 0)
-                        return -EINVAL;
+        if (len <= 0)
+                return -EINVAL;
 
-                n_addresses = l / 4;
+        /* The SIP record is like the other, regular server records, but prefixed with a single "encoding"
+         * byte that is either 0 or 1. We only support it to be 1 for now. Let's drop it and parse it like
+         * the other fields */
 
-                addresses = newdup(struct in_addr, option + 1, n_addresses);
-                if (!addresses)
-                        return -ENOMEM;
-
-                free(*ret);
-                *ret = addresses;
-                *n_ret = n_addresses;
+        if (option[0] != 1) { /* We only support IP address encoding for now */
+                *ret = mfree(*ret);
+                *n_ret = 0;
+                return 0;
         }
 
-        return 0;
+        return lease_parse_in_addrs(option + 1, len - 1, ret, n_ret);
 }
 
 static int lease_parse_routes(
@@ -630,37 +579,37 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
                 break;
 
         case SD_DHCP_OPTION_DOMAIN_NAME_SERVER:
-                r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
+                r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_DNS].addr, &lease->servers[SD_DHCP_LEASE_DNS].size);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse DNS server, ignoring: %m");
                 break;
 
         case SD_DHCP_OPTION_NTP_SERVER:
-                r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
+                r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_NTP].addr, &lease->servers[SD_DHCP_LEASE_NTP].size);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse NTP server, ignoring: %m");
                 break;
 
         case SD_DHCP_OPTION_SIP_SERVER:
-                r = lease_parse_sip_server(option, len, &lease->sip, &lease->sip_size);
+                r = lease_parse_sip_server(option, len, &lease->servers[SD_DHCP_LEASE_SIP].addr, &lease->servers[SD_DHCP_LEASE_SIP].size);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse SIP server, ignoring: %m");
                 break;
 
         case SD_DHCP_OPTION_POP3_SERVER:
-                r = lease_parse_in_addrs(option, len, &lease->pop3_server, &lease->pop3_server_size);
+                r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_POP3].addr, &lease->servers[SD_DHCP_LEASE_POP3].size);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse POP3 server, ignoring: %m");
                 break;
 
         case SD_DHCP_OPTION_SMTP_SERVER:
-                r = lease_parse_in_addrs(option, len, &lease->smtp_server, &lease->smtp_server_size);
+                r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_SMTP].addr, &lease->servers[SD_DHCP_LEASE_SMTP].size);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse SMTP server, ignoring: %m");
                 break;
 
         case SD_DHCP_OPTION_LPR_SERVER:
-                r = lease_parse_in_addrs(option, len, &lease->lpr_server, &lease->lpr_server_size);
+                r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_LPR].addr, &lease->servers[SD_DHCP_LEASE_LPR].size);
                 if (r < 0)
                         log_debug_errno(r, "Failed to parse LPR server, ignoring: %m");
                 break;
@@ -1101,9 +1050,9 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                 *dns = NULL,
                 *ntp = NULL,
                 *sip = NULL,
-                *pop3_server = NULL,
-                *smtp_server = NULL,
-                *lpr_server = NULL,
+                *pop3 = NULL,
+                *smtp = NULL,
+                *lpr = NULL,
                 *mtu = NULL,
                 *routes = NULL,
                 *domains = NULL,
@@ -1133,9 +1082,9 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                            "DNS", &dns,
                            "NTP", &ntp,
                            "SIP", &sip,
-                           "POP3_SERVERS", &pop3_server,
-                           "SMTP_SERVERS", &smtp_server,
-                           "LPR_SERVERS", &lpr_server,
+                           "POP3", &pop3,
+                           "SMTP", &smtp,
+                           "LPR", &lpr,
                            "MTU", &mtu,
                            "DOMAINNAME", &lease->domainname,
                            "HOSTNAME", &lease->hostname,
@@ -1225,54 +1174,53 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
         }
 
         if (dns) {
-                r = deserialize_in_addrs(&lease->dns, dns);
+                r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_DNS].addr, dns);
                 if (r < 0)
                         log_debug_errno(r, "Failed to deserialize DNS servers %s, ignoring: %m", dns);
                 else
-                        lease->dns_size = r;
+                        lease->servers[SD_DHCP_LEASE_DNS].size = r;
         }
 
         if (ntp) {
-                r = deserialize_in_addrs(&lease->ntp, ntp);
+                r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_NTP].addr, ntp);
                 if (r < 0)
                         log_debug_errno(r, "Failed to deserialize NTP servers %s, ignoring: %m", ntp);
                 else
-                        lease->ntp_size = r;
+                        lease->servers[SD_DHCP_LEASE_NTP].size = r;
         }
 
         if (sip) {
-                r = deserialize_in_addrs(&lease->sip, sip);
+                r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_SIP].addr, sip);
                 if (r < 0)
                         log_debug_errno(r, "Failed to deserialize SIP servers %s, ignoring: %m", sip);
                 else
-                        lease->sip_size = r;
+                        lease->servers[SD_DHCP_LEASE_SIP].size = r;
         }
 
-        if (pop3_server) {
-                r = deserialize_in_addrs(&lease->pop3_server, pop3_server);
+        if (pop3) {
+                r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_POP3].addr, pop3);
                 if (r < 0)
-                        log_debug_errno(r, "Failed to deserialize POP3 server %s, ignoring: %m", pop3_server);
+                        log_debug_errno(r, "Failed to deserialize POP3 server %s, ignoring: %m", pop3);
                 else
-                        lease->pop3_server_size = r;
+                        lease->servers[SD_DHCP_LEASE_POP3].size = r;
         }
 
-        if (smtp_server) {
-                r = deserialize_in_addrs(&lease->smtp_server, smtp_server);
+        if (smtp) {
+                r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_SMTP].addr, smtp);
                 if (r < 0)
-                        log_debug_errno(r, "Failed to deserialize SMTP server %s, ignoring: %m", smtp_server);
+                        log_debug_errno(r, "Failed to deserialize SMTP server %s, ignoring: %m", smtp);
                 else
-                        lease->smtp_server_size = r;
+                        lease->servers[SD_DHCP_LEASE_SMTP].size = r;
         }
 
-        if (lpr_server) {
-                r = deserialize_in_addrs(&lease->lpr_server, lpr_server);
+        if (lpr) {
+                r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_LPR].addr, lpr);
                 if (r < 0)
-                        log_debug_errno(r, "Failed to deserialize LPR server %s, ignoring: %m", lpr_server);
+                        log_debug_errno(r, "Failed to deserialize LPR server %s, ignoring: %m", lpr);
                 else
-                        lease->lpr_server_size = r;
+                        lease->servers[SD_DHCP_LEASE_LPR].size = r;
         }
 
-
         if (mtu) {
                 r = safe_atou16(mtu, &lease->mtu);
                 if (r < 0)

diff --git a/src/libsystemd-network/sd-dhcp-server.c b/src/libsystemd-network/sd-dhcp-server.c
index 9db583a7a800d1915ef265daee69c69ffb443e08..dce68aeb26af5e72a63b58e58e6ad158d2b06f11 100644 (file)
--- a/src/libsystemd-network/sd-dhcp-server.c
+++ b/src/libsystemd-network/sd-dhcp-server.c
@@ -3,6 +3,7 @@
   Copyright © 2013 Intel Corporation. All rights reserved.
 ***/
 
+#include <net/if_arp.h>
 #include <sys/ioctl.h>
 
 #include "sd-dhcp-server.h"
@@ -143,12 +144,9 @@ static sd_dhcp_server *dhcp_server_free(sd_dhcp_server *server) {
         sd_event_unref(server->event);
 
         free(server->timezone);
-        free(server->dns);
-        free(server->ntp);
-        free(server->sip);
-        free(server->pop3_server);
-        free(server->smtp_server);
-        free(server->lpr_server);
+
+        for (sd_dhcp_lease_server_type i = 0; i < _SD_DHCP_LEASE_SERVER_TYPE_MAX; i++)
+                free(server->servers[i].addr);
 
         hashmap_free(server->leases_by_client_id);
 
@@ -461,8 +459,20 @@ static int server_send_offer(sd_dhcp_server *server, DHCPRequest *req,
         return 0;
 }
 
-static int server_send_ack(sd_dhcp_server *server, DHCPRequest *req,
-                           be32_t address) {
+static int server_send_ack(
+                sd_dhcp_server *server,
+                DHCPRequest *req,
+                be32_t address) {
+
+        static const uint8_t option_map[_SD_DHCP_LEASE_SERVER_TYPE_MAX] = {
+                [SD_DHCP_LEASE_DNS] = SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
+                [SD_DHCP_LEASE_NTP] = SD_DHCP_OPTION_NTP_SERVER,
+                [SD_DHCP_LEASE_SIP] = SD_DHCP_OPTION_SIP_SERVER,
+                [SD_DHCP_LEASE_POP3] = SD_DHCP_OPTION_POP3_SERVER,
+                [SD_DHCP_LEASE_SMTP] = SD_DHCP_OPTION_SMTP_SERVER,
+                [SD_DHCP_LEASE_LPR] = SD_DHCP_OPTION_LPR_SERVER,
+        };
+
         _cleanup_free_ DHCPPacket *packet = NULL;
         be32_t lease_time;
         sd_dhcp_option *j;
@@ -495,59 +505,19 @@ static int server_send_ack(sd_dhcp_server *server, DHCPRequest *req,
                         return r;
         }
 
-        if (server->n_dns > 0) {
-                r = dhcp_option_append(
-                                &packet->dhcp, req->max_optlen, &offset, 0,
-                                SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
-                                sizeof(struct in_addr) * server->n_dns, server->dns);
-                if (r < 0)
-                        return r;
-        }
-
-        if (server->n_ntp > 0) {
-                r = dhcp_option_append(
-                                &packet->dhcp, req->max_optlen, &offset, 0,
-                                SD_DHCP_OPTION_NTP_SERVER,
-                                sizeof(struct in_addr) * server->n_ntp, server->ntp);
-                if (r < 0)
-                        return r;
-        }
-
-        if (server->n_sip > 0) {
-                r = dhcp_option_append(
-                                &packet->dhcp, req->max_optlen, &offset, 0,
-                                SD_DHCP_OPTION_SIP_SERVER,
-                                sizeof(struct in_addr) * server->n_sip, server->sip);
-                if (r < 0)
-                        return r;
-        }
+        for (sd_dhcp_lease_server_type k = 0; k < _SD_DHCP_LEASE_SERVER_TYPE_MAX; k++) {
 
-        if (server->n_pop3_server > 0) {
-                r = dhcp_option_append(
-                                &packet->dhcp, req->max_optlen, &offset, 0,
-                                SD_DHCP_OPTION_POP3_SERVER,
-                                sizeof(struct in_addr) * server->n_pop3_server, server->pop3_server);
-                if (r < 0)
-                        return r;
-        }
+                if (server->servers[k].size <= 0)
+                        continue;
 
-        if (server->n_smtp_server > 0) {
                 r = dhcp_option_append(
                                 &packet->dhcp, req->max_optlen, &offset, 0,
-                                SD_DHCP_OPTION_SMTP_SERVER,
-                                sizeof(struct in_addr) * server->n_smtp_server, server->smtp_server);
+                                option_map[k],
+                                sizeof(struct in_addr) * server->servers[k].size, server->servers[k].addr);
                 if (r < 0)
                         return r;
         }
 
-        if (server->n_lpr_server > 0) {
-                r = dhcp_option_append(
-                                &packet->dhcp, req->max_optlen, &offset, 0,
-                                SD_DHCP_OPTION_LPR_SERVER,
-                                sizeof(struct in_addr) * server->n_lpr_server, server->lpr_server);
-                if (r < 0)
-                        return r;
-        }
 
         if (server->timezone) {
                 r = dhcp_option_append(
@@ -1139,87 +1109,50 @@ int sd_dhcp_server_set_default_lease_time(sd_dhcp_server *server, uint32_t t) {
 
 int sd_dhcp_server_set_servers(
                 sd_dhcp_server *server,
-                sd_dhcp_lease_info what,
+                sd_dhcp_lease_server_type what,
                 const struct in_addr addresses[],
                 size_t n_addresses) {
 
+        struct in_addr *c = NULL;
+
         assert_return(server, -EINVAL);
         assert_return(addresses || n_addresses == 0, -EINVAL);
+        assert_return(what >= 0, -EINVAL);
+        assert_return(what < _SD_DHCP_LEASE_SERVER_TYPE_MAX, -EINVAL);
 
-        struct in_addr **a;
-        size_t *n_a;
-
-        switch (what) {
-        case SD_DHCP_LEASE_DNS_SERVERS:
-                a = &server->dns;
-                n_a = &server->n_dns;
-                break;
-
-        case SD_DHCP_LEASE_NTP_SERVERS:
-                a = &server->ntp;
-                n_a = &server->n_ntp;
-                break;
-
-        case SD_DHCP_LEASE_SIP_SERVERS:
-                a = &server->sip;
-                n_a = &server->n_sip;
-                break;
-
-        case SD_DHCP_LEASE_POP3_SERVERS:
-                a = &server->pop3_server;
-                n_a = &server->n_pop3_server;
-                break;
-
-        case SD_DHCP_LEASE_SMTP_SERVERS:
-                a = &server->smtp_server;
-                n_a = &server->n_smtp_server;
-                break;
-
-        case SD_DHCP_LEASE_LPR_SERVERS:
-                a = &server->lpr_server;
-                n_a = &server->n_lpr_server;
-                break;
-
-        default:
-                return log_debug_errno(SYNTHETIC_ERRNO(ENXIO),
-                                       "Unknown DHCP lease info item %d.", what);
-        }
-
-        if (*n_a == n_addresses &&
-            memcmp(*a, addresses, sizeof(struct in_addr) * n_addresses) == 0)
+        if (server->servers[what].size == n_addresses &&
+            memcmp(server->servers[what].addr, addresses, sizeof(struct in_addr) * n_addresses) == 0)
                 return 0;
 
-        struct in_addr *c = NULL;
-
         if (n_addresses > 0) {
                 c = newdup(struct in_addr, addresses, n_addresses);
                 if (!c)
                         return -ENOMEM;
         }
 
-        free(*a);
-        *a = c;
-        *n_a = n_addresses;
+        free(server->servers[what].addr);
+        server->servers[what].addr = c;
+        server->servers[what].size = n_addresses;
         return 1;
 }
 
 int sd_dhcp_server_set_dns(sd_dhcp_server *server, const struct in_addr dns[], size_t n) {
-        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_DNS_SERVERS, dns, n);
+        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_DNS, dns, n);
 }
 int sd_dhcp_server_set_ntp(sd_dhcp_server *server, const struct in_addr ntp[], size_t n) {
-        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_NTP_SERVERS, ntp, n);
+        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_NTP, ntp, n);
 }
 int sd_dhcp_server_set_sip(sd_dhcp_server *server, const struct in_addr sip[], size_t n) {
-        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SIP_SERVERS, sip, n);
+        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SIP, sip, n);
 }
 int sd_dhcp_server_set_pop3(sd_dhcp_server *server, const struct in_addr pop3[], size_t n) {
-        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_POP3_SERVERS, pop3, n);
+        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_POP3, pop3, n);
 }
 int sd_dhcp_server_set_smtp(sd_dhcp_server *server, const struct in_addr smtp[], size_t n) {
-        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SMTP_SERVERS, smtp, n);
+        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SMTP, smtp, n);
 }
 int sd_dhcp_server_set_lpr(sd_dhcp_server *server, const struct in_addr lpr[], size_t n) {
-        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_LPR_SERVERS, lpr, n);
+        return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_LPR, lpr, n);
 }
 
 int sd_dhcp_server_set_emit_router(sd_dhcp_server *server, int enabled) {

diff --git a/src/libsystemd-network/test-dhcp-client.c b/src/libsystemd-network/test-dhcp-client.c
index 4e9b388a451aa0be06c3838d9aa34773b8e45717..80a85661942ea9ea1c55c94de29abef6dd43505c 100644 (file)
--- a/src/libsystemd-network/test-dhcp-client.c
+++ b/src/libsystemd-network/test-dhcp-client.c
@@ -4,10 +4,11 @@
 ***/
 
 #include <errno.h>
+#include <net/if.h>
+#include <net/if_arp.h>
 #include <stdio.h>
 #include <sys/socket.h>
 #include <unistd.h>
-#include <net/if.h>
 
 #include "sd-dhcp-client.h"
 #include "sd-event.h"

diff --git a/src/libsystemd-network/test-dhcp-option.c b/src/libsystemd-network/test-dhcp-option.c
index 56bd690cb0a0280fb8e8803f90f0b07286e759ec..086f8b5fd96c946817f1c99ec6d5f56d1b4ef9ce 100644 (file)
--- a/src/libsystemd-network/test-dhcp-option.c
+++ b/src/libsystemd-network/test-dhcp-option.c
@@ -1,4 +1,7 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+
 #include <errno.h>
+#include <net/if_arp.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>

diff --git a/src/libsystemd-network/test-dhcp-server.c b/src/libsystemd-network/test-dhcp-server.c
index ea998939bc48729adf2c7e5dfa07220142e05b64..a45d98f669077d61fe9534ceafc8c9aff03d16a6 100644 (file)
--- a/src/libsystemd-network/test-dhcp-server.c
+++ b/src/libsystemd-network/test-dhcp-server.c
@@ -4,6 +4,7 @@
 ***/
 
 #include <errno.h>
+#include <net/if_arp.h>
 
 #include "sd-dhcp-server.h"
 #include "sd-event.h"

diff --git a/src/network/networkd-dhcp-server.c b/src/network/networkd-dhcp-server.c
index 3427c6642aec38531c3ebbbcdab98853c71fcba9..40705c3d814a7b84845d97a9b4fb0d755c8e7cc4 100644 (file)
--- a/src/network/networkd-dhcp-server.c
+++ b/src/network/networkd-dhcp-server.c
@@ -79,7 +79,7 @@ static int link_push_uplink_dns_to_dhcp_server(Link *link, sd_dhcp_server *s) {
 
 static int link_push_uplink_to_dhcp_server(
                 Link *link,
-                sd_dhcp_lease_info what,
+                sd_dhcp_lease_server_type what,
                 sd_dhcp_server *s) {
 
         _cleanup_free_ struct in_addr *addresses = NULL;
@@ -90,35 +90,35 @@ static int link_push_uplink_to_dhcp_server(
         if (!link->network)
                 return 0;
 
-        log_link_debug(link, "Copying %s from link", dhcp_lease_info_to_string(what));
+        log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what));
 
         switch (what) {
-        case SD_DHCP_LEASE_DNS_SERVERS:
+        case SD_DHCP_LEASE_DNS:
                 /* DNS servers are stored as parsed data, so special handling is required.
                  * TODO: check if DNS servers should be stored unparsed too. */
                 return link_push_uplink_dns_to_dhcp_server(link, s);
 
-        case SD_DHCP_LEASE_NTP_SERVERS:
+        case SD_DHCP_LEASE_NTP:
                 servers = link->network->ntp;
                 lease_condition = link->network->dhcp_use_ntp;
                 break;
 
-        case SD_DHCP_LEASE_POP3_SERVERS:
+        case SD_DHCP_LEASE_POP3:
                 servers = link->network->pop3;
                 lease_condition = true;
                 break;
 
-        case SD_DHCP_LEASE_SMTP_SERVERS:
+        case SD_DHCP_LEASE_SMTP:
                 servers = link->network->smtp;
                 lease_condition = true;
                 break;
 
-        case SD_DHCP_LEASE_SIP_SERVERS:
+        case SD_DHCP_LEASE_SIP:
                 servers = link->network->sip;
                 lease_condition = link->network->dhcp_use_sip;
                 break;
 
-        case SD_DHCP_LEASE_LPR_SERVERS:
+        case SD_DHCP_LEASE_LPR:
                 servers = link->network->lpr;
                 lease_condition = true;
                 break;
@@ -290,38 +290,38 @@ int dhcp4_server_configure(Link *link) {
                 const struct in_addr *servers;
                 unsigned n_servers;
         } configs[] = {
-                [SD_DHCP_LEASE_DNS_SERVERS] = {
+                [SD_DHCP_LEASE_DNS] = {
                         link->network->dhcp_server_emit_dns,
                         link->network->dhcp_server_dns,
                         link->network->n_dhcp_server_dns,
                 },
-                [SD_DHCP_LEASE_NTP_SERVERS] = {
+                [SD_DHCP_LEASE_NTP] = {
                         link->network->dhcp_server_emit_ntp,
                         link->network->dhcp_server_ntp,
                         link->network->n_dhcp_server_ntp,
                 },
-                [SD_DHCP_LEASE_SIP_SERVERS] = {
+                [SD_DHCP_LEASE_SIP] = {
                         link->network->dhcp_server_emit_sip,
                         link->network->dhcp_server_sip,
                         link->network->n_dhcp_server_sip,
                 },
-                [SD_DHCP_LEASE_POP3_SERVERS] = {
+                [SD_DHCP_LEASE_POP3] = {
                         true,
                         link->network->dhcp_server_pop3,
                         link->network->n_dhcp_server_pop3,
                 },
-                [SD_DHCP_LEASE_SMTP_SERVERS] = {
+                [SD_DHCP_LEASE_SMTP] = {
                         true,
                         link->network->dhcp_server_smtp,
                         link->network->n_dhcp_server_smtp,
                 },
-                [SD_DHCP_LEASE_LPR_SERVERS] = {
+                [SD_DHCP_LEASE_LPR] = {
                         true,
                         link->network->dhcp_server_lpr,
                         link->network->n_dhcp_server_lpr,
                 },
         };
-        assert_cc(ELEMENTSOF(configs) == _SD_DHCP_LEASE_INFO_MAX);
+        assert_cc(ELEMENTSOF(configs) == _SD_DHCP_LEASE_SERVER_TYPE_MAX);
 
         for (unsigned n = 0; n < ELEMENTSOF(configs); n++)
                 if (configs[n].condition) {
@@ -337,17 +337,17 @@ int dhcp4_server_configure(Link *link) {
                                 if (!uplink) {
                                         log_link_debug(link,
                                                        "Not emitting %s on link, couldn't find suitable uplink.",
-                                                       dhcp_lease_info_to_string(n));
+                                                       dhcp_lease_server_type_to_string(n));
                                         r = 0;
                                 } else if (uplink->network)
                                         r = link_push_uplink_to_dhcp_server(uplink, n, link->dhcp_server);
-                                else if (n == SD_DHCP_LEASE_DNS_SERVERS)
+                                else if (n == SD_DHCP_LEASE_DNS)
                                         r = dhcp4_server_set_dns_from_resolve_conf(link);
                         }
                         if (r < 0)
                                 log_link_warning_errno(link, r,
                                                        "Failed to set %s for DHCP server, ignoring: %m",
-                                                       dhcp_lease_info_to_string(n));
+                                                       dhcp_lease_server_type_to_string(n));
                 }
 
         r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);

diff --git a/src/network/networkd-link.c b/src/network/networkd-link.c
index 8a549110fa14dc4405e642a8d39cd46b76258fd6..214604cd9b93d41eddf6ba314301914968d5b646 100644 (file)
--- a/src/network/networkd-link.c
+++ b/src/network/networkd-link.c
@@ -4012,7 +4012,7 @@ static void serialize_addresses(
                 char **addresses,
                 sd_dhcp_lease *lease,
                 bool conditional,
-                sd_dhcp_lease_info what,
+                sd_dhcp_lease_server_type what,
                 sd_dhcp6_lease *lease6,
                 bool conditional6,
                 int (*lease6_get_addr)(sd_dhcp6_lease*, const struct in6_addr**),
@@ -4138,7 +4138,7 @@ int link_save(Link *link) {
                                     NULL,
                                     link->dhcp_lease,
                                     link->network->dhcp_use_dns,
-                                    SD_DHCP_LEASE_DNS_SERVERS,
+                                    SD_DHCP_LEASE_DNS,
                                     dhcp6_lease,
                                     link->network->dhcp6_use_dns,
                                     sd_dhcp6_lease_get_dns,
@@ -4162,7 +4162,7 @@ int link_save(Link *link) {
                                     link->ntp ?: link->network->ntp,
                                     link->dhcp_lease,
                                     link->network->dhcp_use_ntp,
-                                    SD_DHCP_LEASE_NTP_SERVERS,
+                                    SD_DHCP_LEASE_NTP,
                                     dhcp6_lease,
                                     link->network->dhcp6_use_ntp,
                                     sd_dhcp6_lease_get_ntp_addrs,
@@ -4172,28 +4172,28 @@ int link_save(Link *link) {
                                     link->network->sip,
                                     link->dhcp_lease,
                                     link->network->dhcp_use_sip,
-                                    SD_DHCP_LEASE_SIP_SERVERS,
+                                    SD_DHCP_LEASE_SIP,
                                     false, NULL, NULL, NULL);
 
-                serialize_addresses(f, "POP3_SERVERS", NULL,
+                serialize_addresses(f, "POP3", NULL,
                                     link->network->pop3,
                                     link->dhcp_lease,
                                     true,
-                                    SD_DHCP_LEASE_POP3_SERVERS,
+                                    SD_DHCP_LEASE_POP3,
                                     false, NULL, NULL, NULL);
 
-                serialize_addresses(f, "SMTP_SERVERS", NULL,
+                serialize_addresses(f, "SMTP", NULL,
                                     link->network->smtp,
                                     link->dhcp_lease,
                                     true,
-                                    SD_DHCP_LEASE_SMTP_SERVERS,
+                                    SD_DHCP_LEASE_SMTP,
                                     false, NULL, NULL, NULL);
 
-                serialize_addresses(f, "LPR_SERVERS", NULL,
+                serialize_addresses(f, "LPR", NULL,
                                     link->network->lpr,
                                     link->dhcp_lease,
                                     true,
-                                    SD_DHCP_LEASE_LPR_SERVERS,
+                                    SD_DHCP_LEASE_LPR,
                                     false, NULL, NULL, NULL);
 
                 /************************************************************/

diff --git a/src/network/networkd-manager.c b/src/network/networkd-manager.c
index f9b611e41949b2b9d6faea11d231492a9ed26dd9..3142f6ae868fb692680e1467a68902a38cce5dad 100644 (file)
--- a/src/network/networkd-manager.c
+++ b/src/network/networkd-manager.c
@@ -1611,7 +1611,7 @@ static int manager_save(Manager *m) {
                                 return r;
                 }
 
-                r = sd_dhcp_lease_get_pop3_server(link->dhcp_lease, &addresses);
+                r = sd_dhcp_lease_get_pop3(link->dhcp_lease, &addresses);
                 if (r > 0) {
                         r = ordered_set_put_in4_addrv(pop3, addresses, r, in4_addr_is_non_local);
                         if (r < 0)
@@ -1619,7 +1619,7 @@ static int manager_save(Manager *m) {
                 } else if (r < 0 && r != -ENODATA)
                         return r;
 
-                r = sd_dhcp_lease_get_smtp_server(link->dhcp_lease, &addresses);
+                r = sd_dhcp_lease_get_smtp(link->dhcp_lease, &addresses);
                 if (r > 0) {
                         r = ordered_set_put_in4_addrv(smtp, addresses, r, in4_addr_is_non_local);
                         if (r < 0)
@@ -1627,7 +1627,7 @@ static int manager_save(Manager *m) {
                 } else if (r < 0 && r != -ENODATA)
                         return r;
 
-                r = sd_dhcp_lease_get_lpr_servers(link->dhcp_lease, &addresses);
+                r = sd_dhcp_lease_get_lpr(link->dhcp_lease, &addresses);
                 if (r > 0) {
                         r = ordered_set_put_in4_addrv(lpr, addresses, r, in4_addr_is_non_local);
                         if (r < 0)

diff --git a/src/network/networkd-util.c b/src/network/networkd-util.c
index d9ad647a15a8ce62fd0bb8971843a1ac68335d79..bc76fc7a596bfc0200b1fd5bac971468cee6f2b6 100644 (file)
--- a/src/network/networkd-util.c
+++ b/src/network/networkd-util.c
@@ -37,13 +37,13 @@ static const char* const duplicate_address_detection_address_family_table[_ADDRE
         [ADDRESS_FAMILY_IPV6]          = "ipv6",
 };
 
-static const char* const dhcp_lease_info_table[_SD_DHCP_LEASE_INFO_MAX] = {
-        [SD_DHCP_LEASE_DNS_SERVERS]  = "DNS servers",
-        [SD_DHCP_LEASE_NTP_SERVERS]  = "NTP servers",
-        [SD_DHCP_LEASE_SIP_SERVERS]  = "SIP servers",
-        [SD_DHCP_LEASE_POP3_SERVERS] = "POP3 servers",
-        [SD_DHCP_LEASE_SMTP_SERVERS] = "SMTP servers",
-        [SD_DHCP_LEASE_LPR_SERVERS]  = "LPR servers",
+static const char* const dhcp_lease_server_type_table[_SD_DHCP_LEASE_SERVER_TYPE_MAX] = {
+        [SD_DHCP_LEASE_DNS]  = "DNS servers",
+        [SD_DHCP_LEASE_NTP]  = "NTP servers",
+        [SD_DHCP_LEASE_SIP]  = "SIP servers",
+        [SD_DHCP_LEASE_POP3] = "POP3 servers",
+        [SD_DHCP_LEASE_SMTP] = "SMTP servers",
+        [SD_DHCP_LEASE_LPR]  = "LPR servers",
 };
 
 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(address_family, AddressFamily, ADDRESS_FAMILY_YES);
@@ -52,7 +52,7 @@ DEFINE_STRING_TABLE_LOOKUP(routing_policy_rule_address_family, AddressFamily);
 DEFINE_STRING_TABLE_LOOKUP(duplicate_address_detection_address_family, AddressFamily);
 DEFINE_CONFIG_PARSE_ENUM(config_parse_link_local_address_family, link_local_address_family,
                          AddressFamily, "Failed to parse option");
-DEFINE_STRING_TABLE_LOOKUP(dhcp_lease_info, sd_dhcp_lease_info);
+DEFINE_STRING_TABLE_LOOKUP(dhcp_lease_server_type, sd_dhcp_lease_server_type);
 
 int config_parse_address_family_with_kernel(
                 const char* unit,

diff --git a/src/network/networkd-util.h b/src/network/networkd-util.h
index 48411b0cf52c93e232c36c5e48e0c76cc4c4b014..0433f883a32856417fea5b130e0fad9a59545714 100644 (file)
--- a/src/network/networkd-util.h
+++ b/src/network/networkd-util.h
@@ -40,8 +40,8 @@ AddressFamily routing_policy_rule_address_family_from_string(const char *s) _pur
 const char *duplicate_address_detection_address_family_to_string(AddressFamily b) _const_;
 AddressFamily duplicate_address_detection_address_family_from_string(const char *s) _pure_;
 
-const char *dhcp_lease_info_to_string(sd_dhcp_lease_info info) _const_;
-sd_dhcp_lease_info dhcp_lease_info_from_string(const char *s) _pure_;
+const char *dhcp_lease_server_type_to_string(sd_dhcp_lease_server_type t) _const_;
+sd_dhcp_lease_server_type dhcp_lease_server_type_from_string(const char *s) _pure_;
 
 int kernel_route_expiration_supported(void);
 

diff --git a/src/systemd/sd-dhcp-lease.h b/src/systemd/sd-dhcp-lease.h
index a3964d5989dc03a479ea637a152df9316da563ab..17bd491819ff324d01f42eae1c80f62e3a238dfc 100644 (file)
--- a/src/systemd/sd-dhcp-lease.h
+++ b/src/systemd/sd-dhcp-lease.h
@@ -33,15 +33,16 @@ typedef struct sd_dhcp_route sd_dhcp_route;
 sd_dhcp_lease *sd_dhcp_lease_ref(sd_dhcp_lease *lease);
 sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease);
 
-typedef enum sd_dhcp_lease_info {
-        SD_DHCP_LEASE_DNS_SERVERS = 0,
-        SD_DHCP_LEASE_NTP_SERVERS,
-        SD_DHCP_LEASE_SIP_SERVERS,
-        SD_DHCP_LEASE_POP3_SERVERS,
-        SD_DHCP_LEASE_SMTP_SERVERS,
-        SD_DHCP_LEASE_LPR_SERVERS,
-        _SD_DHCP_LEASE_INFO_MAX,
-} sd_dhcp_lease_info;
+typedef enum sd_dhcp_lease_server_type {
+        SD_DHCP_LEASE_DNS,
+        SD_DHCP_LEASE_NTP,
+        SD_DHCP_LEASE_SIP,
+        SD_DHCP_LEASE_POP3,
+        SD_DHCP_LEASE_SMTP,
+        SD_DHCP_LEASE_LPR,
+        _SD_DHCP_LEASE_SERVER_TYPE_MAX,
+        _SD_DHCP_LEASE_SERVER_TYPE_INVALID = -1,
+} sd_dhcp_lease_server_type;
 
 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);
@@ -52,13 +53,13 @@ int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr);
 int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, const struct in_addr **addr);
 int sd_dhcp_lease_get_next_server(sd_dhcp_lease *lease, struct in_addr *addr);
 int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *addr);
-int sd_dhcp_lease_get_servers(sd_dhcp_lease *lease, sd_dhcp_lease_info what, const struct in_addr **addr);
+int sd_dhcp_lease_get_servers(sd_dhcp_lease *lease, sd_dhcp_lease_server_type what, const struct in_addr **addr);
 int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr);
 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr);
 int sd_dhcp_lease_get_sip(sd_dhcp_lease *lease, const struct in_addr **addr);
-int sd_dhcp_lease_get_pop3_server(sd_dhcp_lease *lease, const struct in_addr **addr);
-int sd_dhcp_lease_get_smtp_server(sd_dhcp_lease *lease, const struct in_addr **addr);
-int sd_dhcp_lease_get_lpr_servers(sd_dhcp_lease *lease, const struct in_addr **addr);
+int sd_dhcp_lease_get_pop3(sd_dhcp_lease *lease, const struct in_addr **addr);
+int sd_dhcp_lease_get_smtp(sd_dhcp_lease *lease, const struct in_addr **addr);
+int sd_dhcp_lease_get_lpr(sd_dhcp_lease *lease, const struct in_addr **addr);
 int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu);
 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname);
 int sd_dhcp_lease_get_search_domains(sd_dhcp_lease *lease, char ***domains);

diff --git a/src/systemd/sd-dhcp-server.h b/src/systemd/sd-dhcp-server.h
index 4697f3dd3d75b630f4d180179df039a14761d27d..1993bf12d3f973128f84280289be8e8250f7d30c 100644 (file)
--- a/src/systemd/sd-dhcp-server.h
+++ b/src/systemd/sd-dhcp-server.h
@@ -52,7 +52,7 @@ int sd_dhcp_server_set_emit_router(sd_dhcp_server *server, int enabled);
 
 int sd_dhcp_server_set_servers(
                 sd_dhcp_server *server,
-                sd_dhcp_lease_info what,
+                sd_dhcp_lease_server_type what,
                 const struct in_addr addresses[],
                 size_t n_addresses);