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

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright (C) 2014 Tom Gundersen
  Copyright (C) 2014-2015 Intel Corporation. All rights reserved.

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <errno.h>

#include "strv.h"
#include "util.h"

#include "dhcp6-lease-internal.h"
#include "dhcp6-protocol.h"

int dhcp6_lease_clear_timers(DHCP6IA *ia) {
        assert_return(ia, -EINVAL);

        ia->timeout_t1 = sd_event_source_unref(ia->timeout_t1);
        ia->timeout_t2 = sd_event_source_unref(ia->timeout_t2);

        return 0;
}

int dhcp6_lease_ia_rebind_expire(const DHCP6IA *ia, uint32_t *expire) {
        DHCP6Address *addr;
        uint32_t valid = 0, t;

        assert_return(ia, -EINVAL);
        assert_return(expire, -EINVAL);

        LIST_FOREACH(addresses, addr, ia->addresses) {
                t = be32toh(addr->iaaddr.lifetime_valid);
                if (valid < t)
                        valid = t;
        }

        t = be32toh(ia->lifetime_t2);
        if (t > valid)
                return -EINVAL;

        *expire = valid - t;

        return 0;
}

DHCP6IA *dhcp6_lease_free_ia(DHCP6IA *ia) {
        DHCP6Address *address;

        if (!ia)
                return NULL;

        dhcp6_lease_clear_timers(ia);

        while (ia->addresses) {
                address = ia->addresses;

                LIST_REMOVE(addresses, ia->addresses, address);

                free(address);
        }

        return NULL;
}

int dhcp6_lease_set_serverid(sd_dhcp6_lease *lease, const uint8_t *id,
                             size_t len) {
        assert_return(lease, -EINVAL);
        assert_return(id, -EINVAL);

        free(lease->serverid);

        lease->serverid = memdup(id, len);
        if (!lease->serverid)
                return -EINVAL;

        lease->serverid_len = len;

        return 0;
}

int dhcp6_lease_get_serverid(sd_dhcp6_lease *lease, uint8_t **id, size_t *len) {
        assert_return(lease, -EINVAL);
        assert_return(id, -EINVAL);
        assert_return(len, -EINVAL);

        *id = lease->serverid;
        *len = lease->serverid_len;

        return 0;
}

int dhcp6_lease_set_preference(sd_dhcp6_lease *lease, uint8_t preference) {
        assert_return(lease, -EINVAL);

        lease->preference = preference;

        return 0;
}

int dhcp6_lease_get_preference(sd_dhcp6_lease *lease, uint8_t *preference) {
        assert_return(preference, -EINVAL);

        if (!lease)
                return -EINVAL;

        *preference = lease->preference;

        return 0;
}

int dhcp6_lease_set_rapid_commit(sd_dhcp6_lease *lease) {
        assert_return(lease, -EINVAL);

        lease->rapid_commit = true;

        return 0;
}

int dhcp6_lease_get_rapid_commit(sd_dhcp6_lease *lease, bool *rapid_commit) {
        assert_return(lease, -EINVAL);
        assert_return(rapid_commit, -EINVAL);

        *rapid_commit = lease->rapid_commit;

        return 0;
}

int dhcp6_lease_get_iaid(sd_dhcp6_lease *lease, be32_t *iaid) {
        assert_return(lease, -EINVAL);
        assert_return(iaid, -EINVAL);

        *iaid = lease->ia.id;

        return 0;
}

int sd_dhcp6_lease_get_address(sd_dhcp6_lease *lease, struct in6_addr *addr,
                               uint32_t *lifetime_preferred,
                               uint32_t *lifetime_valid) {
        assert_return(lease, -EINVAL);
        assert_return(addr, -EINVAL);
        assert_return(lifetime_preferred, -EINVAL);
        assert_return(lifetime_valid, -EINVAL);

        if (!lease->addr_iter)
                return -ENOMSG;

        memcpy(addr, &lease->addr_iter->iaaddr.address,
                sizeof(struct in6_addr));
        *lifetime_preferred =
                be32toh(lease->addr_iter->iaaddr.lifetime_preferred);
        *lifetime_valid = be32toh(lease->addr_iter->iaaddr.lifetime_valid);

        lease->addr_iter = lease->addr_iter->addresses_next;

        return 0;
}

void sd_dhcp6_lease_reset_address_iter(sd_dhcp6_lease *lease) {
        if (lease)
                lease->addr_iter = lease->ia.addresses;
}

int dhcp6_lease_set_dns(sd_dhcp6_lease *lease, uint8_t *optval, size_t optlen) {
        int r;

        assert_return(lease, -EINVAL);
        assert_return(optval, -EINVAL);

        if (!optlen)
                return 0;

        r = dhcp6_option_parse_ip6addrs(optval, optlen, &lease->dns,
                                        lease->dns_count,
                                        &lease->dns_allocated);
        if (r < 0) {
                log_dhcp6_client(client, "Invalid DNS server option: %s",
                                 strerror(-r));

                return r;
        }

        lease->dns_count = r;

        return 0;
}

int sd_dhcp6_lease_get_dns(sd_dhcp6_lease *lease, struct in6_addr **addrs) {
        assert_return(lease, -EINVAL);
        assert_return(addrs, -EINVAL);

        if (lease->dns_count) {
                *addrs = lease->dns;
                return lease->dns_count;
        }

        return -ENOENT;
}

int dhcp6_lease_set_domains(sd_dhcp6_lease *lease, uint8_t *optval,
                            size_t optlen) {
        int r;
        char **domains;

        assert_return(lease, -EINVAL);
        assert_return(optval, -EINVAL);

        if (!optlen)
                return 0;

        r = dhcp6_option_parse_domainname(optval, optlen, &domains);
        if (r < 0)
                return 0;

        free(lease->domains);
        lease->domains = domains;
        lease->domains_count = r;

        return r;
}

int sd_dhcp6_lease_get_domains(sd_dhcp6_lease *lease, char ***domains) {
        assert_return(lease, -EINVAL);
        assert_return(domains, -EINVAL);

        if (lease->domains_count) {
                *domains = lease->domains;
                return lease->domains_count;
        }

        return -ENOENT;
}

int dhcp6_lease_set_ntp(sd_dhcp6_lease *lease, uint8_t *optval, size_t optlen) {
        int r;
        uint16_t subopt;
        size_t sublen;
        uint8_t *subval;

        assert_return(lease, -EINVAL);
        assert_return(optval, -EINVAL);

        free(lease->ntp);
        lease->ntp_count = 0;
        lease->ntp_allocated = 0;

        while ((r = dhcp6_option_parse(&optval, &optlen, &subopt, &sublen,
                                       &subval)) >= 0) {
                int s;
                char **servers;

                switch(subopt) {
                case DHCP6_NTP_SUBOPTION_SRV_ADDR:
                case DHCP6_NTP_SUBOPTION_MC_ADDR:
                        if (sublen != 16)
                                return 0;

                        s = dhcp6_option_parse_ip6addrs(subval, sublen,
                                                        &lease->ntp,
                                                        lease->ntp_count,
                                                        &lease->ntp_allocated);
                        if (s < 0)
                                return s;

                        lease->ntp_count = s;

                        break;

                case DHCP6_NTP_SUBOPTION_SRV_FQDN:
                        r = dhcp6_option_parse_domainname(subval, sublen,
                                                          &servers);
                        if (r < 0)
                                return 0;

                        lease->ntp_fqdn = strv_free(lease->ntp_fqdn);
                        lease->ntp_fqdn = servers;
                        lease->ntp_fqdn_count = r;

                        break;
                }
        }

        if (r != -ENOMSG)
                return r;

        return 0;
}

int dhcp6_lease_set_sntp(sd_dhcp6_lease *lease, uint8_t *optval, size_t optlen) {
        int r;

        assert_return(lease, -EINVAL);
        assert_return(optval, -EINVAL);

        if (!optlen)
                return 0;

        if (lease->ntp || lease->ntp_fqdn) {
                log_dhcp6_client(client, "NTP information already provided");

                return 0;
        }

        log_dhcp6_client(client, "Using deprecated SNTP information");

        r = dhcp6_option_parse_ip6addrs(optval, optlen, &lease->ntp,
                                        lease->ntp_count,
                                        &lease->ntp_allocated);
        if (r < 0) {
                log_dhcp6_client(client, "Invalid SNTP server option: %s",
                                 strerror(-r));

                return r;
        }

        lease->ntp_count = r;

        return 0;
}

int sd_dhcp6_lease_get_ntp_addrs(sd_dhcp6_lease *lease,
                                 struct in6_addr **addrs) {
        assert_return(lease, -EINVAL);
        assert_return(addrs, -EINVAL);

        if (lease->ntp_count) {
                *addrs = lease->ntp;
                return lease->ntp_count;
        }

        return -ENOENT;
}

int sd_dhcp6_lease_get_ntp_fqdn(sd_dhcp6_lease *lease, char ***ntp_fqdn) {
        assert_return(lease, -EINVAL);
        assert_return(ntp_fqdn, -EINVAL);

        if (lease->ntp_fqdn_count) {
                *ntp_fqdn = lease->ntp_fqdn;
                return lease->ntp_fqdn_count;
        }

        return -ENOENT;
}

sd_dhcp6_lease *sd_dhcp6_lease_ref(sd_dhcp6_lease *lease) {

        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)
                return NULL;

        assert(lease->n_ref >= 1);
        lease->n_ref--;

        if (lease->n_ref > 0)
                return NULL;

        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;
}

int dhcp6_lease_new(sd_dhcp6_lease **ret) {
        sd_dhcp6_lease *lease;

        lease = new0(sd_dhcp6_lease, 1);
        if (!lease)
                return -ENOMEM;

        lease->n_ref = 1;

        LIST_HEAD_INIT(lease->ia.addresses);

        *ret = lease;
        return 0;
}
Commit	Line	Data
13d276d0 MP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
13d276d0 MP	2
e842803a MB	3	/***
	4	This file is part of systemd.
	5
	6	Copyright (C) 2014 Tom Gundersen
13d276d0	7	Copyright (C) 2014-2015 Intel Corporation. All rights reserved.
e842803a MB	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
	23	#include <errno.h>
	24
13d276d0	25	#include "strv.h"
e842803a MB	26	#include "util.h"
	27
	28	#include "dhcp6-lease-internal.h"
13d276d0	29	#include "dhcp6-protocol.h"
e842803a MB	30
	31	int dhcp6_lease_clear_timers(DHCP6IA *ia) {
	32	assert_return(ia, -EINVAL);
	33
	34	ia->timeout_t1 = sd_event_source_unref(ia->timeout_t1);
	35	ia->timeout_t2 = sd_event_source_unref(ia->timeout_t2);
	36
	37	return 0;
	38	}
	39
	40	int dhcp6_lease_ia_rebind_expire(const DHCP6IA ia, uint32_t expire) {
	41	DHCP6Address *addr;
	42	uint32_t valid = 0, t;
	43
	44	assert_return(ia, -EINVAL);
	45	assert_return(expire, -EINVAL);
	46
	47	LIST_FOREACH(addresses, addr, ia->addresses) {
5eef597e	48	t = be32toh(addr->iaaddr.lifetime_valid);
e842803a MB	49	if (valid < t)
	50	valid = t;
	51	}
	52
	53	t = be32toh(ia->lifetime_t2);
	54	if (t > valid)
	55	return -EINVAL;
	56
	57	*expire = valid - t;
	58
	59	return 0;
	60	}
	61
	62	DHCP6IA dhcp6_lease_free_ia(DHCP6IA ia) {
	63	DHCP6Address *address;
	64
	65	if (!ia)
	66	return NULL;
	67
	68	dhcp6_lease_clear_timers(ia);
	69
	70	while (ia->addresses) {
	71	address = ia->addresses;
	72
	73	LIST_REMOVE(addresses, ia->addresses, address);
	74
	75	free(address);
	76	}
	77
	78	return NULL;
	79	}
	80
	81	int dhcp6_lease_set_serverid(sd_dhcp6_lease lease, const uint8_t id,
	82	size_t len) {
	83	assert_return(lease, -EINVAL);
	84	assert_return(id, -EINVAL);
	85
	86	free(lease->serverid);
	87
	88	lease->serverid = memdup(id, len);
	89	if (!lease->serverid)
	90	return -EINVAL;
	91
	92	lease->serverid_len = len;
	93
	94	return 0;
	95	}
	96
	97	int dhcp6_lease_get_serverid(sd_dhcp6_lease lease, uint8_t id, size_t len) {
	98	assert_return(lease, -EINVAL);
	99	assert_return(id, -EINVAL);
	100	assert_return(len, -EINVAL);
	101
	102	*id = lease->serverid;
	103	*len = lease->serverid_len;
	104
	105	return 0;
	106	}
	107
	108	int dhcp6_lease_set_preference(sd_dhcp6_lease *lease, uint8_t preference) {
	109	assert_return(lease, -EINVAL);
	110
	111	lease->preference = preference;
	112
113	return 0;
114	}
115
116	int dhcp6_lease_get_preference(sd_dhcp6_lease lease, uint8_t preference) {
e842803a MB	117	assert_return(preference, -EINVAL);
e842803a MB	118
f47781d8 MP	119	if (!lease)
	120	return -EINVAL;
	121
e842803a MB	122	*preference = lease->preference;
	123
	124	return 0;
	125	}
	126
	127	int dhcp6_lease_set_rapid_commit(sd_dhcp6_lease *lease) {
	128	assert_return(lease, -EINVAL);
	129
	130	lease->rapid_commit = true;
	131
	132	return 0;
	133	}
	134
	135	int dhcp6_lease_get_rapid_commit(sd_dhcp6_lease lease, bool rapid_commit) {
	136	assert_return(lease, -EINVAL);
	137	assert_return(rapid_commit, -EINVAL);
	138
	139	*rapid_commit = lease->rapid_commit;
	140
	141	return 0;
	142	}
	143
	144	int dhcp6_lease_get_iaid(sd_dhcp6_lease lease, be32_t iaid) {
	145	assert_return(lease, -EINVAL);
	146	assert_return(iaid, -EINVAL);
	147
	148	*iaid = lease->ia.id;
	149
	150	return 0;
	151	}
	152
e735f4d4 MP	153	int sd_dhcp6_lease_get_address(sd_dhcp6_lease lease, struct in6_addr addr,
	154	uint32_t *lifetime_preferred,
	155	uint32_t *lifetime_valid) {
e842803a MB	156	assert_return(lease, -EINVAL);
	157	assert_return(addr, -EINVAL);
	158	assert_return(lifetime_preferred, -EINVAL);
	159	assert_return(lifetime_valid, -EINVAL);
	160
	161	if (!lease->addr_iter)
	162	return -ENOMSG;
	163
5eef597e MP	164	memcpy(addr, &lease->addr_iter->iaaddr.address,
	165	sizeof(struct in6_addr));
	166	*lifetime_preferred =
	167	be32toh(lease->addr_iter->iaaddr.lifetime_preferred);
	168	*lifetime_valid = be32toh(lease->addr_iter->iaaddr.lifetime_valid);
e842803a MB	169
	170	lease->addr_iter = lease->addr_iter->addresses_next;
	171
	172	return 0;
	173	}
	174
e735f4d4 MP	175	void sd_dhcp6_lease_reset_address_iter(sd_dhcp6_lease *lease) {
	176	if (lease)
	177	lease->addr_iter = lease->ia.addresses;
e842803a MB	178	}
e842803a MB	179
13d276d0 MP	180	int dhcp6_lease_set_dns(sd_dhcp6_lease lease, uint8_t optval, size_t optlen) {
	181	int r;
	182
	183	assert_return(lease, -EINVAL);
	184	assert_return(optval, -EINVAL);
	185
	186	if (!optlen)
	187	return 0;
	188
	189	r = dhcp6_option_parse_ip6addrs(optval, optlen, &lease->dns,
	190	lease->dns_count,
	191	&lease->dns_allocated);
	192	if (r < 0) {
	193	log_dhcp6_client(client, "Invalid DNS server option: %s",
	194	strerror(-r));
	195
	196	return r;
	197	}
	198
	199	lease->dns_count = r;
	200
	201	return 0;
	202	}
	203
	204	int sd_dhcp6_lease_get_dns(sd_dhcp6_lease lease, struct in6_addr *addrs) {
	205	assert_return(lease, -EINVAL);
	206	assert_return(addrs, -EINVAL);
	207
	208	if (lease->dns_count) {
	209	*addrs = lease->dns;
	210	return lease->dns_count;
	211	}
	212
	213	return -ENOENT;
	214	}
	215
	216	int dhcp6_lease_set_domains(sd_dhcp6_lease lease, uint8_t optval,
	217	size_t optlen) {
	218	int r;
	219	char **domains;
	220
	221	assert_return(lease, -EINVAL);
	222	assert_return(optval, -EINVAL);
	223
	224	if (!optlen)
	225	return 0;
	226
	227	r = dhcp6_option_parse_domainname(optval, optlen, &domains);
	228	if (r < 0)
	229	return 0;
	230
	231	free(lease->domains);
	232	lease->domains = domains;
	233	lease->domains_count = r;
	234
	235	return r;
	236	}
	237
	238	int sd_dhcp6_lease_get_domains(sd_dhcp6_lease lease, char **domains) {
	239	assert_return(lease, -EINVAL);
	240	assert_return(domains, -EINVAL);
	241
	242	if (lease->domains_count) {
	243	*domains = lease->domains;
244	return lease->domains_count;
245	}
246
247	return -ENOENT;
248	}
249
d9dfd233	250	int dhcp6_lease_set_ntp(sd_dhcp6_lease lease, uint8_t optval, size_t optlen) {
13d276d0 MP	251	int r;
	252	uint16_t subopt;
	253	size_t sublen;
	254	uint8_t *subval;
	255
	256	assert_return(lease, -EINVAL);
	257	assert_return(optval, -EINVAL);
	258
	259	free(lease->ntp);
	260	lease->ntp_count = 0;
	261	lease->ntp_allocated = 0;
	262
	263	while ((r = dhcp6_option_parse(&optval, &optlen, &subopt, &sublen,
	264	&subval)) >= 0) {
	265	int s;
	266	char **servers;
	267
	268	switch(subopt) {
	269	case DHCP6_NTP_SUBOPTION_SRV_ADDR:
	270	case DHCP6_NTP_SUBOPTION_MC_ADDR:
	271	if (sublen != 16)
	272	return 0;
	273
	274	s = dhcp6_option_parse_ip6addrs(subval, sublen,
	275	&lease->ntp,
	276	lease->ntp_count,
	277	&lease->ntp_allocated);
	278	if (s < 0)
	279	return s;
	280
	281	lease->ntp_count = s;
	282
	283	break;
	284
	285	case DHCP6_NTP_SUBOPTION_SRV_FQDN:
	286	r = dhcp6_option_parse_domainname(subval, sublen,
	287	&servers);
	288	if (r < 0)
	289	return 0;
	290
	291	lease->ntp_fqdn = strv_free(lease->ntp_fqdn);
	292	lease->ntp_fqdn = servers;
	293	lease->ntp_fqdn_count = r;
	294
	295	break;
	296	}
	297	}
	298
	299	if (r != -ENOMSG)
	300	return r;
	301
	302	return 0;
	303	}
	304
	305	int dhcp6_lease_set_sntp(sd_dhcp6_lease lease, uint8_t optval, size_t optlen) {
	306	int r;
	307
	308	assert_return(lease, -EINVAL);
	309	assert_return(optval, -EINVAL);
	310
	311	if (!optlen)
	312	return 0;
	313
	314	if (lease->ntp \|\| lease->ntp_fqdn) {
315	log_dhcp6_client(client, "NTP information already provided");
316
317	return 0;
318	}
319
320	log_dhcp6_client(client, "Using deprecated SNTP information");
321
322	r = dhcp6_option_parse_ip6addrs(optval, optlen, &lease->ntp,
323	lease->ntp_count,
324	&lease->ntp_allocated);
325	if (r < 0) {
326	log_dhcp6_client(client, "Invalid SNTP server option: %s",
327	strerror(-r));
328
329	return r;
330	}
331
332	lease->ntp_count = r;
333
334	return 0;
335	}
336
337	int sd_dhcp6_lease_get_ntp_addrs(sd_dhcp6_lease *lease,
338	struct in6_addr **addrs) {
339	assert_return(lease, -EINVAL);
340	assert_return(addrs, -EINVAL);
341
342	if (lease->ntp_count) {
343	*addrs = lease->ntp;
344	return lease->ntp_count;
345	}
346
347	return -ENOENT;
348	}
349
350	int sd_dhcp6_lease_get_ntp_fqdn(sd_dhcp6_lease lease, char **ntp_fqdn) {
351	assert_return(lease, -EINVAL);
352	assert_return(ntp_fqdn, -EINVAL);
353
354	if (lease->ntp_fqdn_count) {
355	*ntp_fqdn = lease->ntp_fqdn;
356	return lease->ntp_fqdn_count;
357	}
358
359	return -ENOENT;
360	}
361
e842803a	362	sd_dhcp6_lease sd_dhcp6_lease_ref(sd_dhcp6_lease lease) {
d9dfd233 MP	363
	364	if (!lease)
	365	return NULL;
	366
	367	assert(lease->n_ref >= 1);
	368	lease->n_ref++;
e842803a MB	369
	370	return lease;
	371	}
	372
	373	sd_dhcp6_lease sd_dhcp6_lease_unref(sd_dhcp6_lease lease) {
e842803a	374
d9dfd233 MP	375	if (!lease)
d9dfd233 MP	376	return NULL;
13d276d0	377
d9dfd233 MP	378	assert(lease->n_ref >= 1);
d9dfd233 MP	379	lease->n_ref--;
13d276d0	380
d9dfd233 MP	381	if (lease->n_ref > 0)
d9dfd233 MP	382	return NULL;
13d276d0	383
d9dfd233 MP	384	free(lease->serverid);
	385	dhcp6_lease_free_ia(&lease->ia);
	386
	387	free(lease->dns);
	388
	389	lease->domains = strv_free(lease->domains);
	390
	391	free(lease->ntp);
	392
	393	lease->ntp_fqdn = strv_free(lease->ntp_fqdn);
	394	free(lease);
e842803a MB	395
	396	return NULL;
	397	}
	398
	399	int dhcp6_lease_new(sd_dhcp6_lease **ret) {
	400	sd_dhcp6_lease *lease;
	401
	402	lease = new0(sd_dhcp6_lease, 1);
	403	if (!lease)
	404	return -ENOMEM;
	405
d9dfd233	406	lease->n_ref = 1;
e842803a MB	407
	408	LIST_HEAD_INIT(lease->ia.addresses);
	409
	410	*ret = lease;
	411	return 0;
	412	}