dhcp: clean up dhcp4 lease object

a) drop handling of obsolete or unused DHCP options time_offset,
   mtu_aging_timeout, policy filter, mdr, ttl, ip forwarding settings.
   Should this become useful one day we can readd support for this.

b) For subnet mask and broadcast it is not always clear whether 0 or
   255.255.255.255 might be valid, hence maintain a boolean indicating
   validity next to it.

c) serialize/deserialize broadcast address, lifetime, T1 and T2 together
   with the rest of the fields in dhcp_lease_save() and
   dhcp_lease_load().

d) consistently return ENODATA from getter functions for data that is
   missing in the lease.

e) add missing getter calls for broadcast, lifetime, T1, T2.

f) when decoding DHCP options, generate debug messages on parse
   failures, but try to proceed if possible.

g) Similar, when deserializing a lease in dhcp_lease_load(), make sure
   we deal nicely with unparsable fields, to provide upgrade compat.

h) fix some memory allocations

1 files changed, 372 insertions, 270 deletions

diff --git a/src/libsystemd-network/sd-dhcp-lease.c b/src/libsystemd-network/sd-dhcp-lease.c
index 328ab152b8..123ea68f19 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,37 +192,34 @@ 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 void **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;
 }
 
@@ -237,67 +266,52 @@ sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease) {
         return NULL;
 }
 
-static void lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_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 == 4) {
-                *ret = unaligned_read_be32((be32_t*) option);
-
-                if (*ret < min)
-                        *ret = min;
-        }
-}
-
-static void lease_parse_s32(const uint8_t *option, size_t len, int32_t *ret) {
-        lease_parse_u32(option, len, (uint32_t *)ret, 0);
-}
-
-static void lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
-        assert(option);
-        assert(ret);
+        if (len != 4)
+                return -EINVAL;
 
-        if (len == 2) {
-                *ret = unaligned_read_be16((be16_t*) option);
+        *ret = unaligned_read_be32((be32_t*) option);
+        if (*ret < min)
+                *ret = min;
 
-                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))
@@ -309,54 +323,52 @@ static int lease_parse_string(const uint8_t *option, size_t len, char **ret) {
 
                 free(*ret);
                 *ret = string;
-        } else
-                *ret = mfree(*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;
 
-                addresses = newdup(struct in_addr, option, size);
+                n_addresses = len / 4;
+
+                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)
@@ -371,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;
@@ -390,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) {
@@ -405,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;
 
@@ -444,70 +460,76 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
 
         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:
-                return lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
-
-        case DHCP_OPTION_NTP_SERVER:
-                return lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
-
-        case DHCP_OPTION_POLICY_FILTER:
-                return lease_parse_in_addrs_pairs(option, len, &lease->policy_filter, &lease->policy_filter_size);
-
-        case DHCP_OPTION_STATIC_ROUTE:
-                return lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size, &lease->static_route_allocated);
-
-        case DHCP_OPTION_INTERFACE_MTU:
-                lease_parse_u16(option, len, &lease->mtu, 68);
+                r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse DNS server, ignoring: %m");
                 break;
 
-        case DHCP_OPTION_INTERFACE_MDR:
-                lease_parse_u16(option, len, &lease->mdr, 576);
+        case DHCP_OPTION_NTP_SERVER:
+                r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse NTP server, ignoring: %m");
                 break;
 
-        case DHCP_OPTION_INTERFACE_TTL:
-                lease_parse_u8(option, len, &lease->ttl, 1);
+        case DHCP_OPTION_STATIC_ROUTE:
+                r = lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size, &lease->static_route_allocated);
+                if (r < 0)
+                        log_debug_errno(r, "Failed to parse static routes, ignoring: %m");
                 break;
 
-        case DHCP_OPTION_BOOT_FILE_SIZE:
-                lease_parse_u16(option, len, &lease->boot_file_size, 0);
+        case DHCP_OPTION_INTERFACE_MTU:
+                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, *normalized = NULL;
 
                 r = lease_parse_string(option, len, &domainname);
-                if (r < 0)
-                        return r;
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to parse domain name, ignoring: %m");
+                        return 0;
+                }
 
                 r = dns_name_normalize(domainname, &normalized);
                 if (r < 0) {
@@ -531,12 +553,14 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
                 _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;
+                }
 
                 r = dns_name_normalize(hostname, &normalized);
                 if (r < 0) {
-                        log_debug_errno(r, "Failed to normalize host name '%s': %m", hostname);
+                        log_debug_errno(r, "Failed to normalize host name '%s', ignoring: %m", hostname);
                         return 0;
                 }
 
@@ -553,80 +577,97 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
         }
 
         case DHCP_OPTION_ROOT_PATH:
-                return lease_parse_string(option, len, &lease->root_path);
+                r = lease_parse_string(option, len, &lease->root_path);
+                if (r < 0)
+                        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);
-                break;
-
-        case DHCP_OPTION_ENABLE_IP_FORWARDING:
-                lease_parse_bool(option, len, &lease->ip_forward);
-                break;
-
-        case DHCP_OPTION_ENABLE_IP_FORWARDING_NL:
-                lease_parse_bool(option, len, &lease->ip_forward_non_local);
+                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_CLASSLESS_STATIC_ROUTE:
-                return lease_parse_classless_routes(
+                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_NEW_TZDB_TIMEZONE: {
                 _cleanup_free_ char *tz = NULL;
 
                 r = lease_parse_string(option, len, &tz);
-                if (r < 0)
-                        return r;
+                if (r < 0) {
+                        log_debug_errno(r, "Failed to parse timezone option, ignoring: %m");
+                        return 0;
+                }
 
-                if (!timezone_is_valid(tz))
-                        return -EINVAL;
+                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 void *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;
                 }
         }
@@ -644,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;
 }
 
@@ -657,7 +697,6 @@ int dhcp_lease_new(sd_dhcp_lease **ret) {
 
         lease->router = INADDR_ANY;
         lease->n_ref = 1;
-        LIST_HEAD_INIT(lease->private_options);
 
         *ret = lease;
         return 0;
@@ -674,6 +713,7 @@ int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
         const char *string;
         uint16_t mtu;
         struct sd_dhcp_route *routes;
+        uint32_t t1, t2, lifetime;
         int r;
 
         assert(lease);
@@ -685,19 +725,16 @@ int 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)
@@ -705,28 +742,45 @@ int 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)
@@ -741,7 +795,7 @@ int 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);
@@ -774,6 +828,7 @@ int 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)
@@ -799,15 +854,26 @@ fail:
 }
 
 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);
@@ -823,6 +889,7 @@ int 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,
@@ -833,6 +900,9 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                            "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],
@@ -865,88 +935,109 @@ int 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++) {
@@ -957,8 +1048,10 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
                         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)
@@ -972,12 +1065,14 @@ int 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 */
@@ -986,33 +1081,40 @@ 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 void **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 void *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;
         }
 
@@ -1024,7 +1126,7 @@ int sd_dhcp_lease_get_timezone(sd_dhcp_lease *lease, const char **timezone) {
         assert_return(timezone, -EINVAL);
 
         if (!lease->timezone)
-                return -ENXIO;
+                return -ENODATA;
 
         *timezone = lease->timezone;
         return 0;