Merge pull request #1055 from poettering/dhcp-updates

Various networkd and dhcp updates

24 files changed, 909 insertions, 643 deletions

diff --git a/src/libsystemd-network/dhcp-internal.h b/src/libsystemd-network/dhcp-internal.h
index 7c60ef123c..df6f882af5 100644
--- a/src/libsystemd-network/dhcp-internal.h
+++ b/src/libsystemd-network/dhcp-internal.h
@@ -45,10 +45,10 @@ int dhcp_option_append(DHCPMessage *message, size_t size, size_t *offset, uint8_
                        uint8_t code, size_t optlen, const void *optval);
 
 typedef int (*dhcp_option_cb_t)(uint8_t code, uint8_t len,
-                                const uint8_t *option, void *user_data);
+                                const void *option, void *userdata);
 
 int dhcp_option_parse(DHCPMessage *message, size_t len,
-                      dhcp_option_cb_t cb, void *user_data);
+                      dhcp_option_cb_t cb, void *userdata);
 
 int dhcp_message_init(DHCPMessage *message, uint8_t op, uint32_t xid,
                       uint8_t type, uint16_t arp_type, size_t optlen,
diff --git a/src/libsystemd-network/dhcp-lease-internal.h b/src/libsystemd-network/dhcp-lease-internal.h
index 5a3fcddb1b..c6b97ca8f7 100644
--- a/src/libsystemd-network/dhcp-lease-internal.h
+++ b/src/libsystemd-network/dhcp-lease-internal.h
@@ -25,7 +25,6 @@
 #include <stdint.h>
 #include <linux/if_packet.h>
 
-#include "refcnt.h"
 #include "util.h"
 #include "list.h"
 
@@ -48,54 +47,62 @@ struct sd_dhcp_raw_option {
 };
 
 struct sd_dhcp_lease {
-        RefCount n_ref;
+        unsigned n_ref;
 
-        int32_t time_offset;
+        /* each 0 if unset */
         uint32_t t1;
         uint32_t t2;
         uint32_t lifetime;
-        uint32_t mtu_aging_timeout;
+
+        /* each 0 if unset */
         be32_t address;
         be32_t server_address;
-        be32_t subnet_mask;
         be32_t router;
         be32_t next_server;
+
+        bool have_subnet_mask;
+        be32_t subnet_mask;
+
+        bool have_broadcast;
         be32_t broadcast;
+
         struct in_addr *dns;
         size_t dns_size;
+
         struct in_addr *ntp;
         size_t ntp_size;
-        struct in_addr *policy_filter;
-        size_t policy_filter_size;
+
         struct sd_dhcp_route *static_route;
-        size_t static_route_size;
-        size_t static_route_allocated;
-        uint16_t boot_file_size;
-        uint16_t mdr;
-        uint16_t mtu;
-        uint8_t ttl;
-        bool ip_forward;
-        bool ip_forward_non_local;
+        size_t static_route_size, static_route_allocated;
+
+        uint16_t mtu; /* 0 if unset */
+
         char *domainname;
         char *hostname;
         char *root_path;
-        uint8_t *client_id;
+
+        void *client_id;
         size_t client_id_len;
-        uint8_t *vendor_specific;
+
+        void *vendor_specific;
         size_t vendor_specific_len;
+
+        char *timezone;
+
         LIST_HEAD(struct sd_dhcp_raw_option, private_options);
 };
 
 int dhcp_lease_new(sd_dhcp_lease **ret);
-int dhcp_lease_parse_options(uint8_t code, uint8_t len, const uint8_t *option,
-                              void *user_data);
-int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag,
-                                     const uint8_t *data, uint8_t len);
+
+int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void *userdata);
+int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag, const void *data, uint8_t len);
 
 int dhcp_lease_set_default_subnet_mask(sd_dhcp_lease *lease);
 
-int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const uint8_t *client_id,
-                             size_t client_id_len);
+int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const void *client_id, size_t client_id_len);
+
+int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file);
+int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file);
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(sd_dhcp_lease*, sd_dhcp_lease_unref);
 #define _cleanup_dhcp_lease_unref_ _cleanup_(sd_dhcp_lease_unrefp)
diff --git a/src/libsystemd-network/dhcp-option.c b/src/libsystemd-network/dhcp-option.c
index b6110c5f16..36be7d54ed 100644
--- a/src/libsystemd-network/dhcp-option.c
+++ b/src/libsystemd-network/dhcp-option.c
@@ -140,7 +140,7 @@ int dhcp_option_append(DHCPMessage *message, size_t size, size_t *offset,
 
 static int parse_options(const uint8_t options[], size_t buflen, uint8_t *overload,
                          uint8_t *message_type, dhcp_option_cb_t cb,
-                         void *user_data) {
+                         void *userdata) {
         uint8_t code, len;
         size_t offset = 0;
 
@@ -199,7 +199,7 @@ static int parse_options(const uint8_t options[], size_t buflen, uint8_t *overlo
                                 return -EINVAL;
 
                         if (cb)
-                                cb(code, len, &options[offset], user_data);
+                                cb(code, len, &options[offset], userdata);
 
                         offset += len;
 
@@ -214,7 +214,7 @@ static int parse_options(const uint8_t options[], size_t buflen, uint8_t *overlo
 }
 
 int dhcp_option_parse(DHCPMessage *message, size_t len,
-                      dhcp_option_cb_t cb, void *user_data) {
+                      dhcp_option_cb_t cb, void *userdata) {
         uint8_t overload = 0;
         uint8_t message_type = 0;
         int r;
@@ -228,20 +228,20 @@ int dhcp_option_parse(DHCPMessage *message, size_t len,
         len -= sizeof(DHCPMessage);
 
         r = parse_options(message->options, len, &overload, &message_type,
-                          cb, user_data);
+                          cb, userdata);
         if (r < 0)
                 return r;
 
         if (overload & DHCP_OVERLOAD_FILE) {
                 r = parse_options(message->file, sizeof(message->file),
-                                NULL, &message_type, cb, user_data);
+                                NULL, &message_type, cb, userdata);
                 if (r < 0)
                         return r;
         }
 
         if (overload & DHCP_OVERLOAD_SNAME) {
                 r = parse_options(message->sname, sizeof(message->sname),
-                                NULL, &message_type, cb, user_data);
+                                NULL, &message_type, cb, userdata);
                 if (r < 0)
                         return r;
         }
diff --git a/src/libsystemd-network/dhcp-protocol.h b/src/libsystemd-network/dhcp-protocol.h
index 4308723f91..88a81d2866 100644
--- a/src/libsystemd-network/dhcp-protocol.h
+++ b/src/libsystemd-network/dhcp-protocol.h
@@ -137,6 +137,8 @@ enum {
         DHCP_OPTION_REBINDING_T2_TIME           = 59,
         DHCP_OPTION_VENDOR_CLASS_IDENTIFIER     = 60,
         DHCP_OPTION_CLIENT_IDENTIFIER           = 61,
+        DHCP_OPTION_NEW_POSIX_TIMEZONE          = 100,
+        DHCP_OPTION_NEW_TZDB_TIMEZONE           = 101,
         DHCP_OPTION_CLASSLESS_STATIC_ROUTE      = 121,
         DHCP_OPTION_PRIVATE_BASE                = 224,
         DHCP_OPTION_PRIVATE_LAST                = 254,
diff --git a/src/libsystemd-network/dhcp-server-internal.h b/src/libsystemd-network/dhcp-server-internal.h
index 58750c4418..6cc794c937 100644
--- a/src/libsystemd-network/dhcp-server-internal.h
+++ b/src/libsystemd-network/dhcp-server-internal.h
@@ -26,7 +26,6 @@
 #include "sd-dhcp-server.h"
 
 #include "hashmap.h"
-#include "refcnt.h"
 #include "util.h"
 #include "log.h"
 
@@ -34,7 +33,7 @@
 
 typedef struct DHCPClientId {
         size_t length;
-        uint8_t *data;
+        void *data;
 } DHCPClientId;
 
 typedef struct DHCPLease {
@@ -47,7 +46,7 @@ typedef struct DHCPLease {
 } DHCPLease;
 
 struct sd_dhcp_server {
-        RefCount n_ref;
+        unsigned n_ref;
 
         sd_event *event;
         int event_priority;
@@ -55,15 +54,22 @@ struct sd_dhcp_server {
         int fd;
         int fd_raw;
 
-        int index;
+        int ifindex;
         be32_t address;
         be32_t netmask;
         be32_t pool_start;
         size_t pool_size;
         size_t next_offer;
 
+        char *timezone;
+
+        struct in_addr *ntp, *dns;
+        unsigned n_ntp, n_dns;
+
         Hashmap *leases_by_client_id;
         DHCPLease **bound_leases;
+
+        uint32_t max_lease_time, default_lease_time;
 };
 
 typedef struct DHCPRequest {
@@ -75,7 +81,7 @@ typedef struct DHCPRequest {
         size_t max_optlen;
         be32_t server_id;
         be32_t requested_ip;
-        int lifetime;
+        uint32_t lifetime;
 } DHCPRequest;
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(sd_dhcp_server*, sd_dhcp_server_unref);
diff --git a/src/libsystemd-network/dhcp6-lease-internal.h b/src/libsystemd-network/dhcp6-lease-internal.h
index 037f580eb6..4edecf7711 100644
--- a/src/libsystemd-network/dhcp6-lease-internal.h
+++ b/src/libsystemd-network/dhcp6-lease-internal.h
@@ -24,13 +24,11 @@
 
 #include <stdint.h>
 
-#include "refcnt.h"
-
 #include "sd-dhcp6-lease.h"
 #include "dhcp6-internal.h"
 
 struct sd_dhcp6_lease {
-        RefCount n_ref;
+        unsigned n_ref;
 
         uint8_t *serverid;
         size_t serverid_len;
diff --git a/src/libsystemd-network/dhcp6-network.c b/src/libsystemd-network/dhcp6-network.c
index fe56c10273..187975364b 100644
--- a/src/libsystemd-network/dhcp6-network.c
+++ b/src/libsystemd-network/dhcp6-network.c
@@ -41,8 +41,7 @@
         { { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } } }
 
-int dhcp_network_icmp6_bind_router_solicitation(int index)
-{
+int dhcp_network_icmp6_bind_router_solicitation(int index) {
         struct icmp6_filter filter = { };
         struct ipv6_mreq mreq = {
                 .ipv6mr_multiaddr = IN6ADDR_ALL_NODES_MULTICAST_INIT,
@@ -92,8 +91,7 @@ int dhcp_network_icmp6_bind_router_solicitation(int index)
         return r;
 }
 
-int dhcp_network_icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr)
-{
+int dhcp_network_icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr) {
         struct sockaddr_in6 dst = {
                 .sin6_family = AF_INET6,
                 .sin6_addr = IN6ADDR_ALL_ROUTERS_MULTICAST_INIT,
diff --git a/src/libsystemd-network/dhcp6-option.c b/src/libsystemd-network/dhcp6-option.c
index 2fa4d5fac8..f41bebced0 100644
--- a/src/libsystemd-network/dhcp6-option.c
+++ b/src/libsystemd-network/dhcp6-option.c
@@ -338,9 +338,7 @@ int dhcp6_option_parse_ip6addrs(uint8_t *optval, uint16_t optlen,
         return count;
 }
 
-int dhcp6_option_parse_domainname(const uint8_t *optval, uint16_t optlen,
-                                  char ***str_arr)
-{
+int dhcp6_option_parse_domainname(const uint8_t *optval, uint16_t optlen, char ***str_arr) {
         size_t pos = 0, idx = 0;
         _cleanup_free_ char **names = NULL;
         int r;
diff --git a/src/libsystemd-network/lldp-internal.c b/src/libsystemd-network/lldp-internal.c
index 0f354461f7..3c04898e92 100644
--- a/src/libsystemd-network/lldp-internal.c
+++ b/src/libsystemd-network/lldp-internal.c
@@ -374,9 +374,8 @@ int lldp_mib_add_objects(Prioq *by_expiry,
                 }
 
                 /* Admission Control: Can this port attached to the existing chassis ? */
-                if (REFCNT_GET(c->n_ref) >= LLDP_MIB_MAX_PORT_PER_CHASSIS) {
-                        log_lldp("Port limit reached. Chassis has: %d ports. Dropping ...",
-                                 REFCNT_GET(c->n_ref));
+                if (c->n_ref >= LLDP_MIB_MAX_PORT_PER_CHASSIS) {
+                        log_lldp("Port limit reached. Chassis has: %d ports. Dropping ...", c->n_ref);
 
                         c = NULL;
                         goto drop;
@@ -394,7 +393,7 @@ int lldp_mib_add_objects(Prioq *by_expiry,
 
         /* Attach new port to chassis */
         LIST_PREPEND(port, c->ports, p);
-        REFCNT_INC(c->n_ref);
+        c->n_ref ++;
 
         p = NULL;
         c = NULL;
@@ -424,7 +423,8 @@ void lldp_neighbour_port_remove_and_free(lldp_neighbour_port *p) {
         lldp_neighbour_port_free(p);
 
         /* Drop the Chassis if no port is attached  */
-        if (REFCNT_DEC(c->n_ref) <= 1) {
+        c->n_ref --;
+        if (c->n_ref <= 1) {
                 hashmap_remove(c->neighbour_mib, &c->chassis_id);
                 lldp_chassis_free(c);
         }
@@ -486,7 +486,7 @@ void lldp_chassis_free(lldp_chassis *c) {
         if (!c)
                 return;
 
-        if (REFCNT_GET(c->n_ref) > 1)
+        if (c->n_ref > 1)
                 return;
 
         free(c->chassis_id.data);
@@ -513,7 +513,7 @@ int lldp_chassis_new(tlv_packet *tlv,
         if (!c)
                 return -ENOMEM;
 
-        c->n_ref = REFCNT_INIT;
+        c->n_ref = 1;
         c->chassis_id.type = type;
         c->chassis_id.length = length;
 
diff --git a/src/libsystemd-network/lldp-internal.h b/src/libsystemd-network/lldp-internal.h
index 8e09ee8f3a..f4eadbb87e 100644
--- a/src/libsystemd-network/lldp-internal.h
+++ b/src/libsystemd-network/lldp-internal.h
@@ -24,7 +24,6 @@
 
 #include "log.h"
 #include "list.h"
-#include "refcnt.h"
 #include "lldp-tlv.h"
 #include "prioq.h"
 
@@ -63,7 +62,7 @@ struct lldp_chassis_id {
 };
 
 struct lldp_chassis {
-        RefCount n_ref;
+        unsigned n_ref;
 
         lldp_chassis_id chassis_id;
 
diff --git a/src/libsystemd-network/network-internal.c b/src/libsystemd-network/network-internal.c
index d8357c687e..26bd4088d9 100644
--- a/src/libsystemd-network/network-internal.c
+++ b/src/libsystemd-network/network-internal.c
@@ -525,7 +525,7 @@ int deserialize_dhcp_routes(struct sd_dhcp_route **ret, size_t *ret_size, size_t
         return 0;
 }
 
-int serialize_dhcp_option(FILE *f, const char *key, const uint8_t *data, size_t size) {
+int serialize_dhcp_option(FILE *f, const char *key, const void *data, size_t size) {
         _cleanup_free_ char *hex_buf = NULL;
 
         assert(f);
@@ -541,7 +541,7 @@ int serialize_dhcp_option(FILE *f, const char *key, const uint8_t *data, size_t
         return 0;
 }
 
-int deserialize_dhcp_option(uint8_t **data, size_t *data_len, const char *string) {
+int deserialize_dhcp_option(void **data, size_t *data_len, const char *string) {
         assert(data);
         assert(data_len);
         assert(string);
diff --git a/src/libsystemd-network/network-internal.h b/src/libsystemd-network/network-internal.h
index dca82646ce..d5d4ef42f2 100644
--- a/src/libsystemd-network/network-internal.h
+++ b/src/libsystemd-network/network-internal.h
@@ -77,5 +77,5 @@ struct sd_dhcp_route;
 void serialize_dhcp_routes(FILE *f, const char *key, struct sd_dhcp_route *routes, size_t size);
 int deserialize_dhcp_routes(struct sd_dhcp_route **ret, size_t *ret_size, size_t *ret_allocated, const char *string);
 
-int serialize_dhcp_option(FILE *f, const char *key, const uint8_t *data, size_t size);
-int deserialize_dhcp_option(uint8_t **data, size_t *data_len, const char *string);
+int serialize_dhcp_option(FILE *f, const char *key, const void *data, size_t size);
+int deserialize_dhcp_option(void **data, size_t *data_len, const char *string);
diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c
index 46104afded..c12768cf0e 100644
--- a/src/libsystemd-network/sd-dhcp-client.c
+++ b/src/libsystemd-network/sd-dhcp-client.c
@@ -27,7 +27,6 @@
 #include <sys/ioctl.h>
 
 #include "util.h"
-#include "refcnt.h"
 #include "random-util.h"
 #include "async.h"
 
@@ -41,7 +40,7 @@
 #define MAX_MAC_ADDR_LEN CONST_MAX(INFINIBAND_ALEN, ETH_ALEN)
 
 struct sd_dhcp_client {
-        RefCount n_ref;
+        unsigned n_ref;
 
         DHCPState state;
         sd_event *event;
@@ -106,7 +105,6 @@ static const uint8_t default_req_opts[] = {
         DHCP_OPTION_HOST_NAME,
         DHCP_OPTION_DOMAIN_NAME,
         DHCP_OPTION_DOMAIN_NAME_SERVER,
-        DHCP_OPTION_NTP_SERVER,
 };
 
 static int client_receive_message_raw(sd_event_source *s, int fd,
@@ -377,8 +375,7 @@ static int client_initialize(sd_dhcp_client *client) {
         client->state = DHCP_STATE_INIT;
         client->xid = 0;
 
-        if (client->lease)
-                client->lease = sd_dhcp_lease_unref(client->lease);
+        client->lease = sd_dhcp_lease_unref(client->lease);
 
         return 0;
 }
@@ -1055,18 +1052,16 @@ static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer,
         }
 
         lease->next_server = offer->siaddr;
-
         lease->address = offer->yiaddr;
 
-        if (lease->address == INADDR_ANY ||
-            lease->server_address == INADDR_ANY ||
+        if (lease->address == 0 ||
+            lease->server_address == 0 ||
             lease->lifetime == 0) {
-                log_dhcp_client(client, "received lease lacks address, server "
-                                "address or lease lifetime, ignoring");
+                log_dhcp_client(client, "received lease lacks address, server address or lease lifetime, ignoring");
                 return -ENOMSG;
         }
 
-        if (lease->subnet_mask == INADDR_ANY) {
+        if (!lease->have_subnet_mask) {
                 r = dhcp_lease_set_default_subnet_mask(lease);
                 if (r < 0) {
                         log_dhcp_client(client, "received lease lacks subnet "
@@ -1168,13 +1163,17 @@ static int client_handle_ack(sd_dhcp_client *client, DHCPMessage *ack,
         return r;
 }
 
-static uint64_t client_compute_timeout(sd_dhcp_client *client,
-                                       uint32_t lifetime, double factor) {
+static uint64_t client_compute_timeout(sd_dhcp_client *client, uint32_t lifetime, double factor) {
         assert(client);
         assert(client->request_sent);
-        assert(lifetime);
+        assert(lifetime > 0);
 
-        return client->request_sent + ((lifetime - 3) * USEC_PER_SEC * factor) +
+        if (lifetime > 3)
+                lifetime -= 3;
+        else
+                lifetime = 0;
+
+        return client->request_sent + (lifetime * USEC_PER_SEC * factor) +
                 + (random_u32() & 0x1fffff);
 }
 
@@ -1206,7 +1205,7 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
 
         /* convert the various timeouts from relative (secs) to absolute (usecs) */
         lifetime_timeout = client_compute_timeout(client, client->lease->lifetime, 1);
-        if (client->lease->t1 && client->lease->t2) {
+        if (client->lease->t1 > 0 && client->lease->t2 > 0) {
                 /* both T1 and T2 are given */
                 if (client->lease->t1 < client->lease->t2 &&
                     client->lease->t2 < client->lease->lifetime) {
@@ -1220,7 +1219,7 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
                         t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
                         client->lease->t1 = client->lease->lifetime / 2;
                 }
-        } else if (client->lease->t2 && client->lease->t2 < client->lease->lifetime) {
+        } else if (client->lease->t2 > 0 && client->lease->t2 < client->lease->lifetime) {
                 /* only T2 is given, and it is valid */
                 t2_timeout = client_compute_timeout(client, client->lease->t2, 1);
                 t1_timeout = client_compute_timeout(client, client->lease->lifetime, 0.5);
@@ -1230,7 +1229,7 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) {
                         t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
                         client->lease->t2 = (client->lease->lifetime * 7) / 8;
                 }
-        } else if (client->lease->t1 && client->lease->t1 < client->lease->lifetime) {
+        } else if (client->lease->t1 > 0 && client->lease->t1 < client->lease->lifetime) {
                 /* only T1 is given, and it is valid */
                 t1_timeout = client_compute_timeout(client, client->lease->t1, 1);
                 t2_timeout = client_compute_timeout(client, client->lease->lifetime, 7.0 / 8.0);
@@ -1676,30 +1675,41 @@ sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) {
 }
 
 sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client) {
-        if (client)
-                assert_se(REFCNT_INC(client->n_ref) >= 2);
+
+        if (!client)
+                return NULL;
+
+        assert(client->n_ref >= 1);
+        client->n_ref++;
 
         return client;
 }
 
 sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) {
-        if (client && REFCNT_DEC(client->n_ref) == 0) {
-                log_dhcp_client(client, "FREE");
 
-                client_initialize(client);
+        if (!client)
+                return NULL;
 
-                client->receive_message =
-                        sd_event_source_unref(client->receive_message);
+        assert(client->n_ref >= 1);
+        client->n_ref--;
 
-                sd_dhcp_client_detach_event(client);
+        if (client->n_ref > 0)
+                return NULL;
 
-                sd_dhcp_lease_unref(client->lease);
+        log_dhcp_client(client, "FREE");
 
-                free(client->req_opts);
-                free(client->hostname);
-                free(client->vendor_class_identifier);
-                free(client);
-        }
+        client_initialize(client);
+
+        client->receive_message = sd_event_source_unref(client->receive_message);
+
+        sd_dhcp_client_detach_event(client);
+
+        sd_dhcp_lease_unref(client->lease);
+
+        free(client->req_opts);
+        free(client->hostname);
+        free(client->vendor_class_identifier);
+        free(client);
 
         return NULL;
 }
@@ -1713,7 +1723,7 @@ int sd_dhcp_client_new(sd_dhcp_client **ret) {
         if (!client)
                 return -ENOMEM;
 
-        client->n_ref = REFCNT_INIT;
+        client->n_ref = 1;
         client->state = DHCP_STATE_INIT;
         client->index = -1;
         client->fd = -1;
diff --git a/src/libsystemd-network/sd-dhcp-lease.c b/src/libsystemd-network/sd-dhcp-lease.c
index f5b9e22589..6551e7c94c 100644
--- a/src/libsystemd-network/sd-dhcp-lease.c
+++ b/src/libsystemd-network/sd-dhcp-lease.c
@@ -28,18 +28,31 @@
 #include "unaligned.h"
 #include "in-addr-util.h"
 #include "hostname-util.h"
+#include "dns-domain.h"
+#include "network-internal.h"
 #include "dhcp-protocol.h"
 #include "dhcp-lease-internal.h"
 #include "sd-dhcp-lease.h"
-#include "network-internal.h"
-#include "dns-domain.h"
 
 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
+        if (lease->address == 0)
+                return -ENODATA;
+
         addr->s_addr = lease->address;
+        return 0;
+}
 
+int sd_dhcp_lease_get_broadcast(sd_dhcp_lease *lease, struct in_addr *addr) {
+        assert_return(lease, -EINVAL);
+        assert_return(addr, -EINVAL);
+
+        if (!lease->have_broadcast)
+                return -ENODATA;
+
+        addr->s_addr = lease->broadcast;
         return 0;
 }
 
@@ -47,8 +60,32 @@ int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime) {
         assert_return(lease, -EINVAL);
         assert_return(lifetime, -EINVAL);
 
+        if (lease->lifetime <= 0)
+                return -ENODATA;
+
         *lifetime = lease->lifetime;
+        return 0;
+}
+
+int sd_dhcp_lease_get_t1(sd_dhcp_lease *lease, uint32_t *t1) {
+        assert_return(lease, -EINVAL);
+        assert_return(t1, -EINVAL);
+
+        if (lease->t1 <= 0)
+                return -ENODATA;
 
+        *t1 = lease->t1;
+        return 0;
+}
+
+int sd_dhcp_lease_get_t2(sd_dhcp_lease *lease, uint32_t *t2) {
+        assert_return(lease, -EINVAL);
+        assert_return(t2, -EINVAL);
+
+        if (lease->t2 <= 0)
+                return -ENODATA;
+
+        *t2 = lease->t2;
         return 0;
 }
 
@@ -56,11 +93,10 @@ int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
         assert_return(lease, -EINVAL);
         assert_return(mtu, -EINVAL);
 
-        if (lease->mtu)
-                *mtu = lease->mtu;
-        else
-                return -ENOENT;
+        if (lease->mtu <= 0)
+                return -ENODATA;
 
+        *mtu = lease->mtu;
         return 0;
 }
 
@@ -68,37 +104,32 @@ int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        if (lease->dns_size) {
-                *addr = lease->dns;
-                return lease->dns_size;
-        } else
-                return -ENOENT;
+        if (lease->dns_size <= 0)
+                return -ENODATA;
 
-        return 0;
+        *addr = lease->dns;
+        return (int) lease->dns_size;
 }
 
 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        if (lease->ntp_size) {
-                *addr = lease->ntp;
-                return lease->ntp_size;
-        } else
-                return -ENOENT;
+        if (lease->ntp_size <= 0)
+                return -ENODATA;
 
-        return 0;
+        *addr = lease->ntp;
+        return (int) lease->ntp_size;
 }
 
 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname) {
         assert_return(lease, -EINVAL);
         assert_return(domainname, -EINVAL);
 
-        if (lease->domainname)
-                *domainname = lease->domainname;
-        else
-                return -ENOENT;
+        if (!lease->domainname)
+                return -ENODATA;
 
+        *domainname = lease->domainname;
         return 0;
 }
 
@@ -106,11 +137,10 @@ int sd_dhcp_lease_get_hostname(sd_dhcp_lease *lease, const char **hostname) {
         assert_return(lease, -EINVAL);
         assert_return(hostname, -EINVAL);
 
-        if (lease->hostname)
-                *hostname = lease->hostname;
-        else
-                return -ENOENT;
+        if (!lease->hostname)
+                return -ENODATA;
 
+        *hostname = lease->hostname;
         return 0;
 }
 
@@ -118,11 +148,10 @@ int sd_dhcp_lease_get_root_path(sd_dhcp_lease *lease, const char **root_path) {
         assert_return(lease, -EINVAL);
         assert_return(root_path, -EINVAL);
 
-        if (lease->root_path)
-                *root_path = lease->root_path;
-        else
-                return -ENOENT;
+        if (!lease->root_path)
+                return -ENODATA;
 
+        *root_path = lease->root_path;
         return 0;
 }
 
@@ -130,11 +159,10 @@ int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, struct in_addr *addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        if (lease->router != INADDR_ANY)
-                addr->s_addr = lease->router;
-        else
-                return -ENOENT;
+        if (lease->router == 0)
+                return -ENODATA;
 
+        addr->s_addr = lease->router;
         return 0;
 }
 
@@ -142,8 +170,10 @@ int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        addr->s_addr = lease->subnet_mask;
+        if (!lease->have_subnet_mask)
+                return -ENODATA;
 
+        addr->s_addr = lease->subnet_mask;
         return 0;
 }
 
@@ -151,8 +181,10 @@ int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *ad
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        addr->s_addr = lease->server_address;
+        if (lease->server_address == 0)
+                return -ENODATA;
 
+        addr->s_addr = lease->server_address;
         return 0;
 }
 
@@ -160,136 +192,134 @@ int sd_dhcp_lease_get_next_server(sd_dhcp_lease *lease, struct in_addr *addr) {
         assert_return(lease, -EINVAL);
         assert_return(addr, -EINVAL);
 
-        addr->s_addr = lease->next_server;
+        if (lease->next_server == 0)
+                return -ENODATA;
 
+        addr->s_addr = lease->next_server;
         return 0;
 }
 
 int sd_dhcp_lease_get_routes(sd_dhcp_lease *lease, struct sd_dhcp_route **routes) {
-
         assert_return(lease, -EINVAL);
         assert_return(routes, -EINVAL);
 
-        if (lease->static_route_size) {
-                *routes = lease->static_route;
-                return lease->static_route_size;
-        } else
-                return -ENOENT;
+        if (lease->static_route_size <= 0)
+                return -ENODATA;
 
-        return 0;
+        *routes = lease->static_route;
+        return (int) lease->static_route_size;
 }
 
-int sd_dhcp_lease_get_vendor_specific(sd_dhcp_lease *lease, const uint8_t **data,
-                                      size_t *data_len) {
+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);
         assert_return(data_len, -EINVAL);
 
-        if (!lease->vendor_specific)
-                return -ENOENT;
+        if (lease->vendor_specific_len <= 0)
+                return -ENODATA;
 
         *data = lease->vendor_specific;
         *data_len = lease->vendor_specific_len;
-
         return 0;
 }
 
 sd_dhcp_lease *sd_dhcp_lease_ref(sd_dhcp_lease *lease) {
-        if (lease)
-                assert_se(REFCNT_INC(lease->n_ref) >= 2);
+
+        if (!lease)
+                return NULL;
+
+        assert(lease->n_ref >= 1);
+        lease->n_ref++;
 
         return lease;
 }
 
 sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease) {
-        if (lease && REFCNT_DEC(lease->n_ref) == 0) {
-                while (lease->private_options) {
-                        struct sd_dhcp_raw_option *option = lease->private_options;
 
-                        LIST_REMOVE(options, lease->private_options, option);
+        if (!lease)
+                return NULL;
 
-                        free(option->data);
-                        free(option);
-                }
-                free(lease->hostname);
-                free(lease->domainname);
-                free(lease->dns);
-                free(lease->ntp);
-                free(lease->static_route);
-                free(lease->client_id);
-                free(lease->vendor_specific);
-                free(lease);
-        }
+        assert(lease->n_ref >= 1);
+        lease->n_ref--;
 
-        return NULL;
-}
+        if (lease->n_ref > 0)
+                return NULL;
 
-static void lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_t min) {
-        assert(option);
-        assert(ret);
+        while (lease->private_options) {
+                struct sd_dhcp_raw_option *option = lease->private_options;
 
-        if (len == 4) {
-                *ret = unaligned_read_be32((be32_t*) option);
+                LIST_REMOVE(options, lease->private_options, option);
 
-                if (*ret < min)
-                        *ret = min;
+                free(option->data);
+                free(option);
         }
-}
 
-static void lease_parse_s32(const uint8_t *option, size_t len, int32_t *ret) {
-        lease_parse_u32(option, len, (uint32_t *)ret, 0);
+        free(lease->hostname);
+        free(lease->domainname);
+        free(lease->dns);
+        free(lease->ntp);
+        free(lease->static_route);
+        free(lease->client_id);
+        free(lease->vendor_specific);
+        free(lease);
+
+        return NULL;
 }
 
-static void lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
+static int lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_t min) {
         assert(option);
         assert(ret);
 
-        if (len == 2) {
-                *ret = unaligned_read_be16((be16_t*) option);
+        if (len != 4)
+                return -EINVAL;
 
-                if (*ret < min)
-                        *ret = min;
-        }
+        *ret = unaligned_read_be32((be32_t*) option);
+        if (*ret < min)
+                *ret = min;
+
+        return 0;
 }
 
-static void lease_parse_be32(const uint8_t *option, size_t len, be32_t *ret) {
+static int lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
         assert(option);
         assert(ret);
 
-        if (len == 4)
-                memcpy(ret, option, 4);
-}
+        if (len != 2)
+                return -EINVAL;
 
-static void lease_parse_bool(const uint8_t *option, size_t len, bool *ret) {
-        assert(option);
-        assert(ret);
+        *ret = unaligned_read_be16((be16_t*) option);
+        if (*ret < min)
+                *ret = min;
 
-        if (len == 1)
-                *ret = !!(*option);
+        return 0;
 }
 
-static void lease_parse_u8(const uint8_t *option, size_t len, uint8_t *ret, uint8_t min) {
+static int lease_parse_be32(const uint8_t *option, size_t len, be32_t *ret) {
         assert(option);
         assert(ret);
 
-        if (len == 1) {
-                *ret = *option;
+        if (len != 4)
+                return -EINVAL;
 
-                if (*ret < min)
-                        *ret = min;
-        }
+        memcpy(ret, option, 4);
+        return 0;
 }
 
 static int lease_parse_string(const uint8_t *option, size_t len, char **ret) {
         assert(option);
         assert(ret);
 
-        if (len >= 1) {
+        if (len <= 0)
+                *ret = mfree(*ret);
+        else {
                 char *string;
 
+                if (memchr(option, 0, len))
+                        return -EINVAL;
+
                 string = strndup((const char *)option, len);
                 if (!string)
-                        return -errno;
+                        return -ENOMEM;
 
                 free(*ret);
                 *ret = string;
@@ -298,48 +328,47 @@ static int lease_parse_string(const uint8_t *option, size_t len, char **ret) {
         return 0;
 }
 
-static int lease_parse_in_addrs_aux(const uint8_t *option, size_t len, struct in_addr **ret, size_t *ret_size, size_t mult) {
+static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
         assert(option);
         assert(ret);
-        assert(ret_size);
+        assert(n_ret);
 
-        if (len && !(len % (4 * mult))) {
-                size_t size;
+        if (len <= 0) {
+                *ret = mfree(*ret);
+                *n_ret = 0;
+        } else {
+                size_t n_addresses;
                 struct in_addr *addresses;
 
-                size = len / 4;
+                if (len % 4 != 0)
+                        return -EINVAL;
+
+                n_addresses = len / 4;
 
-                addresses = newdup(struct in_addr, option, size);
+                addresses = newdup(struct in_addr, option, n_addresses);
                 if (!addresses)
                         return -ENOMEM;
 
                 free(*ret);
                 *ret = addresses;
-                *ret_size = size;
+                *n_ret = n_addresses;
         }
 
         return 0;
 }
 
-static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *ret_size) {
-        return lease_parse_in_addrs_aux(option, len, ret, ret_size, 1);
-}
-
-static int lease_parse_in_addrs_pairs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *ret_size) {
-        return lease_parse_in_addrs_aux(option, len, ret, ret_size, 2);
-}
-
-static int lease_parse_routes(const uint8_t *option, size_t len, struct sd_dhcp_route **routes,
-        size_t *routes_size, size_t *routes_allocated) {
+static int lease_parse_routes(
+                const uint8_t *option, size_t len,
+                struct sd_dhcp_route **routes, size_t *routes_size, size_t *routes_allocated) {
 
         struct in_addr addr;
 
-        assert(option);
+        assert(option || len <= 0);
         assert(routes);
         assert(routes_size);
         assert(routes_allocated);
 
-        if (!len)
+        if (len <= 0)
                 return 0;
 
         if (len % 8 != 0)
@@ -354,15 +383,15 @@ static int lease_parse_routes(const uint8_t *option, size_t len, struct sd_dhcp_
 
                 r = in_addr_default_prefixlen((struct in_addr*) option, &route->dst_prefixlen);
                 if (r < 0) {
-                        log_error("Failed to determine destination prefix length from class based IP, ignoring");
+                        log_debug("Failed to determine destination prefix length from class based IP, ignoring");
                         continue;
                 }
 
-                lease_parse_be32(option, 4, &addr.s_addr);
+                assert_se(lease_parse_be32(option, 4, &addr.s_addr) >= 0);
                 route->dst_addr = inet_makeaddr(inet_netof(addr), 0);
                 option += 4;
 
-                lease_parse_be32(option, 4, &route->gw_addr.s_addr);
+                assert_se(lease_parse_be32(option, 4, &route->gw_addr.s_addr) >= 0);
                 option += 4;
 
                 len -= 8;
@@ -373,14 +402,18 @@ static int lease_parse_routes(const uint8_t *option, size_t len, struct sd_dhcp_
 }
 
 /* parses RFC3442 Classless Static Route Option */
-static int lease_parse_classless_routes(const uint8_t *option, size_t len, struct sd_dhcp_route **routes,
-        size_t *routes_size, size_t *routes_allocated) {
+static int lease_parse_classless_routes(
+                const uint8_t *option, size_t len,
+                struct sd_dhcp_route **routes, size_t *routes_size, size_t *routes_allocated) {
 
-        assert(option);
+        assert(option || len <= 0);
         assert(routes);
         assert(routes_size);
         assert(routes_allocated);
 
+        if (len <= 0)
+                return 0;
+
         /* option format: (subnet-mask-width significant-subnet-octets gateway-ip)*  */
 
         while (len > 0) {
@@ -388,7 +421,7 @@ static int lease_parse_classless_routes(const uint8_t *option, size_t len, struc
                 struct sd_dhcp_route *route;
 
                 if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + 1))
-                    return -ENOMEM;
+                        return -ENOMEM;
 
                 route = *routes + *routes_size;
 
@@ -419,223 +452,222 @@ static int lease_parse_classless_routes(const uint8_t *option, size_t len, struc
         return 0;
 }
 
-int dhcp_lease_parse_options(uint8_t code, uint8_t len, const uint8_t *option,
-                              void *user_data) {
-        sd_dhcp_lease *lease = user_data;
+int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
+        sd_dhcp_lease *lease = userdata;
         int r;
 
         assert(lease);
 
         switch(code) {
 
-        case DHCP_OPTION_TIME_OFFSET:
-                lease_parse_s32(option, len, &lease->time_offset);
-
-                break;
-
-        case DHCP_OPTION_INTERFACE_MTU_AGING_TIMEOUT:
-                lease_parse_u32(option, len, &lease->mtu_aging_timeout, 0);
-
-                break;
-
         case DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
-                lease_parse_u32(option, len, &lease->lifetime, 1);
+                r = lease_parse_u32(option, len, &lease->lifetime, 1);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse lease time, ignoring: %m");
 
                 break;
 
         case DHCP_OPTION_SERVER_IDENTIFIER:
-                lease_parse_be32(option, len, &lease->server_address);
+                r = lease_parse_be32(option, len, &lease->server_address);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse server identifier, ignoring: %m");
 
                 break;
 
         case DHCP_OPTION_SUBNET_MASK:
-                lease_parse_be32(option, len, &lease->subnet_mask);
-
+                r = lease_parse_be32(option, len, &lease->subnet_mask);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse subnet mask, ignoring: %m");
+                else
+                        lease->have_subnet_mask = true;
                 break;
 
         case DHCP_OPTION_BROADCAST:
-                lease_parse_be32(option, len, &lease->broadcast);
-
+                r = lease_parse_be32(option, len, &lease->broadcast);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse broadcast address, ignoring: %m");
+                else
+                        lease->have_broadcast = true;
                 break;
 
         case DHCP_OPTION_ROUTER:
-                if(len >= 4)
-                        lease_parse_be32(option, 4, &lease->router);
-
+                if (len >= 4) {
+                        r = lease_parse_be32(option, 4, &lease->router);
+                        if (r < 0)
+                                log_debug_errno(r, "Failed to parse router address, ignoring: %m");
+                }
                 break;
 
         case DHCP_OPTION_DOMAIN_NAME_SERVER:
                 r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
                 if (r < 0)
-                        return r;
-
+                        log_debug_errno(r, "Failed to parse DNS server, ignoring: %m");
                 break;
 
         case DHCP_OPTION_NTP_SERVER:
                 r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
                 if (r < 0)
-                        return r;
-
-                break;
-
-        case DHCP_OPTION_POLICY_FILTER:
-                r = lease_parse_in_addrs_pairs(option, len, &lease->policy_filter, &lease->policy_filter_size);
-                if (r < 0)
-                        return r;
-
+                        log_debug_errno(r, "Failed to parse NTP server, ignoring: %m");
                 break;
 
         case DHCP_OPTION_STATIC_ROUTE:
-                r = lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size,
-                        &lease->static_route_allocated);
+                r = lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size, &lease->static_route_allocated);
                 if (r < 0)
-                        return r;
-
+                        log_debug_errno(r, "Failed to parse static routes, ignoring: %m");
                 break;
 
         case DHCP_OPTION_INTERFACE_MTU:
-                lease_parse_u16(option, len, &lease->mtu, 68);
-
-                break;
-
-        case DHCP_OPTION_INTERFACE_MDR:
-                lease_parse_u16(option, len, &lease->mdr, 576);
-
-                break;
-
-        case DHCP_OPTION_INTERFACE_TTL:
-                lease_parse_u8(option, len, &lease->ttl, 1);
-
-                break;
-
-        case DHCP_OPTION_BOOT_FILE_SIZE:
-                lease_parse_u16(option, len, &lease->boot_file_size, 0);
-
+                r = lease_parse_u16(option, len, &lease->mtu, 68);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse MTU, ignoring: %m");
                 break;
 
-        case DHCP_OPTION_DOMAIN_NAME:
-        {
-                _cleanup_free_ char *domainname = NULL;
-                char *e;
+        case DHCP_OPTION_DOMAIN_NAME: {
+                _cleanup_free_ char *domainname = NULL, *normalized = NULL;
 
                 r = lease_parse_string(option, len, &domainname);
-                if (r < 0)
-                        return r;
-
-                /* Chop off trailing dot of domain name that some DHCP
-                 * servers send us back. Internally we want to store
-                 * host names without trailing dots and
-                 * host_name_is_valid() doesn't accept them. */
-                e = endswith(domainname, ".");
-                if (e)
-                        *e = 0;
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to parse domain name, ignoring: %m");
+                        return 0;
+                }
 
-                if (is_localhost(domainname))
-                        break;
+                r = dns_name_normalize(domainname, &normalized);
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to normalize domain name '%s': %m", domainname);
+                        return 0;
+                }
 
-                r = dns_name_is_valid(domainname);
-                if (r <= 0) {
-                        if (r < 0)
-                                log_error_errno(r, "Failed to validate domain name: %s: %m", domainname);
-                        if (r == 0)
-                                log_warning("Domain name is not valid, ignoring: %s", domainname);
+                if (is_localhost(normalized)) {
+                        log_debug_errno(r, "Detected 'localhost' as suggested domain name, ignoring.");
                         break;
                 }
 
                 free(lease->domainname);
-                lease->domainname = domainname;
-                domainname = NULL;
+                lease->domainname = normalized;
+                normalized = NULL;
 
                 break;
         }
-        case DHCP_OPTION_HOST_NAME:
-        {
-                _cleanup_free_ char *hostname = NULL;
-                char *e;
+
+        case DHCP_OPTION_HOST_NAME: {
+                _cleanup_free_ char *hostname = NULL, *normalized = NULL;
 
                 r = lease_parse_string(option, len, &hostname);
-                if (r < 0)
-                        return r;
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to parse host name, ignoring: %m");
+                        return 0;
+                }
 
-                e = endswith(hostname, ".");
-                if (e)
-                        *e = 0;
+                r = dns_name_normalize(hostname, &normalized);
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to normalize host name '%s', ignoring: %m", hostname);
+                        return 0;
+                }
 
-                if (!hostname_is_valid(hostname, false) || is_localhost(hostname))
-                        break;
+                if (is_localhost(normalized)) {
+                        log_debug_errno(r, "Detected 'localhost' as suggested host name, ignoring.");
+                        return 0;
+                }
 
-                free_and_replace(&lease->hostname, hostname);
-                hostname = NULL;
+                free(lease->hostname);
+                lease->hostname = normalized;
+                normalized = NULL;
 
                 break;
         }
+
         case DHCP_OPTION_ROOT_PATH:
                 r = lease_parse_string(option, len, &lease->root_path);
                 if (r < 0)
-                        return r;
-
+                        log_debug_errno(r, "Failed to parse root path, ignoring: %m");
                 break;
 
         case DHCP_OPTION_RENEWAL_T1_TIME:
-                lease_parse_u32(option, len, &lease->t1, 1);
-
+                r = lease_parse_u32(option, len, &lease->t1, 1);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse T1 time, ignoring: %m");
                 break;
 
         case DHCP_OPTION_REBINDING_T2_TIME:
-                lease_parse_u32(option, len, &lease->t2, 1);
-
+                r = lease_parse_u32(option, len, &lease->t2, 1);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse T2 time, ignoring: %m");
                 break;
 
-        case DHCP_OPTION_ENABLE_IP_FORWARDING:
-                lease_parse_bool(option, len, &lease->ip_forward);
-
+        case DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
+                r = lease_parse_classless_routes(
+                                option, len,
+                                &lease->static_route,
+                                &lease->static_route_size,
+                                &lease->static_route_allocated);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse classless routes, ignoring: %m");
                 break;
 
-        case DHCP_OPTION_ENABLE_IP_FORWARDING_NL:
-                lease_parse_bool(option, len, &lease->ip_forward_non_local);
+        case DHCP_OPTION_NEW_TZDB_TIMEZONE: {
+                _cleanup_free_ char *tz = NULL;
 
-                break;
+                r = lease_parse_string(option, len, &tz);
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to parse timezone option, ignoring: %m");
+                        return 0;
+                }
 
-        case DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
-                r = lease_parse_classless_routes(option, len, &lease->static_route, &lease->static_route_size,
-                        &lease->static_route_allocated);
-                if (r < 0)
-                        return r;
+                if (!timezone_is_valid(tz)) {
+                        log_debug_errno(r, "Timezone is not valid, ignoring: %m");
+                        return 0;
+                }
+
+                free(lease->timezone);
+                lease->timezone = tz;
+                tz = NULL;
 
                 break;
+        }
 
         case DHCP_OPTION_VENDOR_SPECIFIC:
-                if (len >= 1) {
-                        free(lease->vendor_specific);
-                        lease->vendor_specific = memdup(option, len);
-                        if (!lease->vendor_specific)
+
+                if (len <= 0)
+                        lease->vendor_specific = mfree(lease->vendor_specific);
+                else {
+                        void *p;
+
+                        p = memdup(option, len);
+                        if (!p)
                                 return -ENOMEM;
-                        lease->vendor_specific_len = len;
-                }
 
-               break;
+                        free(lease->vendor_specific);
+                        lease->vendor_specific = p;
+                }
 
-        default:
-                if (code < DHCP_OPTION_PRIVATE_BASE || code > DHCP_OPTION_PRIVATE_LAST)
-                    break;
+                lease->vendor_specific_len = len;
+                break;
 
+        case DHCP_OPTION_PRIVATE_BASE ... DHCP_OPTION_PRIVATE_LAST:
                 r = dhcp_lease_insert_private_option(lease, code, option, len);
                 if (r < 0)
                         return r;
+
+                break;
+
+        default:
+                log_debug("Ignoring option DHCP option %i while parsing.", code);
+                break;
         }
 
         return 0;
 }
 
-int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag,
-                                     const uint8_t *data, uint8_t len) {
+int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag, const void *data, uint8_t len) {
         struct sd_dhcp_raw_option *cur, *option;
 
+        assert(lease);
+
         LIST_FOREACH(options, cur, lease->private_options) {
                 if (tag < cur->tag)
                         break;
-                else if (tag == cur->tag) {
-                        log_error("Ignoring duplicate option, tagged %d.", tag);
+                if (tag == cur->tag) {
+                        log_debug("Ignoring duplicate option, tagged %i.", tag);
                         return 0;
                 }
         }
@@ -653,7 +685,6 @@ int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag,
         }
 
         LIST_INSERT_BEFORE(options, lease->private_options, cur, option);
-
         return 0;
 }
 
@@ -665,24 +696,24 @@ int dhcp_lease_new(sd_dhcp_lease **ret) {
                 return -ENOMEM;
 
         lease->router = INADDR_ANY;
-        lease->n_ref = REFCNT_INIT;
-        LIST_HEAD_INIT(lease->private_options);
+        lease->n_ref = 1;
 
         *ret = lease;
         return 0;
 }
 
-int sd_dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
+int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
         _cleanup_free_ char *temp_path = NULL;
         _cleanup_fclose_ FILE *f = NULL;
         struct sd_dhcp_raw_option *option;
         struct in_addr address;
         const struct in_addr *addresses;
-        const uint8_t *client_id, *data;
+        const void *client_id, *data;
         size_t client_id_len, data_len;
         const char *string;
         uint16_t mtu;
         struct sd_dhcp_route *routes;
+        uint32_t t1, t2, lifetime;
         int r;
 
         assert(lease);
@@ -694,19 +725,16 @@ int sd_dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
 
         fchmod(fileno(f), 0644);
 
-        r = sd_dhcp_lease_get_address(lease, &address);
-        if (r < 0)
-                goto fail;
-
         fprintf(f,
-                "# This is private data. Do not parse.\n"
-                "ADDRESS=%s\n", inet_ntoa(address));
+                "# This is private data. Do not parse.\n");
 
-        r = sd_dhcp_lease_get_netmask(lease, &address);
-        if (r < 0)
-                goto fail;
+        r = sd_dhcp_lease_get_address(lease, &address);
+        if (r >= 0)
+                fprintf(f, "ADDRESS=%s\n", inet_ntoa(address));
 
-        fprintf(f, "NETMASK=%s\n", inet_ntoa(address));
+        r = sd_dhcp_lease_get_netmask(lease, &address);
+        if (r >= 0)
+                fprintf(f, "NETMASK=%s\n", inet_ntoa(address));
 
         r = sd_dhcp_lease_get_router(lease, &address);
         if (r >= 0)
@@ -714,28 +742,45 @@ int sd_dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
 
         r = sd_dhcp_lease_get_server_identifier(lease, &address);
         if (r >= 0)
-                fprintf(f, "SERVER_ADDRESS=%s\n",
-                        inet_ntoa(address));
+                fprintf(f, "SERVER_ADDRESS=%s\n", inet_ntoa(address));
 
         r = sd_dhcp_lease_get_next_server(lease, &address);
         if (r >= 0)
                 fprintf(f, "NEXT_SERVER=%s\n", inet_ntoa(address));
 
+        r = sd_dhcp_lease_get_broadcast(lease, &address);
+        if (r >= 0)
+                fprintf(f, "BROADCAST=%s\n", inet_ntoa(address));
+
         r = sd_dhcp_lease_get_mtu(lease, &mtu);
         if (r >= 0)
                 fprintf(f, "MTU=%" PRIu16 "\n", mtu);
 
-        fputs("DNS=", f);
-        r = sd_dhcp_lease_get_dns(lease, &addresses);
+        r = sd_dhcp_lease_get_t1(lease, &t1);
+        if (r >= 0)
+                fprintf(f, "T1=%" PRIu32 "\n", t1);
+
+        r = sd_dhcp_lease_get_t2(lease, &t2);
+        if (r >= 0)
+                fprintf(f, "T2=%" PRIu32 "\n", t2);
+
+        r = sd_dhcp_lease_get_lifetime(lease, &lifetime);
         if (r >= 0)
+                fprintf(f, "LIFETIME=%" PRIu32 "\n", lifetime);
+
+        r = sd_dhcp_lease_get_dns(lease, &addresses);
+        if (r > 0) {
+                fputs("DNS=", f);
                 serialize_in_addrs(f, addresses, r);
-        fputs("\n", f);
+                fputs("\n", f);
+        }
 
-        fputs("NTP=", f);
         r = sd_dhcp_lease_get_ntp(lease, &addresses);
-        if (r >= 0)
+        if (r > 0) {
+                fputs("NTP=", f);
                 serialize_in_addrs(f, addresses, r);
-        fputs("\n", f);
+                fputs("\n", f);
+        }
 
         r = sd_dhcp_lease_get_domainname(lease, &string);
         if (r >= 0)
@@ -750,9 +795,13 @@ int sd_dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
                 fprintf(f, "ROOT_PATH=%s\n", string);
 
         r = sd_dhcp_lease_get_routes(lease, &routes);
-        if (r >= 0)
+        if (r > 0)
                 serialize_dhcp_routes(f, "ROUTES", routes, r);
 
+        r = sd_dhcp_lease_get_timezone(lease, &string);
+        if (r >= 0)
+                fprintf(f, "TIMEZONE=%s\n", string);
+
         r = sd_dhcp_lease_get_client_id(lease, &client_id, &client_id_len);
         if (r >= 0) {
                 _cleanup_free_ char *client_id_hex;
@@ -779,6 +828,7 @@ int sd_dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
 
         LIST_FOREACH(options, option, lease->private_options) {
                 char key[strlen("OPTION_000")+1];
+
                 snprintf(key, sizeof(key), "OPTION_%"PRIu8, option->tag);
                 r = serialize_dhcp_option(f, key, option->data, option->length);
                 if (r < 0)
@@ -803,16 +853,27 @@ fail:
         return log_error_errno(r, "Failed to save lease data %s: %m", lease_file);
 }
 
-int sd_dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
+int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
+
         _cleanup_dhcp_lease_unref_ sd_dhcp_lease *lease = NULL;
-        _cleanup_free_ char *address = NULL, *router = NULL, *netmask = NULL,
-                            *server_address = NULL, *next_server = NULL,
-                            *dns = NULL, *ntp = NULL, *mtu = NULL,
-                            *routes = NULL, *client_id_hex = NULL,
-                            *vendor_specific_hex = NULL,
-                            *options[DHCP_OPTION_PRIVATE_LAST -
-                                     DHCP_OPTION_PRIVATE_BASE + 1] = { NULL };
-        struct in_addr addr;
+        _cleanup_free_ char
+                *address = NULL,
+                *router = NULL,
+                *netmask = NULL,
+                *server_address = NULL,
+                *next_server = NULL,
+                *broadcast = NULL,
+                *dns = NULL,
+                *ntp = NULL,
+                *mtu = NULL,
+                *routes = NULL,
+                *client_id_hex = NULL,
+                *vendor_specific_hex = NULL,
+                *lifetime = NULL,
+                *t1 = NULL,
+                *t2 = NULL,
+                *options[DHCP_OPTION_PRIVATE_LAST - DHCP_OPTION_PRIVATE_BASE + 1] = {};
+
         int r, i;
 
         assert(lease_file);
@@ -828,6 +889,7 @@ int sd_dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                            "NETMASK", &netmask,
                            "SERVER_IDENTIFIER", &server_address,
                            "NEXT_SERVER", &next_server,
+                           "BROADCAST", &broadcast,
                            "DNS", &dns,
                            "NTP", &ntp,
                            "MTU", &mtu,
@@ -836,7 +898,11 @@ int sd_dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                            "ROOT_PATH", &lease->root_path,
                            "ROUTES", &routes,
                            "CLIENTID", &client_id_hex,
+                           "TIMEZONE", &lease->timezone,
                            "VENDOR_SPECIFIC", &vendor_specific_hex,
+                           "LIFETIME", &lifetime,
+                           "T1", &t1,
+                           "T2", &t2,
                            "OPTION_224", &options[0],
                            "OPTION_225", &options[1],
                            "OPTION_226", &options[2],
@@ -869,100 +935,123 @@ int sd_dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                            "OPTION_253", &options[29],
                            "OPTION_254", &options[30],
                            NULL);
-        if (r < 0) {
-                if (r == -ENOENT)
-                        return 0;
-
-                return log_error_errno(r, "Failed to read %s: %m", lease_file);
-        }
-
-        r = inet_pton(AF_INET, address, &addr);
         if (r < 0)
                 return r;
 
-        lease->address = addr.s_addr;
+        if (address) {
+                r = inet_pton(AF_INET, address, &lease->address);
+                if (r <= 0)
+                        log_debug_errno(errno, "Failed to parse address %s, ignoring: %m", address);
+        }
 
         if (router) {
-                r = inet_pton(AF_INET, router, &addr);
-                if (r < 0)
-                        return r;
-
-                lease->router = addr.s_addr;
+                r = inet_pton(AF_INET, router, &lease->router);
+                if (r <= 0)
+                        log_debug_errno(errno, "Failed to parse router %s, ignoring: %m", router);
         }
 
-        r = inet_pton(AF_INET, netmask, &addr);
-        if (r < 0)
-                return r;
-
-        lease->subnet_mask = addr.s_addr;
+        if (netmask) {
+                r = inet_pton(AF_INET, netmask, &lease->subnet_mask);
+                if (r <= 0)
+                        log_debug_errno(errno, "Failed to parse netmask %s, ignoring: %m", netmask);
+                else
+                        lease->have_subnet_mask = true;
+        }
 
         if (server_address) {
-                r = inet_pton(AF_INET, server_address, &addr);
-                if (r < 0)
-                        return r;
-
-                lease->server_address = addr.s_addr;
+                r = inet_pton(AF_INET, server_address, &lease->server_address);
+                if (r <= 0)
+                        log_debug_errno(errno, "Failed to parse netmask %s, ignoring: %m", server_address);
         }
 
         if (next_server) {
-                r = inet_pton(AF_INET, next_server, &addr);
-                if (r < 0)
-                        return r;
+                r = inet_pton(AF_INET, next_server, &lease->next_server);
+                if (r <= 0)
+                        log_debug_errno(errno, "Failed to parse next server %s, ignoring: %m", next_server);
+        }
 
-                lease->next_server = addr.s_addr;
+        if (broadcast) {
+                r = inet_pton(AF_INET, broadcast, &lease->broadcast);
+                if (r <= 0)
+                        log_debug_errno(errno, "Failed to parse broadcast address %s, ignoring: %m", broadcast);
+                else
+                        lease->have_broadcast = true;
         }
 
         if (dns) {
                 r = deserialize_in_addrs(&lease->dns, dns);
                 if (r < 0)
-                        return r;
-
-                lease->dns_size = r;
+                        log_debug_errno(r, "Failed to deserialize DNS servers %s, ignoring: %m", dns);
+                else
+                        lease->dns_size = r;
         }
 
         if (ntp) {
                 r = deserialize_in_addrs(&lease->ntp, ntp);
                 if (r < 0)
-                        return r;
-
-                lease->ntp_size = r;
+                        log_debug_errno(r, "Failed to deserialize NTP servers %s, ignoring: %m", ntp);
+                else
+                        lease->ntp_size = r;
         }
 
         if (mtu) {
-                uint16_t u;
-                if (sscanf(mtu, "%" SCNu16, &u) > 0)
-                        lease->mtu = u;
+                r = safe_atou16(mtu, &lease->mtu);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse MTU %s, ignoring: %m", mtu);
         }
 
         if (routes) {
-                r = deserialize_dhcp_routes(&lease->static_route, &lease->static_route_size,
-                                &lease->static_route_allocated, routes);
+                r = deserialize_dhcp_routes(
+                                &lease->static_route,
+                                &lease->static_route_size,
+                                &lease->static_route_allocated,
+                                routes);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse DHCP routes %s, ignoring: %m", routes);
+        }
+
+        if (lifetime) {
+                r = safe_atou32(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);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse T1 %s, ignoring: %m", t1);
+        }
+
+        if (t2) {
+                r = safe_atou32(t2, &lease->t2);
                 if (r < 0)
-                    return r;
+                        log_debug_errno(r, "Failed to parse T2 %s, ignoring: %m", t2);
         }
 
         if (client_id_hex) {
                 r = deserialize_dhcp_option(&lease->client_id, &lease->client_id_len, client_id_hex);
                 if (r < 0)
-                        return r;
+                        log_debug_errno(r, "Failed to parse client ID %s, ignoring: %m", client_id_hex);
         }
 
         if (vendor_specific_hex) {
                 r = deserialize_dhcp_option(&lease->vendor_specific, &lease->vendor_specific_len, vendor_specific_hex);
                 if (r < 0)
-                        return r;
+                        log_debug_errno(r, "Failed to parse vendor specific data %s, ignoring: %m", vendor_specific_hex);
         }
 
         for (i = 0; i <= DHCP_OPTION_PRIVATE_LAST - DHCP_OPTION_PRIVATE_BASE; i++) {
-                _cleanup_free_ uint8_t *data = NULL;
+                _cleanup_free_ void *data = NULL;
                 size_t len;
 
                 if (!options[i])
                         continue;
 
                 r = deserialize_dhcp_option(&data, &len, options[i]);
-                if (r < 0)
-                        return r;
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to parse private DHCP option %s, ignoring: %m", options[i]);
+                        continue;
+                }
 
                 r = dhcp_lease_insert_private_option(lease, DHCP_OPTION_PRIVATE_BASE + i, data, len);
                 if (r < 0)
@@ -976,12 +1065,14 @@ int sd_dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
 }
 
 int dhcp_lease_set_default_subnet_mask(sd_dhcp_lease *lease) {
-        struct in_addr address;
-        struct in_addr mask;
+        struct in_addr address, mask;
         int r;
 
         assert(lease);
 
+        if (lease->address == 0)
+                return -ENODATA;
+
         address.s_addr = lease->address;
 
         /* fall back to the default subnet masks based on address class */
@@ -990,35 +1081,53 @@ int dhcp_lease_set_default_subnet_mask(sd_dhcp_lease *lease) {
                 return r;
 
         lease->subnet_mask = mask.s_addr;
+        lease->have_subnet_mask = true;
 
         return 0;
 }
 
-int sd_dhcp_lease_get_client_id(sd_dhcp_lease *lease, const uint8_t **client_id,
-                                size_t *client_id_len) {
+int sd_dhcp_lease_get_client_id(sd_dhcp_lease *lease, const void **client_id, size_t *client_id_len) {
         assert_return(lease, -EINVAL);
         assert_return(client_id, -EINVAL);
         assert_return(client_id_len, -EINVAL);
 
+        if (!lease->client_id)
+                return -ENODATA;
+
         *client_id = lease->client_id;
         *client_id_len = lease->client_id_len;
+
         return 0;
 }
 
-int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const uint8_t *client_id,
-                             size_t client_id_len) {
+int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const void *client_id, size_t client_id_len) {
         assert_return(lease, -EINVAL);
-        assert_return((!client_id && !client_id_len) ||
-                      (client_id && client_id_len), -EINVAL);
+        assert_return(client_id || client_id_len <= 0, -EINVAL);
+
+        if (client_id_len <= 0)
+                lease->client_id = mfree(lease->client_id);
+        else {
+                void *p;
 
-        free (lease->client_id);
-        lease->client_id = NULL;
-        lease->client_id_len = 0;
+                p = memdup(client_id, client_id_len);
+                if (!p)
+                        return -ENOMEM;
 
-        if (client_id) {
-                lease->client_id = memdup (client_id, client_id_len);
+                free(lease->client_id);
+                lease->client_id = p;
                 lease->client_id_len = client_id_len;
         }
 
         return 0;
 }
+
+int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **timezone) {
+        assert_return(lease, -EINVAL);
+        assert_return(timezone, -EINVAL);
+
+        if (!lease->timezone)
+                return -ENODATA;
+
+        *timezone = lease->timezone;
+        return 0;
+}
diff --git a/src/libsystemd-network/sd-dhcp-server.c b/src/libsystemd-network/sd-dhcp-server.c
index faeab0fd30..a46858258b 100644
--- a/src/libsystemd-network/sd-dhcp-server.c
+++ b/src/libsystemd-network/sd-dhcp-server.c
@@ -28,7 +28,8 @@
 #include "dhcp-server-internal.h"
 #include "dhcp-internal.h"
 
-#define DHCP_DEFAULT_LEASE_TIME         3600 /* one hour */
+#define DHCP_DEFAULT_LEASE_TIME_USEC USEC_PER_HOUR
+#define DHCP_MAX_LEASE_TIME_USEC (USEC_PER_HOUR*12)
 
 int sd_dhcp_server_set_lease_pool(sd_dhcp_server *server,
                                   struct in_addr *address,
@@ -73,8 +74,12 @@ bool sd_dhcp_server_is_running(sd_dhcp_server *server) {
 }
 
 sd_dhcp_server *sd_dhcp_server_ref(sd_dhcp_server *server) {
-        if (server)
-                assert_se(REFCNT_INC(server->n_ref) >= 2);
+
+        if (!server)
+                return NULL;
+
+        assert(server->n_ref >= 1);
+        server->n_ref++;
 
         return server;
 }
@@ -127,7 +132,10 @@ sd_dhcp_server *sd_dhcp_server_unref(sd_dhcp_server *server) {
         if (!server)
                 return NULL;
 
-        if (REFCNT_DEC(server->n_ref) > 0)
+        assert(server->n_ref >= 1);
+        server->n_ref--;
+
+        if (server->n_ref > 0)
                 return NULL;
 
         log_dhcp_server(server, "UNREF");
@@ -136,6 +144,10 @@ sd_dhcp_server *sd_dhcp_server_unref(sd_dhcp_server *server) {
 
         sd_event_unref(server->event);
 
+        free(server->timezone);
+        free(server->dns);
+        free(server->ntp);
+
         while ((lease = hashmap_steal_first(server->leases_by_client_id)))
                 dhcp_lease_free(lease);
         hashmap_free(server->leases_by_client_id);
@@ -156,13 +168,15 @@ int sd_dhcp_server_new(sd_dhcp_server **ret, int ifindex) {
         if (!server)
                 return -ENOMEM;
 
-        server->n_ref = REFCNT_INIT;
+        server->n_ref = 1;
         server->fd_raw = -1;
         server->fd = -1;
         server->address = htobe32(INADDR_ANY);
         server->netmask = htobe32(INADDR_ANY);
-        server->index = ifindex;
+        server->ifindex = ifindex;
         server->leases_by_client_id = hashmap_new(&client_id_hash_ops);
+        server->default_lease_time = DIV_ROUND_UP(DHCP_DEFAULT_LEASE_TIME_USEC, USEC_PER_SEC);
+        server->max_lease_time = DIV_ROUND_UP(DHCP_MAX_LEASE_TIME_USEC, USEC_PER_SEC);
 
         *ret = server;
         server = NULL;
@@ -223,13 +237,12 @@ static int dhcp_server_send_unicast_raw(sd_dhcp_server *server,
         union sockaddr_union link = {
                 .ll.sll_family = AF_PACKET,
                 .ll.sll_protocol = htons(ETH_P_IP),
-                .ll.sll_ifindex = server->index,
+                .ll.sll_ifindex = server->ifindex,
                 .ll.sll_halen = ETH_ALEN,
         };
-        int r;
 
         assert(server);
-        assert(server->index > 0);
+        assert(server->ifindex > 0);
         assert(server->address);
         assert(packet);
         assert(len > sizeof(DHCPPacket));
@@ -240,11 +253,7 @@ static int dhcp_server_send_unicast_raw(sd_dhcp_server *server,
                                       packet->dhcp.yiaddr,
                                       DHCP_PORT_CLIENT, len);
 
-        r = dhcp_network_send_raw_socket(server->fd_raw, &link, packet, len);
-        if (r < 0)
-                return r;
-
-        return 0;
+        return dhcp_network_send_raw_socket(server->fd_raw, &link, packet, len);
 }
 
 static int dhcp_server_send_udp(sd_dhcp_server *server, be32_t destination,
@@ -290,7 +299,7 @@ static int dhcp_server_send_udp(sd_dhcp_server *server, be32_t destination,
         pktinfo = (struct in_pktinfo*) CMSG_DATA(cmsg);
         assert(pktinfo);
 
-        pktinfo->ipi_ifindex = server->index;
+        pktinfo->ipi_ifindex = server->ifindex;
         pktinfo->ipi_spec_dst.s_addr = server->address;
 
         r = sendmsg(server->fd, &msg, 0);
@@ -474,6 +483,33 @@ static int server_send_ack(sd_dhcp_server *server, DHCPRequest *req,
         if (r < 0)
                 return r;
 
+        if (server->n_dns > 0) {
+                r = dhcp_option_append(
+                                &packet->dhcp, req->max_optlen, &offset, 0,
+                                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,
+                                DHCP_OPTION_NTP_SERVER,
+                                sizeof(struct in_addr) * server->n_ntp, server->ntp);
+                if (r < 0)
+                        return r;
+        }
+
+        if (server->timezone) {
+                r = dhcp_option_append(
+                                &packet->dhcp, req->max_optlen, &offset, 0,
+                                DHCP_OPTION_NEW_TZDB_TIMEZONE,
+                                strlen(server->timezone), server->timezone);
+                if (r < 0)
+                        return r;
+        }
+
         r = dhcp_server_send_packet(server, req, packet, DHCP_ACK, offset);
         if (r < 0)
                 return r;
@@ -490,11 +526,7 @@ static int server_send_nak(sd_dhcp_server *server, DHCPRequest *req) {
         if (r < 0)
                 return r;
 
-        r = dhcp_server_send_packet(server, req, packet, DHCP_NAK, offset);
-        if (r < 0)
-                return r;
-
-        return 0;
+        return dhcp_server_send_packet(server, req, packet, DHCP_NAK, offset);
 }
 
 static int server_send_forcerenew(sd_dhcp_server *server, be32_t address,
@@ -532,9 +564,8 @@ static int server_send_forcerenew(sd_dhcp_server *server, be32_t address,
         return 0;
 }
 
-static int parse_request(uint8_t code, uint8_t len, const uint8_t *option,
-                         void *user_data) {
-        DHCPRequest *req = user_data;
+static int parse_request(uint8_t code, uint8_t len, const void *option, void *userdata) {
+        DHCPRequest *req = userdata;
 
         assert(req);
 
@@ -590,7 +621,7 @@ static void dhcp_request_free(DHCPRequest *req) {
 DEFINE_TRIVIAL_CLEANUP_FUNC(DHCPRequest*, dhcp_request_free);
 #define _cleanup_dhcp_request_free_ _cleanup_(dhcp_request_freep)
 
-static int ensure_sane_request(DHCPRequest *req, DHCPMessage *message) {
+static int ensure_sane_request(sd_dhcp_server *server, DHCPRequest *req, DHCPMessage *message) {
         assert(req);
         assert(message);
 
@@ -599,23 +630,27 @@ static int ensure_sane_request(DHCPRequest *req, DHCPMessage *message) {
         /* set client id based on MAC address if client did not send an explicit
            one */
         if (!req->client_id.data) {
-                uint8_t *data;
+                void *data;
 
-                data = new0(uint8_t, ETH_ALEN + 1);
+                data = malloc0(ETH_ALEN + 1);
                 if (!data)
                         return -ENOMEM;
 
+                ((uint8_t*) data)[0] = 0x01;
+                memcpy((uint8_t*) data + 1, &message->chaddr, ETH_ALEN);
+
                 req->client_id.length = ETH_ALEN + 1;
                 req->client_id.data = data;
-                req->client_id.data[0] = 0x01;
-                memcpy(&req->client_id.data[1], &message->chaddr, ETH_ALEN);
         }
 
         if (req->max_optlen < DHCP_MIN_OPTIONS_SIZE)
                 req->max_optlen = DHCP_MIN_OPTIONS_SIZE;
 
-        if (!req->lifetime)
-                req->lifetime = DHCP_DEFAULT_LEASE_TIME;
+        if (req->lifetime <= 0)
+                req->lifetime = MAX(1ULL, server->default_lease_time);
+
+        if (server->max_lease_time > 0 && req->lifetime > server->max_lease_time)
+                req->lifetime = server->max_lease_time;
 
         return 0;
 }
@@ -656,7 +691,7 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message,
         if (type < 0)
                 return 0;
 
-        r = ensure_sane_request(req, message);
+        r = ensure_sane_request(server, req, message);
         if (r < 0)
                 /* this only fails on critical errors */
                 return r;
@@ -665,8 +700,8 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message,
                                      &req->client_id);
 
         switch(type) {
-        case DHCP_DISCOVER:
-        {
+
+        case DHCP_DISCOVER: {
                 be32_t address = INADDR_ANY;
                 unsigned i;
 
@@ -716,9 +751,7 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message,
 
                 return 1;
 
-                break;
-        case DHCP_REQUEST:
-        {
+        case DHCP_REQUEST: {
                 be32_t address;
                 bool init_reboot = false;
                 int pool_offset;
@@ -840,6 +873,7 @@ int dhcp_server_handle_message(sd_dhcp_server *server, DHCPMessage *message,
 
                 break;
         }
+
         case DHCP_RELEASE: {
                 int pool_offset;
 
@@ -883,13 +917,12 @@ static int server_receive_message(sd_event_source *s, int fd,
                 .msg_controllen = sizeof(cmsgbuf),
         };
         struct cmsghdr *cmsg;
-        int buflen = 0, len, r;
+        int buflen = 0, len;
 
         assert(server);
 
-        r = ioctl(fd, FIONREAD, &buflen);
-        if (r < 0)
-                return r;
+        if (ioctl(fd, FIONREAD, &buflen) < 0)
+                return -errno;
         if (buflen < 0)
                 return -EIO;
 
@@ -914,7 +947,7 @@ static int server_receive_message(sd_event_source *s, int fd,
 
                         /* TODO figure out if this can be done as a filter on
                          * the socket, like for IPv6 */
-                        if (server->index != info->ipi_ifindex)
+                        if (server->ifindex != info->ipi_ifindex)
                                 return 0;
 
                         break;
@@ -993,3 +1026,91 @@ int sd_dhcp_server_forcerenew(sd_dhcp_server *server) {
 
         return r;
 }
+
+int sd_dhcp_server_set_timezone(sd_dhcp_server *server, const char *timezone) {
+        int r;
+
+        assert_return(server, -EINVAL);
+        assert_return(timezone_is_valid(timezone), -EINVAL);
+
+        if (streq_ptr(timezone, server->timezone))
+                return 0;
+
+        r = free_and_strdup(&server->timezone, timezone);
+        if (r < 0)
+                return r;
+
+        return 1;
+}
+
+int sd_dhcp_server_set_max_lease_time(sd_dhcp_server *server, uint32_t t) {
+        assert_return(server, -EINVAL);
+
+        if (t == server->max_lease_time)
+                return 0;
+
+        server->max_lease_time = t;
+        return 1;
+}
+
+int sd_dhcp_server_set_default_lease_time(sd_dhcp_server *server, uint32_t t) {
+        assert_return(server, -EINVAL);
+
+        if (t == server->default_lease_time)
+                return 0;
+
+        server->default_lease_time = t;
+        return 1;
+}
+
+int sd_dhcp_server_set_dns(sd_dhcp_server *server, const struct in_addr dns[], unsigned n) {
+        assert_return(server, -EINVAL);
+        assert_return(dns || n <= 0, -EINVAL);
+
+        if (server->n_dns == n &&
+            memcmp(server->dns, dns, sizeof(struct in_addr) * n) == 0)
+                return 0;
+
+        if (n <= 0) {
+                server->dns = mfree(server->dns);
+                server->n_dns = 0;
+        } else {
+                struct in_addr *c;
+
+                c = newdup(struct in_addr, dns, n);
+                if (!c)
+                        return -ENOMEM;
+
+                free(server->dns);
+                server->dns = c;
+                server->n_dns = n;
+        }
+
+        return 1;
+}
+
+int sd_dhcp_server_set_ntp(sd_dhcp_server *server, const struct in_addr ntp[], unsigned n) {
+        assert_return(server, -EINVAL);
+        assert_return(ntp || n <= 0, -EINVAL);
+
+        if (server->n_ntp == n &&
+            memcmp(server->ntp, ntp, sizeof(struct in_addr) * n) == 0)
+                return 0;
+
+        if (n <= 0) {
+                server->ntp = mfree(server->ntp);
+                server->n_ntp = 0;
+        } else {
+                struct in_addr *c;
+
+                c = newdup(struct in_addr, ntp, n);
+                if (!c)
+                        return -ENOMEM;
+
+                free(server->ntp);
+                server->ntp = c;
+                server->n_ntp = n;
+        }
+
+        return 1;
+}
diff --git a/src/libsystemd-network/sd-dhcp6-client.c b/src/libsystemd-network/sd-dhcp6-client.c
index 10c3654020..5489c77864 100644
--- a/src/libsystemd-network/sd-dhcp6-client.c
+++ b/src/libsystemd-network/sd-dhcp6-client.c
@@ -27,7 +27,6 @@
 #include "udev.h"
 #include "udev-util.h"
 #include "util.h"
-#include "refcnt.h"
 #include "random-util.h"
 
 #include "network-internal.h"
@@ -40,7 +39,7 @@
 #define MAX_MAC_ADDR_LEN INFINIBAND_ALEN
 
 struct sd_dhcp6_client {
-        RefCount n_ref;
+        unsigned n_ref;
 
         enum DHCP6State state;
         sd_event *event;
@@ -113,9 +112,7 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(sd_dhcp6_client*, sd_dhcp6_client_unref);
 
 static int client_start(sd_dhcp6_client *client, enum DHCP6State state);
 
-int sd_dhcp6_client_set_callback(sd_dhcp6_client *client,
-                                 sd_dhcp6_client_cb_t cb, void *userdata)
-{
+int sd_dhcp6_client_set_callback(sd_dhcp6_client *client, sd_dhcp6_client_cb_t cb, void *userdata) {
         assert_return(client, -EINVAL);
 
         client->cb = cb;
@@ -124,8 +121,7 @@ int sd_dhcp6_client_set_callback(sd_dhcp6_client *client,
         return 0;
 }
 
-int sd_dhcp6_client_set_index(sd_dhcp6_client *client, int interface_index)
-{
+int sd_dhcp6_client_set_index(sd_dhcp6_client *client, int interface_index) {
         assert_return(client, -EINVAL);
         assert_return(interface_index >= -1, -EINVAL);
 
@@ -134,9 +130,11 @@ int sd_dhcp6_client_set_index(sd_dhcp6_client *client, int interface_index)
         return 0;
 }
 
-int sd_dhcp6_client_set_mac(sd_dhcp6_client *client, const uint8_t *addr,
-                            size_t addr_len, uint16_t arp_type)
-{
+int sd_dhcp6_client_set_mac(
+                sd_dhcp6_client *client,
+                const uint8_t *addr, size_t addr_len,
+                uint16_t arp_type) {
+
         assert_return(client, -EINVAL);
         assert_return(addr, -EINVAL);
         assert_return(addr_len > 0 && addr_len <= MAX_MAC_ADDR_LEN, -EINVAL);
@@ -160,16 +158,17 @@ int sd_dhcp6_client_set_mac(sd_dhcp6_client *client, const uint8_t *addr,
         return 0;
 }
 
-static int client_ensure_duid(sd_dhcp6_client *client)
-{
+static int client_ensure_duid(sd_dhcp6_client *client) {
         if (client->duid_len != 0)
                 return 0;
+
         return dhcp_identifier_set_duid_en(&client->duid, &client->duid_len);
 }
 
-int sd_dhcp6_client_set_duid(sd_dhcp6_client *client, uint16_t type, uint8_t *duid,
-                             size_t duid_len)
-{
+int sd_dhcp6_client_set_duid(
+                sd_dhcp6_client *client,
+                uint16_t type,
+                uint8_t *duid, size_t duid_len) {
         assert_return(client, -EINVAL);
         assert_return(duid, -EINVAL);
         assert_return(duid_len > 0 && duid_len <= MAX_DUID_LEN, -EINVAL);
@@ -203,8 +202,7 @@ int sd_dhcp6_client_set_duid(sd_dhcp6_client *client, uint16_t type, uint8_t *du
         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, bool enabled) {
         assert_return(client, -EINVAL);
 
         client->information_request = enabled;
@@ -212,8 +210,7 @@ int sd_dhcp6_client_set_information_request(sd_dhcp6_client *client,
         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, bool *enabled) {
         assert_return(client, -EINVAL);
         assert_return(enabled, -EINVAL);
 
@@ -222,8 +219,7 @@ int sd_dhcp6_client_get_information_request(sd_dhcp6_client *client,
         return 0;
 }
 
-int sd_dhcp6_client_set_request_option(sd_dhcp6_client *client,
-                                       uint16_t option) {
+int sd_dhcp6_client_set_request_option(sd_dhcp6_client *client, uint16_t option) {
         size_t t;
 
         assert_return(client, -EINVAL);
@@ -805,9 +801,7 @@ static int client_parse_message(sd_dhcp6_client *client,
         return r;
 }
 
-static int client_receive_reply(sd_dhcp6_client *client, DHCP6Message *reply,
-                                size_t len)
-{
+static int client_receive_reply(sd_dhcp6_client *client, DHCP6Message *reply, size_t len) {
         int r;
         _cleanup_dhcp6_lease_free_ sd_dhcp6_lease *lease = NULL;
         bool rapid_commit;
@@ -843,8 +837,7 @@ static int client_receive_reply(sd_dhcp6_client *client, DHCP6Message *reply,
         return DHCP6_STATE_BOUND;
 }
 
-static int client_receive_advertise(sd_dhcp6_client *client,
-                                    DHCP6Message *advertise, size_t len) {
+static int client_receive_advertise(sd_dhcp6_client *client, DHCP6Message *advertise, size_t len) {
         int r;
         _cleanup_dhcp6_lease_free_ sd_dhcp6_lease *lease = NULL;
         uint8_t pref_advertise = 0, pref_lease = 0;
@@ -879,8 +872,7 @@ static int client_receive_advertise(sd_dhcp6_client *client,
         return r;
 }
 
-static int client_receive_message(sd_event_source *s, int fd, uint32_t revents,
-                                  void *userdata) {
+static int client_receive_message(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
         sd_dhcp6_client *client = userdata;
         DHCP6_CLIENT_DONT_DESTROY(client);
         _cleanup_free_ DHCP6Message *message;
@@ -991,8 +983,7 @@ static int client_receive_message(sd_event_source *s, int fd, uint32_t revents,
         return 0;
 }
 
-static int client_start(sd_dhcp6_client *client, enum DHCP6State state)
-{
+static int client_start(sd_dhcp6_client *client, enum DHCP6State state) {
         int r;
         usec_t timeout, time_now;
         char time_string[FORMAT_TIMESPAN_MAX];
@@ -1121,15 +1112,13 @@ static int client_start(sd_dhcp6_client *client, enum DHCP6State state)
         return 0;
 }
 
-int sd_dhcp6_client_stop(sd_dhcp6_client *client)
-{
+int sd_dhcp6_client_stop(sd_dhcp6_client *client) {
         client_stop(client, DHCP6_EVENT_STOP);
 
         return 0;
 }
 
-int sd_dhcp6_client_start(sd_dhcp6_client *client)
-{
+int sd_dhcp6_client_start(sd_dhcp6_client *client) {
         int r = 0;
         enum DHCP6State state = DHCP6_STATE_SOLICITATION;
 
@@ -1185,9 +1174,7 @@ error:
         return r;
 }
 
-int sd_dhcp6_client_attach_event(sd_dhcp6_client *client, sd_event *event,
-                                 int priority)
-{
+int sd_dhcp6_client_attach_event(sd_dhcp6_client *client, sd_event *event, int priority) {
         int r;
 
         assert_return(client, -EINVAL);
@@ -1222,30 +1209,39 @@ sd_event *sd_dhcp6_client_get_event(sd_dhcp6_client *client) {
 }
 
 sd_dhcp6_client *sd_dhcp6_client_ref(sd_dhcp6_client *client) {
-        if (client)
-                assert_se(REFCNT_INC(client->n_ref) >= 2);
+
+        if (!client)
+                return NULL;
+
+        assert(client->n_ref >= 1);
+        client->n_ref++;
 
         return client;
 }
 
 sd_dhcp6_client *sd_dhcp6_client_unref(sd_dhcp6_client *client) {
-        if (client && REFCNT_DEC(client->n_ref) == 0) {
-                client_reset(client);
 
-                sd_dhcp6_client_detach_event(client);
-                sd_dhcp6_lease_unref(client->lease);
+        if (!client)
+                return NULL;
 
-                free(client->req_opts);
-                free(client);
+        assert(client->n_ref >= 1);
+        client->n_ref--;
 
+        if (client->n_ref > 0)
                 return NULL;
-        }
 
-        return client;
+        client_reset(client);
+
+        sd_dhcp6_client_detach_event(client);
+        sd_dhcp6_lease_unref(client->lease);
+
+        free(client->req_opts);
+        free(client);
+
+        return NULL;
 }
 
-int sd_dhcp6_client_new(sd_dhcp6_client **ret)
-{
+int sd_dhcp6_client_new(sd_dhcp6_client **ret) {
         _cleanup_dhcp6_client_unref_ sd_dhcp6_client *client = NULL;
         size_t t;
 
@@ -1255,7 +1251,7 @@ int sd_dhcp6_client_new(sd_dhcp6_client **ret)
         if (!client)
                 return -ENOMEM;
 
-        client->n_ref = REFCNT_INIT;
+        client->n_ref = 1;
 
         client->ia_na.type = DHCP6_OPTION_IA_NA;
 
diff --git a/src/libsystemd-network/sd-dhcp6-lease.c b/src/libsystemd-network/sd-dhcp6-lease.c
index f0494b3c91..f34af6eaba 100644
--- a/src/libsystemd-network/sd-dhcp6-lease.c
+++ b/src/libsystemd-network/sd-dhcp6-lease.c
@@ -247,8 +247,7 @@ int sd_dhcp6_lease_get_domains(sd_dhcp6_lease *lease, char ***domains) {
         return -ENOENT;
 }
 
-int dhcp6_lease_set_ntp(sd_dhcp6_lease *lease, uint8_t *optval, size_t optlen)
-{
+int dhcp6_lease_set_ntp(sd_dhcp6_lease *lease, uint8_t *optval, size_t optlen) {
         int r;
         uint16_t subopt;
         size_t sublen;
@@ -361,26 +360,38 @@ int sd_dhcp6_lease_get_ntp_fqdn(sd_dhcp6_lease *lease, char ***ntp_fqdn) {
 }
 
 sd_dhcp6_lease *sd_dhcp6_lease_ref(sd_dhcp6_lease *lease) {
-        if (lease)
-                assert_se(REFCNT_INC(lease->n_ref) >= 2);
+
+        if (!lease)
+                return NULL;
+
+        assert(lease->n_ref >= 1);
+        lease->n_ref++;
 
         return lease;
 }
 
 sd_dhcp6_lease *sd_dhcp6_lease_unref(sd_dhcp6_lease *lease) {
-        if (lease && REFCNT_DEC(lease->n_ref) == 0) {
-                free(lease->serverid);
-                dhcp6_lease_free_ia(&lease->ia);
 
-                free(lease->dns);
+        if (!lease)
+                return NULL;
 
-                lease->domains = strv_free(lease->domains);
+        assert(lease->n_ref >= 1);
+        lease->n_ref--;
 
-                free(lease->ntp);
+        if (lease->n_ref > 0)
+                return NULL;
 
-                lease->ntp_fqdn = strv_free(lease->ntp_fqdn);
-                free(lease);
-        }
+        free(lease->serverid);
+        dhcp6_lease_free_ia(&lease->ia);
+
+        free(lease->dns);
+
+        lease->domains = strv_free(lease->domains);
+
+        free(lease->ntp);
+
+        lease->ntp_fqdn = strv_free(lease->ntp_fqdn);
+        free(lease);
 
         return NULL;
 }
@@ -392,7 +403,7 @@ int dhcp6_lease_new(sd_dhcp6_lease **ret) {
         if (!lease)
                 return -ENOMEM;
 
-        lease->n_ref = REFCNT_INIT;
+        lease->n_ref = 1;
 
         LIST_HEAD_INIT(lease->ia.addresses);
 
diff --git a/src/libsystemd-network/sd-icmp6-nd.c b/src/libsystemd-network/sd-icmp6-nd.c
index 2f867e8562..e80232a7e0 100644
--- a/src/libsystemd-network/sd-icmp6-nd.c
+++ b/src/libsystemd-network/sd-icmp6-nd.c
@@ -25,7 +25,6 @@
 #include <sys/ioctl.h>
 
 #include "socket-util.h"
-#include "refcnt.h"
 #include "async.h"
 
 #include "dhcp6-internal.h"
@@ -47,7 +46,7 @@ enum icmp6_nd_state {
 typedef struct ICMP6Prefix ICMP6Prefix;
 
 struct ICMP6Prefix {
-        RefCount n_ref;
+        unsigned n_ref;
 
         LIST_FIELDS(ICMP6Prefix, prefixes);
 
@@ -57,7 +56,7 @@ struct ICMP6Prefix {
 };
 
 struct sd_icmp6_nd {
-        RefCount n_ref;
+        unsigned n_ref;
 
         enum icmp6_nd_state state;
         sd_event *event;
@@ -78,13 +77,18 @@ struct sd_icmp6_nd {
 #define log_icmp6_nd(p, fmt, ...) log_internal(LOG_DEBUG, 0, __FILE__, __LINE__, __func__, "ICMPv6 CLIENT: " fmt, ##__VA_ARGS__)
 
 static ICMP6Prefix *icmp6_prefix_unref(ICMP6Prefix *prefix) {
-        if (prefix && REFCNT_DEC(prefix->n_ref) <= 0) {
-                prefix->timeout_valid =
-                        sd_event_source_unref(prefix->timeout_valid);
 
-                free(prefix);
-        }
+        if (!prefix)
+                return NULL;
+
+        assert(prefix->n_ref > 0);
+        prefix->n_ref--;
 
+        if (prefix->n_ref > 0)
+                return NULL;
+
+        prefix->timeout_valid = sd_event_source_unref(prefix->timeout_valid);
+        free(prefix);
         return NULL;
 }
 
@@ -97,7 +101,7 @@ static int icmp6_prefix_new(ICMP6Prefix **ret) {
         if (!prefix)
                 return -ENOMEM;
 
-        prefix->n_ref = REFCNT_INIT;
+        prefix->n_ref = 1;
         LIST_INIT(prefixes, prefix);
 
         *ret = prefix;
@@ -106,8 +110,7 @@ static int icmp6_prefix_new(ICMP6Prefix **ret) {
         return 0;
 }
 
-static void icmp6_nd_notify(sd_icmp6_nd *nd, int event)
-{
+static void icmp6_nd_notify(sd_icmp6_nd *nd, int event) {
         if (nd->callback)
                 nd->callback(nd, event, nd->userdata);
 }
@@ -177,9 +180,12 @@ sd_event *sd_icmp6_nd_get_event(sd_icmp6_nd *nd) {
 }
 
 sd_icmp6_nd *sd_icmp6_nd_ref(sd_icmp6_nd *nd) {
-        assert (nd);
 
-        assert_se(REFCNT_INC(nd->n_ref) >= 2);
+        if (!nd)
+                return NULL;
+
+        assert(nd->n_ref > 0);
+        nd->n_ref++;
 
         return nd;
 }
@@ -195,21 +201,28 @@ static int icmp6_nd_init(sd_icmp6_nd *nd) {
 }
 
 sd_icmp6_nd *sd_icmp6_nd_unref(sd_icmp6_nd *nd) {
-        if (nd && REFCNT_DEC(nd->n_ref) == 0) {
-                ICMP6Prefix *prefix, *p;
+        ICMP6Prefix *prefix, *p;
 
-                icmp6_nd_init(nd);
-                sd_icmp6_nd_detach_event(nd);
+        if (!nd)
+                return NULL;
 
-                LIST_FOREACH_SAFE(prefixes, prefix, p, nd->prefixes) {
-                        LIST_REMOVE(prefixes, nd->prefixes, prefix);
+        assert(nd->n_ref > 0);
+        nd->n_ref--;
 
-                        prefix = icmp6_prefix_unref(prefix);
-                }
+        if (nd->n_ref > 0)
+                return NULL;
+
+        icmp6_nd_init(nd);
+        sd_icmp6_nd_detach_event(nd);
 
-                free(nd);
+        LIST_FOREACH_SAFE(prefixes, prefix, p, nd->prefixes) {
+                LIST_REMOVE(prefixes, nd->prefixes, prefix);
+
+                prefix = icmp6_prefix_unref(prefix);
         }
 
+        free(nd);
+
         return NULL;
 }
 
@@ -225,7 +238,7 @@ int sd_icmp6_nd_new(sd_icmp6_nd **ret) {
         if (!nd)
                 return -ENOMEM;
 
-        nd->n_ref = REFCNT_INIT;
+        nd->n_ref = 1;
 
         nd->index = -1;
         nd->fd = -1;
@@ -376,9 +389,7 @@ int sd_icmp6_ra_get_prefixlen(sd_icmp6_nd *nd, const struct in6_addr *addr,
         return 0;
 }
 
-int sd_icmp6_ra_get_expired_prefix(sd_icmp6_nd *nd, struct in6_addr **addr,
-                                uint8_t *prefixlen)
-{
+int sd_icmp6_ra_get_expired_prefix(sd_icmp6_nd *nd, struct in6_addr **addr, uint8_t *prefixlen) {
         assert_return(nd, -EINVAL);
         assert_return(addr, -EINVAL);
         assert_return(prefixlen, -EINVAL);
@@ -525,9 +536,7 @@ static int icmp6_ra_parse(sd_icmp6_nd *nd, struct nd_router_advert *ra,
         return 0;
 }
 
-static int icmp6_router_advertisment_recv(sd_event_source *s, int fd,
-                                          uint32_t revents, void *userdata)
-{
+static int icmp6_router_advertisment_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
         sd_icmp6_nd *nd = userdata;
         int r, buflen = 0;
         ssize_t len;
@@ -586,9 +595,7 @@ static int icmp6_router_advertisment_recv(sd_event_source *s, int fd,
         return 0;
 }
 
-static int icmp6_router_solicitation_timeout(sd_event_source *s, uint64_t usec,
-                                             void *userdata)
-{
+static int icmp6_router_solicitation_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
         sd_icmp6_nd *nd = userdata;
         uint64_t time_now, next_timeout;
         struct ether_addr unset = { };
diff --git a/src/libsystemd-network/sd-ipv4ll.c b/src/libsystemd-network/sd-ipv4ll.c
index f080c5c0a7..0fc05e1484 100644
--- a/src/libsystemd-network/sd-ipv4ll.c
+++ b/src/libsystemd-network/sd-ipv4ll.c
@@ -26,7 +26,6 @@
 #include "util.h"
 #include "siphash24.h"
 #include "list.h"
-#include "refcnt.h"
 #include "random-util.h"
 
 #include "ipv4ll-internal.h"
@@ -68,7 +67,7 @@ typedef enum IPv4LLState {
 } IPv4LLState;
 
 struct sd_ipv4ll {
-        RefCount n_ref;
+        unsigned n_ref;
 
         IPv4LLState state;
         int index;
@@ -598,30 +597,39 @@ int sd_ipv4ll_stop(sd_ipv4ll *ll) {
 }
 
 sd_ipv4ll *sd_ipv4ll_ref(sd_ipv4ll *ll) {
-        if (ll)
-                assert_se(REFCNT_INC(ll->n_ref) >= 2);
+
+        if (!ll)
+                return NULL;
+
+        assert(ll->n_ref >= 1);
+        ll->n_ref++;
 
         return ll;
 }
 
 sd_ipv4ll *sd_ipv4ll_unref(sd_ipv4ll *ll) {
-        if (ll && REFCNT_DEC(ll->n_ref) == 0) {
-                ll->receive_message =
-                        sd_event_source_unref(ll->receive_message);
-                ll->fd = safe_close(ll->fd);
 
-                ll->timer = sd_event_source_unref(ll->timer);
+        if (!ll)
+                return NULL;
 
-                sd_ipv4ll_detach_event(ll);
+        assert(ll->n_ref >= 1);
+        ll->n_ref--;
 
-                free(ll->random_data);
-                free(ll->random_data_state);
-                free(ll);
+        if (ll->n_ref > 0)
+                return ll;
 
-                return NULL;
-        }
+        ll->receive_message = sd_event_source_unref(ll->receive_message);
+        ll->fd = safe_close(ll->fd);
 
-        return ll;
+        ll->timer = sd_event_source_unref(ll->timer);
+
+        sd_ipv4ll_detach_event(ll);
+
+        free(ll->random_data);
+        free(ll->random_data_state);
+        free(ll);
+
+        return NULL;
 }
 
 DEFINE_TRIVIAL_CLEANUP_FUNC(sd_ipv4ll*, sd_ipv4ll_unref);
@@ -636,7 +644,7 @@ int sd_ipv4ll_new(sd_ipv4ll **ret) {
         if (!ll)
                 return -ENOMEM;
 
-        ll->n_ref = REFCNT_INIT;
+        ll->n_ref = 1;
         ll->state = IPV4LL_STATE_INIT;
         ll->index = -1;
         ll->fd = -1;
diff --git a/src/libsystemd-network/sd-pppoe.c b/src/libsystemd-network/sd-pppoe.c
index ff064f563f..c6c9da812b 100644
--- a/src/libsystemd-network/sd-pppoe.c
+++ b/src/libsystemd-network/sd-pppoe.c
@@ -36,7 +36,6 @@
 #include "random-util.h"
 #include "socket-util.h"
 #include "async.h"
-#include "refcnt.h"
 #include "utf8.h"
 
 #define PPPOE_MAX_PACKET_SIZE 1484
@@ -68,7 +67,7 @@ typedef struct PPPoETags {
 } PPPoETags;
 
 struct sd_pppoe {
-        RefCount n_ref;
+        unsigned n_ref;
 
         PPPoEState state;
         uint64_t host_uniq;
@@ -202,23 +201,34 @@ int sd_pppoe_detach_event(sd_pppoe *ppp) {
 }
 
 sd_pppoe *sd_pppoe_ref(sd_pppoe *ppp) {
-        if (ppp)
-                assert_se(REFCNT_INC(ppp->n_ref) >= 2);
+
+        if (!ppp)
+                return NULL;
+
+        assert(ppp->n_ref > 0);
+        ppp->n_ref++;
 
         return ppp;
 }
 
 sd_pppoe *sd_pppoe_unref(sd_pppoe *ppp) {
-        if (ppp && REFCNT_DEC(ppp->n_ref) <= 0) {
-                pppoe_tags_clear(&ppp->tags);
-                free(ppp->ifname);
-                free(ppp->service_name);
-                sd_pppoe_stop(ppp);
-                sd_pppoe_detach_event(ppp);
-
-                free(ppp);
-        }
 
+        if (!ppp)
+                return NULL;
+
+        assert(ppp->n_ref > 0);
+        ppp->n_ref--;
+
+        if (ppp->n_ref > 0)
+                return NULL;
+
+        pppoe_tags_clear(&ppp->tags);
+        free(ppp->ifname);
+        free(ppp->service_name);
+        sd_pppoe_stop(ppp);
+        sd_pppoe_detach_event(ppp);
+
+        free(ppp);
         return NULL;
 }
 
@@ -231,7 +241,7 @@ int sd_pppoe_new (sd_pppoe **ret) {
         if (!ppp)
                 return -ENOMEM;
 
-        ppp->n_ref = REFCNT_INIT;
+        ppp->n_ref = 1;
         ppp->state = _PPPOE_STATE_INVALID;
         ppp->ifindex = -1;
         ppp->fd = -1;
diff --git a/src/libsystemd-network/test-dhcp-client.c b/src/libsystemd-network/test-dhcp-client.c
index 200499d613..29c20b77e3 100644
--- a/src/libsystemd-network/test-dhcp-client.c
+++ b/src/libsystemd-network/test-dhcp-client.c
@@ -43,16 +43,13 @@ static test_callback_recv_t callback_recv;
 static be32_t xid;
 static sd_event_source *test_hangcheck;
 
-static int test_dhcp_hangcheck(sd_event_source *s, uint64_t usec,
-                               void *userdata)
-{
+static int test_dhcp_hangcheck(sd_event_source *s, uint64_t usec, void *userdata) {
         assert_not_reached("Test case should have completed in 2 seconds");
 
         return 0;
 }
 
-static void test_request_basic(sd_event *e)
-{
+static void test_request_basic(sd_event *e) {
         int r;
 
         sd_dhcp_client *client;
@@ -87,10 +84,7 @@ static void test_request_basic(sd_event *e)
         assert_se(sd_dhcp_client_set_request_option(client,
                                         DHCP_OPTION_DOMAIN_NAME) == -EEXIST);
         assert_se(sd_dhcp_client_set_request_option(client,
-                                        DHCP_OPTION_DOMAIN_NAME_SERVER)
-                        == -EEXIST);
-        assert_se(sd_dhcp_client_set_request_option(client,
-                                        DHCP_OPTION_NTP_SERVER) == -EEXIST);
+                                        DHCP_OPTION_DOMAIN_NAME_SERVER) == -EEXIST);
 
         assert_se(sd_dhcp_client_set_request_option(client,
                                         DHCP_OPTION_PAD) == -EINVAL);
@@ -112,8 +106,7 @@ static void test_request_basic(sd_event *e)
         sd_dhcp_client_unref(client);
 }
 
-static void test_checksum(void)
-{
+static void test_checksum(void) {
         uint8_t buf[20] = {
                 0x45, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
                 0x40, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -126,9 +119,7 @@ static void test_checksum(void)
         assert_se(dhcp_packet_checksum((uint8_t*)&buf, 20) == be16toh(0x78ae));
 }
 
-static int check_options(uint8_t code, uint8_t len, const uint8_t *option,
-                void *user_data)
-{
+static int check_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
         switch(code) {
         case DHCP_OPTION_CLIENT_IDENTIFIER:
         {
@@ -141,10 +132,10 @@ static int check_options(uint8_t code, uint8_t len, const uint8_t *option,
 
                 assert_se(len == sizeof(uint8_t) + sizeof(uint32_t) + duid_len);
                 assert_se(len == 19);
-                assert_se(option[0] == 0xff);
+                assert_se(((uint8_t*) option)[0] == 0xff);
 
-                assert_se(memcmp(&option[1], &iaid, sizeof(iaid)) == 0);
-                assert_se(memcmp(&option[5], &duid, duid_len) == 0);
+                assert_se(memcmp((uint8_t*) option + 1, &iaid, sizeof(iaid)) == 0);
+                assert_se(memcmp((uint8_t*) option + 5, &duid, duid_len) == 0);
                 break;
         }
 
@@ -155,9 +146,7 @@ static int check_options(uint8_t code, uint8_t len, const uint8_t *option,
         return 0;
 }
 
-int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link,
-                                 const void *packet, size_t len)
-{
+int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) {
         size_t size;
         _cleanup_free_ DHCPPacket *discover;
         uint16_t ip_check, udp_check;
@@ -202,18 +191,20 @@ int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link,
         return 575;
 }
 
-int dhcp_network_bind_raw_socket(int index, union sockaddr_union *link,
-                                 uint32_t id, const uint8_t *addr,
-                                 size_t addr_len, uint16_t arp_type)
-{
+int dhcp_network_bind_raw_socket(
+                int index,
+                union sockaddr_union *link,
+                uint32_t id,
+                const uint8_t *addr, size_t addr_len,
+                uint16_t arp_type) {
+
         if (socketpair(AF_UNIX, SOCK_STREAM, 0, test_fd) < 0)
                 return -errno;
 
         return test_fd[0];
 }
 
-int dhcp_network_bind_udp_socket(be32_t address, uint16_t port)
-{
+int dhcp_network_bind_udp_socket(be32_t address, uint16_t port) {
         int fd;
 
         fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
@@ -223,14 +214,11 @@ int dhcp_network_bind_udp_socket(be32_t address, uint16_t port)
         return fd;
 }
 
-int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port,
-                                 const void *packet, size_t len)
-{
+int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port, const void *packet, size_t len) {
         return 0;
 }
 
-static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp)
-{
+static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp) {
         int res;
 
         res = dhcp_option_parse(dhcp, size, check_options, NULL);
@@ -242,8 +230,7 @@ static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp)
         return 0;
 }
 
-static void test_discover_message(sd_event *e)
-{
+static void test_discover_message(sd_event *e) {
         sd_dhcp_client *client;
         int res, r;
 
diff --git a/src/libsystemd-network/test-dhcp-option.c b/src/libsystemd-network/test-dhcp-option.c
index a63a4ea738..b1ef174849 100644
--- a/src/libsystemd-network/test-dhcp-option.c
+++ b/src/libsystemd-network/test-dhcp-option.c
@@ -145,8 +145,8 @@ static void test_ignore_opts(uint8_t *descoption, int *descpos, int *desclen) {
         }
 }
 
-static int test_options_cb(uint8_t code, uint8_t len, const uint8_t *option, void *user_data) {
-        struct option_desc *desc = user_data;
+static int test_options_cb(uint8_t code, uint8_t len, const void *option, void *userdata) {
+        struct option_desc *desc = userdata;
         uint8_t *descoption = NULL;
         int *desclen = NULL, *descpos = NULL;
         uint8_t optcode = 0;
@@ -207,10 +207,10 @@ static int test_options_cb(uint8_t code, uint8_t len, const uint8_t *option, voi
         for (i = 0; i < len; i++) {
 
                 if (verbose)
-                        printf("0x%02x(0x%02x) ", option[i],
+                        printf("0x%02x(0x%02x) ", ((uint8_t*) option)[i],
                                         descoption[*descpos + 2 + i]);
 
-                assert_se(option[i] == descoption[*descpos + 2 + i]);
+                assert_se(((uint8_t*) option)[i] == descoption[*descpos + 2 + i]);
         }
 
         if (verbose)
diff --git a/src/libsystemd-network/test-dhcp6-client.c b/src/libsystemd-network/test-dhcp6-client.c
index 6e62262443..12daac3211 100644
--- a/src/libsystemd-network/test-dhcp6-client.c
+++ b/src/libsystemd-network/test-dhcp6-client.c
@@ -501,8 +501,7 @@ static int test_client_verify_request(DHCP6Message *request, uint8_t *option,
         return 0;
 }
 
-static int test_client_send_advertise(DHCP6Message *solicit)
-{
+static int test_client_send_advertise(DHCP6Message *solicit) {
         DHCP6Message advertise;
 
         advertise.transaction_id = solicit->transaction_id;
diff --git a/src/libsystemd-network/test-ipv4ll.c b/src/libsystemd-network/test-ipv4ll.c
index 5677bfb2d2..d60ee98b25 100644
--- a/src/libsystemd-network/test-ipv4ll.c
+++ b/src/libsystemd-network/test-ipv4ll.c
@@ -39,9 +39,9 @@ static int test_fd[2];
 
 static int basic_request_handler_bind = 0;
 static int basic_request_handler_stop = 0;
-static void* basic_request_handler_user_data = (void*)0xCABCAB;
+static void* basic_request_handler_userdata = (void*)0xCABCAB;
 static void basic_request_handler(sd_ipv4ll *ll, int event, void *userdata) {
-        assert_se(userdata == basic_request_handler_user_data);
+        assert_se(userdata == basic_request_handler_userdata);
 
         switch(event) {
                 case IPV4LL_EVENT_STOP:
@@ -175,7 +175,7 @@ static void test_basic_request(sd_event *e) {
         assert_se(sd_ipv4ll_start(ll) == -EINVAL);
 
         assert_se(sd_ipv4ll_set_callback(ll, basic_request_handler,
-                                         basic_request_handler_user_data) == 0);
+                                         basic_request_handler_userdata) == 0);
         assert_se(sd_ipv4ll_start(ll) == -EINVAL);
 
         assert_se(sd_ipv4ll_set_index(ll, 1) == 0);