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

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright (C) 2013 Intel Corporation. All rights reserved.
   5   Copyright (C) 2014 Tom Gundersen
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <stdlib.h>
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <arpa/inet.h>
  26
  27 #include "fileio.h"
  28 #include "unaligned.h"
  29 #include "in-addr-util.h"
  30 #include "hostname-util.h"
  31 #include "dhcp-protocol.h"
  32 #include "dhcp-lease-internal.h"
  33 #include "sd-dhcp-lease.h"
  34 #include "network-internal.h"
  35 #include "dns-domain.h"
  36
  37 int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr) {
  38         assert_return(lease, -EINVAL);
  39         assert_return(addr, -EINVAL);
  40
  41         addr->s_addr = lease->address;
  42
  43         return 0;
  44 }
  45
  46 int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime) {
  47         assert_return(lease, -EINVAL);
  48         assert_return(lifetime, -EINVAL);
  49
  50         *lifetime = lease->lifetime;
  51
  52         return 0;
  53 }
  54
  55 int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
  56         assert_return(lease, -EINVAL);
  57         assert_return(mtu, -EINVAL);
  58
  59         if (lease->mtu)
  60                 *mtu = lease->mtu;
  61         else
  62                 return -ENOENT;
  63
  64         return 0;
  65 }
  66
  67 int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr) {
  68         assert_return(lease, -EINVAL);
  69         assert_return(addr, -EINVAL);
  70
  71         if (lease->dns_size) {
  72                 *addr = lease->dns;
  73                 return lease->dns_size;
  74         } else
  75                 return -ENOENT;
  76
  77         return 0;
  78 }
  79
  80 int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr) {
  81         assert_return(lease, -EINVAL);
  82         assert_return(addr, -EINVAL);
  83
  84         if (lease->ntp_size) {
  85                 *addr = lease->ntp;
  86                 return lease->ntp_size;
  87         } else
  88                 return -ENOENT;
  89
  90         return 0;
  91 }
  92
  93 int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname) {
  94         assert_return(lease, -EINVAL);
  95         assert_return(domainname, -EINVAL);
  96
  97         if (lease->domainname)
  98                 *domainname = lease->domainname;
  99         else
 100                 return -ENOENT;
 101
 102         return 0;
 103 }
 104
 105 int sd_dhcp_lease_get_hostname(sd_dhcp_lease *lease, const char **hostname) {
 106         assert_return(lease, -EINVAL);
 107         assert_return(hostname, -EINVAL);
 108
 109         if (lease->hostname)
 110                 *hostname = lease->hostname;
 111         else
 112                 return -ENOENT;
 113
 114         return 0;
 115 }
 116
 117 int sd_dhcp_lease_get_root_path(sd_dhcp_lease *lease, const char **root_path) {
 118         assert_return(lease, -EINVAL);
 119         assert_return(root_path, -EINVAL);
 120
 121         if (lease->root_path)
 122                 *root_path = lease->root_path;
 123         else
 124                 return -ENOENT;
 125
 126         return 0;
 127 }
 128
 129 int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, struct in_addr *addr) {
 130         assert_return(lease, -EINVAL);
 131         assert_return(addr, -EINVAL);
 132
 133         if (lease->router != INADDR_ANY)
 134                 addr->s_addr = lease->router;
 135         else
 136                 return -ENOENT;
 137
 138         return 0;
 139 }
 140
 141 int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr) {
 142         assert_return(lease, -EINVAL);
 143         assert_return(addr, -EINVAL);
 144
 145         addr->s_addr = lease->subnet_mask;
 146
 147         return 0;
 148 }
 149
 150 int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *addr) {
 151         assert_return(lease, -EINVAL);
 152         assert_return(addr, -EINVAL);
 153
 154         addr->s_addr = lease->server_address;
 155
 156         return 0;
 157 }
 158
 159 int sd_dhcp_lease_get_next_server(sd_dhcp_lease *lease, struct in_addr *addr) {
 160         assert_return(lease, -EINVAL);
 161         assert_return(addr, -EINVAL);
 162
 163         addr->s_addr = lease->next_server;
 164
 165         return 0;
 166 }
 167
 168 int sd_dhcp_lease_get_routes(sd_dhcp_lease *lease, struct sd_dhcp_route **routes) {
 169
 170         assert_return(lease, -EINVAL);
 171         assert_return(routes, -EINVAL);
 172
 173         if (lease->static_route_size) {
 174                 *routes = lease->static_route;
 175                 return lease->static_route_size;
 176         } else
 177                 return -ENOENT;
 178
 179         return 0;
 180 }
 181
 182 int sd_dhcp_lease_get_vendor_specific(sd_dhcp_lease *lease, const uint8_t **data,
 183                                       size_t *data_len) {
 184         assert_return(lease, -EINVAL);
 185         assert_return(data, -EINVAL);
 186         assert_return(data_len, -EINVAL);
 187
 188         if (!lease->vendor_specific)
 189                 return -ENOENT;
 190
 191         *data = lease->vendor_specific;
 192         *data_len = lease->vendor_specific_len;
 193
 194         return 0;
 195 }
 196
 197 sd_dhcp_lease *sd_dhcp_lease_ref(sd_dhcp_lease *lease) {
 198         if (lease)
 199                 assert_se(REFCNT_INC(lease->n_ref) >= 2);
 200
 201         return lease;
 202 }
 203
 204 sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease) {
 205         if (lease && REFCNT_DEC(lease->n_ref) == 0) {
 206                 while (lease->private_options) {
 207                         struct sd_dhcp_raw_option *option = lease->private_options;
 208
 209                         LIST_REMOVE(options, lease->private_options, option);
 210
 211                         free(option->data);
 212                         free(option);
 213                 }
 214                 free(lease->hostname);
 215                 free(lease->domainname);
 216                 free(lease->dns);
 217                 free(lease->ntp);
 218                 free(lease->static_route);
 219                 free(lease->client_id);
 220                 free(lease->vendor_specific);
 221                 free(lease);
 222         }
 223
 224         return NULL;
 225 }
 226
 227 static void lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_t min) {
 228         assert(option);
 229         assert(ret);
 230
 231         if (len == 4) {
 232                 *ret = unaligned_read_be32((be32_t*) option);
 233
 234                 if (*ret < min)
 235                         *ret = min;
 236         }
 237 }
 238
 239 static void lease_parse_s32(const uint8_t *option, size_t len, int32_t *ret) {
 240         lease_parse_u32(option, len, (uint32_t *)ret, 0);
 241 }
 242
 243 static void lease_parse_u16(const uint8_t *option, size_t len, uint16_t *ret, uint16_t min) {
 244         assert(option);
 245         assert(ret);
 246
 247         if (len == 2) {
 248                 *ret = unaligned_read_be16((be16_t*) option);
 249
 250                 if (*ret < min)
 251                         *ret = min;
 252         }
 253 }
 254
 255 static void lease_parse_be32(const uint8_t *option, size_t len, be32_t *ret) {
 256         assert(option);
 257         assert(ret);
 258
 259         if (len == 4)
 260                 memcpy(ret, option, 4);
 261 }
 262
 263 static void lease_parse_bool(const uint8_t *option, size_t len, bool *ret) {
 264         assert(option);
 265         assert(ret);
 266
 267         if (len == 1)
 268                 *ret = !!(*option);
 269 }
 270
 271 static void lease_parse_u8(const uint8_t *option, size_t len, uint8_t *ret, uint8_t min) {
 272         assert(option);
 273         assert(ret);
 274
 275         if (len == 1) {
 276                 *ret = *option;
 277
 278                 if (*ret < min)
 279                         *ret = min;
 280         }
 281 }
 282
 283 static int lease_parse_string(const uint8_t *option, size_t len, char **ret) {
 284         assert(option);
 285         assert(ret);
 286
 287         if (len >= 1) {
 288                 char *string;
 289
 290                 string = strndup((const char *)option, len);
 291                 if (!string)
 292                         return -errno;
 293
 294                 free(*ret);
 295                 *ret = string;
 296         }
 297
 298         return 0;
 299 }
 300
 301 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) {
 302         assert(option);
 303         assert(ret);
 304         assert(ret_size);
 305
 306         if (len && !(len % (4 * mult))) {
 307                 size_t size;
 308                 struct in_addr *addresses;
 309
 310                 size = len / 4;
 311
 312                 addresses = newdup(struct in_addr, option, size);
 313                 if (!addresses)
 314                         return -ENOMEM;
 315
 316                 free(*ret);
 317                 *ret = addresses;
 318                 *ret_size = size;
 319         }
 320
 321         return 0;
 322 }
 323
 324 static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *ret_size) {
 325         return lease_parse_in_addrs_aux(option, len, ret, ret_size, 1);
 326 }
 327
 328 static int lease_parse_in_addrs_pairs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *ret_size) {
 329         return lease_parse_in_addrs_aux(option, len, ret, ret_size, 2);
 330 }
 331
 332 static int lease_parse_routes(const uint8_t *option, size_t len, struct sd_dhcp_route **routes,
 333         size_t *routes_size, size_t *routes_allocated) {
 334
 335         struct in_addr addr;
 336
 337         assert(option);
 338         assert(routes);
 339         assert(routes_size);
 340         assert(routes_allocated);
 341
 342         if (!len)
 343                 return 0;
 344
 345         if (len % 8 != 0)
 346                 return -EINVAL;
 347
 348         if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + (len / 8)))
 349                 return -ENOMEM;
 350
 351         while (len >= 8) {
 352                 struct sd_dhcp_route *route = *routes + *routes_size;
 353                 int r;
 354
 355                 r = in_addr_default_prefixlen((struct in_addr*) option, &route->dst_prefixlen);
 356                 if (r < 0) {
 357                         log_error("Failed to determine destination prefix length from class based IP, ignoring");
 358                         continue;
 359                 }
 360
 361                 lease_parse_be32(option, 4, &addr.s_addr);
 362                 route->dst_addr = inet_makeaddr(inet_netof(addr), 0);
 363                 option += 4;
 364
 365                 lease_parse_be32(option, 4, &route->gw_addr.s_addr);
 366                 option += 4;
 367
 368                 len -= 8;
 369                 (*routes_size)++;
 370         }
 371
 372         return 0;
 373 }
 374
 375 /* parses RFC3442 Classless Static Route Option */
 376 static int lease_parse_classless_routes(const uint8_t *option, size_t len, struct sd_dhcp_route **routes,
 377         size_t *routes_size, size_t *routes_allocated) {
 378
 379         assert(option);
 380         assert(routes);
 381         assert(routes_size);
 382         assert(routes_allocated);
 383
 384         /* option format: (subnet-mask-width significant-subnet-octets gateway-ip)*  */
 385
 386         while (len > 0) {
 387                 uint8_t dst_octets;
 388                 struct sd_dhcp_route *route;
 389
 390                 if (!GREEDY_REALLOC(*routes, *routes_allocated, *routes_size + 1))
 391                     return -ENOMEM;
 392
 393                 route = *routes + *routes_size;
 394
 395                 dst_octets = (*option == 0 ? 0 : ((*option - 1) / 8) + 1);
 396                 route->dst_prefixlen = *option;
 397                 option++;
 398                 len--;
 399
 400                 /* can't have more than 4 octets in IPv4 */
 401                 if (dst_octets > 4 || len < dst_octets)
 402                         return -EINVAL;
 403
 404                 route->dst_addr.s_addr = 0;
 405                 memcpy(&route->dst_addr.s_addr, option, dst_octets);
 406                 option += dst_octets;
 407                 len -= dst_octets;
 408
 409                 if (len < 4)
 410                         return -EINVAL;
 411
 412                 lease_parse_be32(option, 4, &route->gw_addr.s_addr);
 413                 option += 4;
 414                 len -= 4;
 415
 416                 (*routes_size)++;
 417         }
 418
 419         return 0;
 420 }
 421
 422 int dhcp_lease_parse_options(uint8_t code, uint8_t len, const uint8_t *option,
 423                               void *user_data) {
 424         sd_dhcp_lease *lease = user_data;
 425         int r;
 426
 427         assert(lease);
 428
 429         switch(code) {
 430
 431         case DHCP_OPTION_TIME_OFFSET:
 432                 lease_parse_s32(option, len, &lease->time_offset);
 433
 434                 break;
 435
 436         case DHCP_OPTION_INTERFACE_MTU_AGING_TIMEOUT:
 437                 lease_parse_u32(option, len, &lease->mtu_aging_timeout, 0);
 438
 439                 break;
 440
 441         case DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
 442                 lease_parse_u32(option, len, &lease->lifetime, 1);
 443
 444                 break;
 445
 446         case DHCP_OPTION_SERVER_IDENTIFIER:
 447                 lease_parse_be32(option, len, &lease->server_address);
 448
 449                 break;
 450
 451         case DHCP_OPTION_SUBNET_MASK:
 452                 lease_parse_be32(option, len, &lease->subnet_mask);
 453
 454                 break;
 455
 456         case DHCP_OPTION_BROADCAST:
 457                 lease_parse_be32(option, len, &lease->broadcast);
 458
 459                 break;
 460
 461         case DHCP_OPTION_ROUTER:
 462                 if(len >= 4)
 463                         lease_parse_be32(option, 4, &lease->router);
 464
 465                 break;
 466
 467         case DHCP_OPTION_DOMAIN_NAME_SERVER:
 468                 r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
 469                 if (r < 0)
 470                         return r;
 471
 472                 break;
 473
 474         case DHCP_OPTION_NTP_SERVER:
 475                 r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
 476                 if (r < 0)
 477                         return r;
 478
 479                 break;
 480
 481         case DHCP_OPTION_POLICY_FILTER:
 482                 r = lease_parse_in_addrs_pairs(option, len, &lease->policy_filter, &lease->policy_filter_size);
 483                 if (r < 0)
 484                         return r;
 485
 486                 break;
 487
 488         case DHCP_OPTION_STATIC_ROUTE:
 489                 r = lease_parse_routes(option, len, &lease->static_route, &lease->static_route_size,
 490                         &lease->static_route_allocated);
 491                 if (r < 0)
 492                         return r;
 493
 494                 break;
 495
 496         case DHCP_OPTION_INTERFACE_MTU:
 497                 lease_parse_u16(option, len, &lease->mtu, 68);
 498
 499                 break;
 500
 501         case DHCP_OPTION_INTERFACE_MDR:
 502                 lease_parse_u16(option, len, &lease->mdr, 576);
 503
 504                 break;
 505
 506         case DHCP_OPTION_INTERFACE_TTL:
 507                 lease_parse_u8(option, len, &lease->ttl, 1);
 508
 509                 break;
 510
 511         case DHCP_OPTION_BOOT_FILE_SIZE:
 512                 lease_parse_u16(option, len, &lease->boot_file_size, 0);
 513
 514                 break;
 515
 516         case DHCP_OPTION_DOMAIN_NAME:
 517         {
 518                 _cleanup_free_ char *domainname = NULL;
 519                 char *e;
 520
 521                 r = lease_parse_string(option, len, &domainname);
 522                 if (r < 0)
 523                         return r;
 524
 525                 /* Chop off trailing dot of domain name that some DHCP
 526                  * servers send us back. Internally we want to store
 527                  * host names without trailing dots and
 528                  * host_name_is_valid() doesn't accept them. */
 529                 e = endswith(domainname, ".");
 530                 if (e)
 531                         *e = 0;
 532
 533                 if (is_localhost(domainname))
 534                         break;
 535
 536                 r = dns_name_is_valid(domainname);
 537                 if (r <= 0) {
 538                         if (r < 0)
 539                                 log_error_errno(r, "Failed to validate domain name: %s: %m", domainname);
 540                         if (r == 0)
 541                                 log_warning("Domain name is not valid, ignoring: %s", domainname);
 542                         break;
 543                 }
 544
 545                 free(lease->domainname);
 546                 lease->domainname = domainname;
 547                 domainname = NULL;
 548
 549                 break;
 550         }
 551         case DHCP_OPTION_HOST_NAME:
 552         {
 553                 _cleanup_free_ char *hostname = NULL;
 554                 char *e;
 555
 556                 r = lease_parse_string(option, len, &hostname);
 557                 if (r < 0)
 558                         return r;
 559
 560                 e = endswith(hostname, ".");
 561                 if (e)
 562                         *e = 0;
 563
 564                 if (!hostname_is_valid(hostname, false) || is_localhost(hostname))
 565                         break;
 566
 567                 free_and_replace(&lease->hostname, hostname);
 568                 hostname = NULL;
 569
 570                 break;
 571         }
 572         case DHCP_OPTION_ROOT_PATH:
 573                 r = lease_parse_string(option, len, &lease->root_path);
 574                 if (r < 0)
 575                         return r;
 576
 577                 break;
 578
 579         case DHCP_OPTION_RENEWAL_T1_TIME:
 580                 lease_parse_u32(option, len, &lease->t1, 1);
 581
 582                 break;
 583
 584         case DHCP_OPTION_REBINDING_T2_TIME:
 585                 lease_parse_u32(option, len, &lease->t2, 1);
 586
 587                 break;
 588
 589         case DHCP_OPTION_ENABLE_IP_FORWARDING:
 590                 lease_parse_bool(option, len, &lease->ip_forward);
 591
 592                 break;
 593
 594         case DHCP_OPTION_ENABLE_IP_FORWARDING_NL:
 595                 lease_parse_bool(option, len, &lease->ip_forward_non_local);
 596
 597                 break;
 598
 599         case DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
 600                 r = lease_parse_classless_routes(option, len, &lease->static_route, &lease->static_route_size,
 601                         &lease->static_route_allocated);
 602                 if (r < 0)
 603                         return r;
 604
 605                 break;
 606
 607         case DHCP_OPTION_VENDOR_SPECIFIC:
 608                 if (len >= 1) {
 609                         free(lease->vendor_specific);
 610                         lease->vendor_specific = memdup(option, len);
 611                         if (!lease->vendor_specific)
 612                                 return -ENOMEM;
 613                         lease->vendor_specific_len = len;
 614                 }
 615
 616                break;
 617
 618         default:
 619                 if (code < DHCP_OPTION_PRIVATE_BASE || code > DHCP_OPTION_PRIVATE_LAST)
 620                     break;
 621
 622                 r = dhcp_lease_insert_private_option(lease, code, option, len);
 623                 if (r < 0)
 624                         return r;
 625         }
 626
 627         return 0;
 628 }
 629
 630 int dhcp_lease_insert_private_option(sd_dhcp_lease *lease, uint8_t tag,
 631                                      const uint8_t *data, uint8_t len) {
 632         struct sd_dhcp_raw_option *cur, *option;
 633
 634         LIST_FOREACH(options, cur, lease->private_options) {
 635                 if (tag < cur->tag)
 636                         break;
 637                 else if (tag == cur->tag) {
 638                         log_error("Ignoring duplicate option, tagged %d.", tag);
 639                         return 0;
 640                 }
 641         }
 642
 643         option = new(struct sd_dhcp_raw_option, 1);
 644         if (!option)
 645                 return -ENOMEM;
 646
 647         option->tag = tag;
 648         option->length = len;
 649         option->data = memdup(data, len);
 650         if (!option->data) {
 651                 free(option);
 652                 return -ENOMEM;
 653         }
 654
 655         LIST_INSERT_BEFORE(options, lease->private_options, cur, option);
 656
 657         return 0;
 658 }
 659
 660 int dhcp_lease_new(sd_dhcp_lease **ret) {
 661         sd_dhcp_lease *lease;
 662
 663         lease = new0(sd_dhcp_lease, 1);
 664         if (!lease)
 665                 return -ENOMEM;
 666
 667         lease->router = INADDR_ANY;
 668         lease->n_ref = REFCNT_INIT;
 669         LIST_HEAD_INIT(lease->private_options);
 670
 671         *ret = lease;
 672         return 0;
 673 }
 674
 675 int sd_dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file) {
 676         _cleanup_free_ char *temp_path = NULL;
 677         _cleanup_fclose_ FILE *f = NULL;
 678         struct sd_dhcp_raw_option *option;
 679         struct in_addr address;
 680         const struct in_addr *addresses;
 681         const uint8_t *client_id, *data;
 682         size_t client_id_len, data_len;
 683         const char *string;
 684         uint16_t mtu;
 685         struct sd_dhcp_route *routes;
 686         int r;
 687
 688         assert(lease);
 689         assert(lease_file);
 690
 691         r = fopen_temporary(lease_file, &f, &temp_path);
 692         if (r < 0)
 693                 goto fail;
 694
 695         fchmod(fileno(f), 0644);
 696
 697         r = sd_dhcp_lease_get_address(lease, &address);
 698         if (r < 0)
 699                 goto fail;
 700
 701         fprintf(f,
 702                 "# This is private data. Do not parse.\n"
 703                 "ADDRESS=%s\n", inet_ntoa(address));
 704
 705         r = sd_dhcp_lease_get_netmask(lease, &address);
 706         if (r < 0)
 707                 goto fail;
 708
 709         fprintf(f, "NETMASK=%s\n", inet_ntoa(address));
 710
 711         r = sd_dhcp_lease_get_router(lease, &address);
 712         if (r >= 0)
 713                 fprintf(f, "ROUTER=%s\n", inet_ntoa(address));
 714
 715         r = sd_dhcp_lease_get_server_identifier(lease, &address);
 716         if (r >= 0)
 717                 fprintf(f, "SERVER_ADDRESS=%s\n",
 718                         inet_ntoa(address));
 719
 720         r = sd_dhcp_lease_get_next_server(lease, &address);
 721         if (r >= 0)
 722                 fprintf(f, "NEXT_SERVER=%s\n", inet_ntoa(address));
 723
 724         r = sd_dhcp_lease_get_mtu(lease, &mtu);
 725         if (r >= 0)
 726                 fprintf(f, "MTU=%" PRIu16 "\n", mtu);
 727
 728         fputs("DNS=", f);
 729         r = sd_dhcp_lease_get_dns(lease, &addresses);
 730         if (r >= 0)
 731                 serialize_in_addrs(f, addresses, r);
 732         fputs("\n", f);
 733
 734         fputs("NTP=", f);
 735         r = sd_dhcp_lease_get_ntp(lease, &addresses);
 736         if (r >= 0)
 737                 serialize_in_addrs(f, addresses, r);
 738         fputs("\n", f);
 739
 740         r = sd_dhcp_lease_get_domainname(lease, &string);
 741         if (r >= 0)
 742                 fprintf(f, "DOMAINNAME=%s\n", string);
 743
 744         r = sd_dhcp_lease_get_hostname(lease, &string);
 745         if (r >= 0)
 746                 fprintf(f, "HOSTNAME=%s\n", string);
 747
 748         r = sd_dhcp_lease_get_root_path(lease, &string);
 749         if (r >= 0)
 750                 fprintf(f, "ROOT_PATH=%s\n", string);
 751
 752         r = sd_dhcp_lease_get_routes(lease, &routes);
 753         if (r >= 0)
 754                 serialize_dhcp_routes(f, "ROUTES", routes, r);
 755
 756         r = sd_dhcp_lease_get_client_id(lease, &client_id, &client_id_len);
 757         if (r >= 0) {
 758                 _cleanup_free_ char *client_id_hex;
 759
 760                 client_id_hex = hexmem(client_id, client_id_len);
 761                 if (!client_id_hex) {
 762                         r = -ENOMEM;
 763                         goto fail;
 764                 }
 765                 fprintf(f, "CLIENTID=%s\n", client_id_hex);
 766         }
 767
 768         r = sd_dhcp_lease_get_vendor_specific(lease, &data, &data_len);
 769         if (r >= 0) {
 770                 _cleanup_free_ char *option_hex = NULL;
 771
 772                 option_hex = hexmem(data, data_len);
 773                 if (!option_hex) {
 774                         r = -ENOMEM;
 775                         goto fail;
 776                 }
 777                 fprintf(f, "VENDOR_SPECIFIC=%s\n", option_hex);
 778         }
 779
 780         LIST_FOREACH(options, option, lease->private_options) {
 781                 char key[strlen("OPTION_000")+1];
 782                 snprintf(key, sizeof(key), "OPTION_%"PRIu8, option->tag);
 783                 r = serialize_dhcp_option(f, key, option->data, option->length);
 784                 if (r < 0)
 785                         goto fail;
 786         }
 787
 788         r = fflush_and_check(f);
 789         if (r < 0)
 790                 goto fail;
 791
 792         if (rename(temp_path, lease_file) < 0) {
 793                 r = -errno;
 794                 goto fail;
 795         }
 796
 797         return 0;
 798
 799 fail:
 800         if (temp_path)
 801                 (void) unlink(temp_path);
 802
 803         return log_error_errno(r, "Failed to save lease data %s: %m", lease_file);
 804 }
 805
 806 int sd_dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
 807         _cleanup_dhcp_lease_unref_ sd_dhcp_lease *lease = NULL;
 808         _cleanup_free_ char *address = NULL, *router = NULL, *netmask = NULL,
 809                             *server_address = NULL, *next_server = NULL,
 810                             *dns = NULL, *ntp = NULL, *mtu = NULL,
 811                             *routes = NULL, *client_id_hex = NULL,
 812                             *vendor_specific_hex = NULL,
 813                             *options[DHCP_OPTION_PRIVATE_LAST -
 814                                      DHCP_OPTION_PRIVATE_BASE + 1] = { NULL };
 815         struct in_addr addr;
 816         int r, i;
 817
 818         assert(lease_file);
 819         assert(ret);
 820
 821         r = dhcp_lease_new(&lease);
 822         if (r < 0)
 823                 return r;
 824
 825         r = parse_env_file(lease_file, NEWLINE,
 826                            "ADDRESS", &address,
 827                            "ROUTER", &router,
 828                            "NETMASK", &netmask,
 829                            "SERVER_IDENTIFIER", &server_address,
 830                            "NEXT_SERVER", &next_server,
 831                            "DNS", &dns,
 832                            "NTP", &ntp,
 833                            "MTU", &mtu,
 834                            "DOMAINNAME", &lease->domainname,
 835                            "HOSTNAME", &lease->hostname,
 836                            "ROOT_PATH", &lease->root_path,
 837                            "ROUTES", &routes,
 838                            "CLIENTID", &client_id_hex,
 839                            "VENDOR_SPECIFIC", &vendor_specific_hex,
 840                            "OPTION_224", &options[0],
 841                            "OPTION_225", &options[1],
 842                            "OPTION_226", &options[2],
 843                            "OPTION_227", &options[3],
 844                            "OPTION_228", &options[4],
 845                            "OPTION_229", &options[5],
 846                            "OPTION_230", &options[6],
 847                            "OPTION_231", &options[7],
 848                            "OPTION_232", &options[8],
 849                            "OPTION_233", &options[9],
 850                            "OPTION_234", &options[10],
 851                            "OPTION_235", &options[11],
 852                            "OPTION_236", &options[12],
 853                            "OPTION_237", &options[13],
 854                            "OPTION_238", &options[14],
 855                            "OPTION_239", &options[15],
 856                            "OPTION_240", &options[16],
 857                            "OPTION_241", &options[17],
 858                            "OPTION_242", &options[18],
 859                            "OPTION_243", &options[19],
 860                            "OPTION_244", &options[20],
 861                            "OPTION_245", &options[21],
 862                            "OPTION_246", &options[22],
 863                            "OPTION_247", &options[23],
 864                            "OPTION_248", &options[24],
 865                            "OPTION_249", &options[25],
 866                            "OPTION_250", &options[26],
 867                            "OPTION_251", &options[27],
 868                            "OPTION_252", &options[28],
 869                            "OPTION_253", &options[29],
 870                            "OPTION_254", &options[30],
 871                            NULL);
 872         if (r < 0) {
 873                 if (r == -ENOENT)
 874                         return 0;
 875
 876                 return log_error_errno(r, "Failed to read %s: %m", lease_file);
 877         }
 878
 879         r = inet_pton(AF_INET, address, &addr);
 880         if (r < 0)
 881                 return r;
 882
 883         lease->address = addr.s_addr;
 884
 885         if (router) {
 886                 r = inet_pton(AF_INET, router, &addr);
 887                 if (r < 0)
 888                         return r;
 889
 890                 lease->router = addr.s_addr;
 891         }
 892
 893         r = inet_pton(AF_INET, netmask, &addr);
 894         if (r < 0)
 895                 return r;
 896
 897         lease->subnet_mask = addr.s_addr;
 898
 899         if (server_address) {
 900                 r = inet_pton(AF_INET, server_address, &addr);
 901                 if (r < 0)
 902                         return r;
 903
 904                 lease->server_address = addr.s_addr;
 905         }
 906
 907         if (next_server) {
 908                 r = inet_pton(AF_INET, next_server, &addr);
 909                 if (r < 0)
 910                         return r;
 911
 912                 lease->next_server = addr.s_addr;
 913         }
 914
 915         if (dns) {
 916                 r = deserialize_in_addrs(&lease->dns, dns);
 917                 if (r < 0)
 918                         return r;
 919
 920                 lease->dns_size = r;
 921         }
 922
 923         if (ntp) {
 924                 r = deserialize_in_addrs(&lease->ntp, ntp);
 925                 if (r < 0)
 926                         return r;
 927
 928                 lease->ntp_size = r;
 929         }
 930
 931         if (mtu) {
 932                 uint16_t u;
 933                 if (sscanf(mtu, "%" SCNu16, &u) > 0)
 934                         lease->mtu = u;
 935         }
 936
 937         if (routes) {
 938                 r = deserialize_dhcp_routes(&lease->static_route, &lease->static_route_size,
 939                                 &lease->static_route_allocated, routes);
 940                 if (r < 0)
 941                     return r;
 942         }
 943
 944         if (client_id_hex) {
 945                 r = deserialize_dhcp_option(&lease->client_id, &lease->client_id_len, client_id_hex);
 946                 if (r < 0)
 947                         return r;
 948         }
 949
 950         if (vendor_specific_hex) {
 951                 r = deserialize_dhcp_option(&lease->vendor_specific, &lease->vendor_specific_len, vendor_specific_hex);
 952                 if (r < 0)
 953                         return r;
 954         }
 955
 956         for (i = 0; i <= DHCP_OPTION_PRIVATE_LAST - DHCP_OPTION_PRIVATE_BASE; i++) {
 957                 _cleanup_free_ uint8_t *data = NULL;
 958                 size_t len;
 959
 960                 if (!options[i])
 961                         continue;
 962
 963                 r = deserialize_dhcp_option(&data, &len, options[i]);
 964                 if (r < 0)
 965                         return r;
 966
 967                 r = dhcp_lease_insert_private_option(lease, DHCP_OPTION_PRIVATE_BASE + i, data, len);
 968                 if (r < 0)
 969                         return r;
 970         }
 971
 972         *ret = lease;
 973         lease = NULL;
 974
 975         return 0;
 976 }
 977
 978 int dhcp_lease_set_default_subnet_mask(sd_dhcp_lease *lease) {
 979         struct in_addr address;
 980         struct in_addr mask;
 981         int r;
 982
 983         assert(lease);
 984
 985         address.s_addr = lease->address;
 986
 987         /* fall back to the default subnet masks based on address class */
 988         r = in_addr_default_subnet_mask(&address, &mask);
 989         if (r < 0)
 990                 return r;
 991
 992         lease->subnet_mask = mask.s_addr;
 993
 994         return 0;
 995 }
 996
 997 int sd_dhcp_lease_get_client_id(sd_dhcp_lease *lease, const uint8_t **client_id,
 998                                 size_t *client_id_len) {
 999         assert_return(lease, -EINVAL);
1000         assert_return(client_id, -EINVAL);
1001         assert_return(client_id_len, -EINVAL);
1002
1003         *client_id = lease->client_id;
1004         *client_id_len = lease->client_id_len;
1005         return 0;
1006 }
1007
1008 int dhcp_lease_set_client_id(sd_dhcp_lease *lease, const uint8_t *client_id,
1009                              size_t client_id_len) {
1010         assert_return(lease, -EINVAL);
1011         assert_return((!client_id && !client_id_len) ||
1012                       (client_id && client_id_len), -EINVAL);
1013
1014         free (lease->client_id);
1015         lease->client_id = NULL;
1016         lease->client_id_len = 0;
1017
1018         if (client_id) {
1019                 lease->client_id = memdup (client_id, client_id_len);
1020                 lease->client_id_len = client_id_len;
1021         }
1022
1023         return 0;
1024 }