src/libsystemd-network/sd-dhcp6-lease.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright (C) 2014 Tom Gundersen
   7   Copyright (C) 2014-2015 Intel Corporation. All rights reserved.
   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
  25 #include "alloc-util.h"
  26 #include "dhcp6-lease-internal.h"
  27 #include "dhcp6-protocol.h"
  28 #include "strv.h"
  29 #include "util.h"
  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) {
  48                 t = be32toh(addr->iaaddr.lifetime_valid);
  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) {
 117         assert_return(preference, -EINVAL);
 118
 119         if (!lease)
 120                 return -EINVAL;
 121
 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
 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) {
 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
 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);
 169
 170         lease->addr_iter = lease->addr_iter->addresses_next;
 171
 172         return 0;
 173 }
 174
 175 void sd_dhcp6_lease_reset_address_iter(sd_dhcp6_lease *lease) {
 176         if (lease)
 177                 lease->addr_iter = lease->ia.addresses;
 178 }
 179
 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
 250 int dhcp6_lease_set_ntp(sd_dhcp6_lease *lease, uint8_t *optval, size_t optlen) {
 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         lease->ntp = mfree(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
 362 sd_dhcp6_lease *sd_dhcp6_lease_ref(sd_dhcp6_lease *lease) {
 363
 364         if (!lease)
 365                 return NULL;
 366
 367         assert(lease->n_ref >= 1);
 368         lease->n_ref++;
 369
 370         return lease;
 371 }
 372
 373 sd_dhcp6_lease *sd_dhcp6_lease_unref(sd_dhcp6_lease *lease) {
 374
 375         if (!lease)
 376                 return NULL;
 377
 378         assert(lease->n_ref >= 1);
 379         lease->n_ref--;
 380
 381         if (lease->n_ref > 0)
 382                 return NULL;
 383
 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);
 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
 406         lease->n_ref = 1;
 407
 408         LIST_HEAD_INIT(lease->ia.addresses);
 409
 410         *ret = lease;
 411         return 0;
 412 }