src/libsystemd-network/dhcp6-option.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2014-2015 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <errno.h>
   7 #include <netinet/in.h>
   8 #include <string.h>
   9
  10 #include "sd-dhcp6-client.h"
  11
  12 #include "alloc-util.h"
  13 #include "dhcp6-internal.h"
  14 #include "dhcp6-lease-internal.h"
  15 #include "dhcp6-protocol.h"
  16 #include "dns-domain.h"
  17 #include "sparse-endian.h"
  18 #include "strv.h"
  19 #include "unaligned.h"
  20 #include "util.h"
  21
  22 typedef struct DHCP6StatusOption {
  23         struct DHCP6Option option;
  24         be16_t status;
  25         char msg[];
  26 } _packed_ DHCP6StatusOption;
  27
  28 typedef struct DHCP6AddressOption {
  29         struct DHCP6Option option;
  30         struct iaaddr iaaddr;
  31         uint8_t options[];
  32 } _packed_ DHCP6AddressOption;
  33
  34 typedef struct DHCP6PDPrefixOption {
  35         struct DHCP6Option option;
  36         struct iapdprefix iapdprefix;
  37         uint8_t options[];
  38 } _packed_ DHCP6PDPrefixOption;
  39
  40 #define DHCP6_OPTION_IA_NA_LEN (sizeof(struct ia_na))
  41 #define DHCP6_OPTION_IA_PD_LEN (sizeof(struct ia_pd))
  42 #define DHCP6_OPTION_IA_TA_LEN (sizeof(struct ia_ta))
  43
  44 static int option_append_hdr(uint8_t **buf, size_t *buflen, uint16_t optcode,
  45                              size_t optlen) {
  46         DHCP6Option *option = (DHCP6Option*) *buf;
  47
  48         assert_return(buf, -EINVAL);
  49         assert_return(*buf, -EINVAL);
  50         assert_return(buflen, -EINVAL);
  51
  52         if (optlen > 0xffff || *buflen < optlen + offsetof(DHCP6Option, data))
  53                 return -ENOBUFS;
  54
  55         option->code = htobe16(optcode);
  56         option->len = htobe16(optlen);
  57
  58         *buf += offsetof(DHCP6Option, data);
  59         *buflen -= offsetof(DHCP6Option, data);
  60
  61         return 0;
  62 }
  63
  64 int dhcp6_option_append(uint8_t **buf, size_t *buflen, uint16_t code,
  65                         size_t optlen, const void *optval) {
  66         int r;
  67
  68         assert_return(optval || optlen == 0, -EINVAL);
  69
  70         r = option_append_hdr(buf, buflen, code, optlen);
  71         if (r < 0)
  72                 return r;
  73
  74         memcpy_safe(*buf, optval, optlen);
  75
  76         *buf += optlen;
  77         *buflen -= optlen;
  78
  79         return 0;
  80 }
  81
  82 int dhcp6_option_append_ia(uint8_t **buf, size_t *buflen, const DHCP6IA *ia) {
  83         uint16_t len;
  84         uint8_t *ia_hdr;
  85         size_t iaid_offset, ia_buflen, ia_addrlen = 0;
  86         DHCP6Address *addr;
  87         int r;
  88
  89         assert_return(buf, -EINVAL);
  90         assert_return(*buf, -EINVAL);
  91         assert_return(buflen, -EINVAL);
  92         assert_return(ia, -EINVAL);
  93
  94         switch (ia->type) {
  95         case SD_DHCP6_OPTION_IA_NA:
  96                 len = DHCP6_OPTION_IA_NA_LEN;
  97                 iaid_offset = offsetof(DHCP6IA, ia_na);
  98                 break;
  99
 100         case SD_DHCP6_OPTION_IA_TA:
 101                 len = DHCP6_OPTION_IA_TA_LEN;
 102                 iaid_offset = offsetof(DHCP6IA, ia_ta);
 103                 break;
 104
 105         default:
 106                 return -EINVAL;
 107         }
 108
 109         if (*buflen < offsetof(DHCP6Option, data) + len)
 110                 return -ENOBUFS;
 111
 112         ia_hdr = *buf;
 113         ia_buflen = *buflen;
 114
 115         *buf += offsetof(DHCP6Option, data);
 116         *buflen -= offsetof(DHCP6Option, data);
 117
 118         memcpy(*buf, (char*) ia + iaid_offset, len);
 119
 120         *buf += len;
 121         *buflen -= len;
 122
 123         LIST_FOREACH(addresses, addr, ia->addresses) {
 124                 r = option_append_hdr(buf, buflen, SD_DHCP6_OPTION_IAADDR,
 125                                       sizeof(addr->iaaddr));
 126                 if (r < 0)
 127                         return r;
 128
 129                 memcpy(*buf, &addr->iaaddr, sizeof(addr->iaaddr));
 130
 131                 *buf += sizeof(addr->iaaddr);
 132                 *buflen -= sizeof(addr->iaaddr);
 133
 134                 ia_addrlen += offsetof(DHCP6Option, data) + sizeof(addr->iaaddr);
 135         }
 136
 137         r = option_append_hdr(&ia_hdr, &ia_buflen, ia->type, len + ia_addrlen);
 138         if (r < 0)
 139                 return r;
 140
 141         return 0;
 142 }
 143
 144 int dhcp6_option_append_fqdn(uint8_t **buf, size_t *buflen, const char *fqdn) {
 145         uint8_t buffer[1 + DNS_WIRE_FORMAT_HOSTNAME_MAX];
 146         int r;
 147
 148         assert_return(buf && *buf && buflen && fqdn, -EINVAL);
 149
 150         buffer[0] = DHCP6_FQDN_FLAG_S; /* Request server to perform AAAA RR DNS updates */
 151
 152         /* Store domain name after flags field */
 153         r = dns_name_to_wire_format(fqdn, buffer + 1, sizeof(buffer) - 1,  false);
 154         if (r <= 0)
 155                 return r;
 156
 157         /*
 158          * According to RFC 4704, chapter 4.2 only add terminating zero-length
 159          * label in case a FQDN is provided. Since dns_name_to_wire_format
 160          * always adds terminating zero-length label remove if only a hostname
 161          * is provided.
 162          */
 163         if (dns_name_is_single_label(fqdn))
 164                 r--;
 165
 166         r = dhcp6_option_append(buf, buflen, SD_DHCP6_OPTION_FQDN, 1 + r, buffer);
 167
 168         return r;
 169 }
 170
 171 int dhcp6_option_append_pd(uint8_t *buf, size_t len, const DHCP6IA *pd) {
 172         DHCP6Option *option = (DHCP6Option *)buf;
 173         size_t i = sizeof(*option) + sizeof(pd->ia_pd);
 174         DHCP6Address *prefix;
 175
 176         assert_return(buf, -EINVAL);
 177         assert_return(pd, -EINVAL);
 178         assert_return(pd->type == SD_DHCP6_OPTION_IA_PD, -EINVAL);
 179
 180         if (len < i)
 181                 return -ENOBUFS;
 182
 183         option->code = htobe16(SD_DHCP6_OPTION_IA_PD);
 184
 185         memcpy(&option->data, &pd->ia_pd, sizeof(pd->ia_pd));
 186
 187         LIST_FOREACH(addresses, prefix, pd->addresses) {
 188                 DHCP6PDPrefixOption *prefix_opt;
 189
 190                 if (len < i + sizeof(*prefix_opt))
 191                         return -ENOBUFS;
 192
 193                 prefix_opt = (DHCP6PDPrefixOption *)&buf[i];
 194                 prefix_opt->option.code = htobe16(SD_DHCP6_OPTION_IA_PD_PREFIX);
 195                 prefix_opt->option.len = htobe16(sizeof(prefix_opt->iapdprefix));
 196
 197                 memcpy(&prefix_opt->iapdprefix, &prefix->iapdprefix,
 198                        sizeof(struct iapdprefix));
 199
 200                 i += sizeof(*prefix_opt);
 201         }
 202
 203         option->len = htobe16(i - sizeof(*option));
 204
 205         return i;
 206 }
 207
 208 static int option_parse_hdr(uint8_t **buf, size_t *buflen, uint16_t *optcode, size_t *optlen) {
 209         DHCP6Option *option = (DHCP6Option*) *buf;
 210         uint16_t len;
 211
 212         assert_return(buf, -EINVAL);
 213         assert_return(optcode, -EINVAL);
 214         assert_return(optlen, -EINVAL);
 215
 216         if (*buflen < offsetof(DHCP6Option, data))
 217                 return -ENOMSG;
 218
 219         len = be16toh(option->len);
 220
 221         if (len > *buflen)
 222                 return -ENOMSG;
 223
 224         *optcode = be16toh(option->code);
 225         *optlen = len;
 226
 227         *buf += 4;
 228         *buflen -= 4;
 229
 230         return 0;
 231 }
 232
 233 int dhcp6_option_parse(uint8_t **buf, size_t *buflen, uint16_t *optcode,
 234                        size_t *optlen, uint8_t **optvalue) {
 235         int r;
 236
 237         assert_return(buf && buflen && optcode && optlen && optvalue, -EINVAL);
 238
 239         r = option_parse_hdr(buf, buflen, optcode, optlen);
 240         if (r < 0)
 241                 return r;
 242
 243         if (*optlen > *buflen)
 244                 return -ENOBUFS;
 245
 246         *optvalue = *buf;
 247         *buflen -= *optlen;
 248         *buf += *optlen;
 249
 250         return 0;
 251 }
 252
 253 int dhcp6_option_parse_status(DHCP6Option *option, size_t len) {
 254         DHCP6StatusOption *statusopt = (DHCP6StatusOption *)option;
 255
 256         if (len < sizeof(DHCP6StatusOption) ||
 257             be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(DHCP6StatusOption))
 258                 return -ENOBUFS;
 259
 260         return be16toh(statusopt->status);
 261 }
 262
 263 static int dhcp6_option_parse_address(DHCP6Option *option, DHCP6IA *ia,
 264                                       uint32_t *lifetime_valid) {
 265         DHCP6AddressOption *addr_option = (DHCP6AddressOption *)option;
 266         DHCP6Address *addr;
 267         uint32_t lt_valid, lt_pref;
 268         int r;
 269
 270         if (be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(*addr_option))
 271                 return -ENOBUFS;
 272
 273         lt_valid = be32toh(addr_option->iaaddr.lifetime_valid);
 274         lt_pref = be32toh(addr_option->iaaddr.lifetime_preferred);
 275
 276         if (lt_valid == 0 || lt_pref > lt_valid) {
 277                 log_dhcp6_client(client, "Valid lifetime of an IA address is zero or preferred lifetime %d > valid lifetime %d",
 278                                  lt_pref, lt_valid);
 279
 280                 return 0;
 281         }
 282
 283         if (be16toh(option->len) + offsetof(DHCP6Option, data) > sizeof(*addr_option)) {
 284                 r = dhcp6_option_parse_status((DHCP6Option *)addr_option->options, be16toh(option->len) + offsetof(DHCP6Option, data) - sizeof(*addr_option));
 285                 if (r != 0)
 286                         return r < 0 ? r: 0;
 287         }
 288
 289         addr = new0(DHCP6Address, 1);
 290         if (!addr)
 291                 return -ENOMEM;
 292
 293         LIST_INIT(addresses, addr);
 294         memcpy(&addr->iaaddr, option->data, sizeof(addr->iaaddr));
 295
 296         LIST_PREPEND(addresses, ia->addresses, addr);
 297
 298         *lifetime_valid = be32toh(addr->iaaddr.lifetime_valid);
 299
 300         return 0;
 301 }
 302
 303 static int dhcp6_option_parse_pdprefix(DHCP6Option *option, DHCP6IA *ia,
 304                                        uint32_t *lifetime_valid) {
 305         DHCP6PDPrefixOption *pdprefix_option = (DHCP6PDPrefixOption *)option;
 306         DHCP6Address *prefix;
 307         uint32_t lt_valid, lt_pref;
 308         int r;
 309
 310         if (be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(*pdprefix_option))
 311                 return -ENOBUFS;
 312
 313         lt_valid = be32toh(pdprefix_option->iapdprefix.lifetime_valid);
 314         lt_pref = be32toh(pdprefix_option->iapdprefix.lifetime_preferred);
 315
 316         if (lt_valid == 0 || lt_pref > lt_valid) {
 317                 log_dhcp6_client(client, "Valid lifetieme of a PD prefix is zero or preferred lifetime %d > valid lifetime %d",
 318                                  lt_pref, lt_valid);
 319
 320                 return 0;
 321         }
 322
 323         if (be16toh(option->len) + offsetof(DHCP6Option, data) > sizeof(*pdprefix_option)) {
 324                 r = dhcp6_option_parse_status((DHCP6Option *)pdprefix_option->options, be16toh(option->len) + offsetof(DHCP6Option, data) - sizeof(*pdprefix_option));
 325                 if (r != 0)
 326                         return r < 0 ? r: 0;
 327         }
 328
 329         prefix = new0(DHCP6Address, 1);
 330         if (!prefix)
 331                 return -ENOMEM;
 332
 333         LIST_INIT(addresses, prefix);
 334         memcpy(&prefix->iapdprefix, option->data, sizeof(prefix->iapdprefix));
 335
 336         LIST_PREPEND(addresses, ia->addresses, prefix);
 337
 338         *lifetime_valid = be32toh(prefix->iapdprefix.lifetime_valid);
 339
 340         return 0;
 341 }
 342
 343 int dhcp6_option_parse_ia(DHCP6Option *iaoption, DHCP6IA *ia) {
 344         uint16_t iatype, optlen;
 345         size_t i, len;
 346         int r = 0, status;
 347         uint16_t opt;
 348         size_t iaaddr_offset;
 349         uint32_t lt_t1, lt_t2, lt_valid = 0, lt_min = UINT32_MAX;
 350
 351         assert_return(ia, -EINVAL);
 352         assert_return(!ia->addresses, -EINVAL);
 353
 354         iatype = be16toh(iaoption->code);
 355         len = be16toh(iaoption->len);
 356
 357         switch (iatype) {
 358         case SD_DHCP6_OPTION_IA_NA:
 359
 360                 if (len < DHCP6_OPTION_IA_NA_LEN)
 361                         return -ENOBUFS;
 362
 363                 iaaddr_offset = DHCP6_OPTION_IA_NA_LEN;
 364                 memcpy(&ia->ia_na, iaoption->data, sizeof(ia->ia_na));
 365
 366                 lt_t1 = be32toh(ia->ia_na.lifetime_t1);
 367                 lt_t2 = be32toh(ia->ia_na.lifetime_t2);
 368
 369                 if (lt_t1 && lt_t2 && lt_t1 > lt_t2) {
 370                         log_dhcp6_client(client, "IA NA T1 %ds > T2 %ds",
 371                                          lt_t1, lt_t2);
 372                         return -EINVAL;
 373                 }
 374
 375                 break;
 376
 377         case SD_DHCP6_OPTION_IA_PD:
 378
 379                 if (len < sizeof(ia->ia_pd))
 380                         return -ENOBUFS;
 381
 382                 iaaddr_offset = sizeof(ia->ia_pd);
 383                 memcpy(&ia->ia_pd, iaoption->data, sizeof(ia->ia_pd));
 384
 385                 lt_t1 = be32toh(ia->ia_pd.lifetime_t1);
 386                 lt_t2 = be32toh(ia->ia_pd.lifetime_t2);
 387
 388                 if (lt_t1 && lt_t2 && lt_t1 > lt_t2) {
 389                         log_dhcp6_client(client, "IA PD T1 %ds > T2 %ds",
 390                                          lt_t1, lt_t2);
 391                         return -EINVAL;
 392                 }
 393
 394                 break;
 395
 396         case SD_DHCP6_OPTION_IA_TA:
 397                 if (len < DHCP6_OPTION_IA_TA_LEN)
 398                         return -ENOBUFS;
 399
 400                 iaaddr_offset = DHCP6_OPTION_IA_TA_LEN;
 401                 memcpy(&ia->ia_ta.id, iaoption->data, sizeof(ia->ia_ta));
 402
 403                 break;
 404
 405         default:
 406                 return -ENOMSG;
 407         }
 408
 409         ia->type = iatype;
 410         i = iaaddr_offset;
 411
 412         while (i < len) {
 413                 DHCP6Option *option = (DHCP6Option *)&iaoption->data[i];
 414
 415                 if (len < i + sizeof(*option) || len < i + sizeof(*option) + be16toh(option->len))
 416                         return -ENOBUFS;
 417
 418                 opt = be16toh(option->code);
 419                 optlen = be16toh(option->len);
 420
 421                 switch (opt) {
 422                 case SD_DHCP6_OPTION_IAADDR:
 423
 424                         if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_NA, SD_DHCP6_OPTION_IA_TA)) {
 425                                 log_dhcp6_client(client, "IA Address option not in IA NA or TA option");
 426                                 return -EINVAL;
 427                         }
 428
 429                         r = dhcp6_option_parse_address(option, ia, &lt_valid);
 430                         if (r < 0)
 431                                 return r;
 432
 433                         if (lt_valid < lt_min)
 434                                 lt_min = lt_valid;
 435
 436                         break;
 437
 438                 case SD_DHCP6_OPTION_IA_PD_PREFIX:
 439
 440                         if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_PD)) {
 441                                 log_dhcp6_client(client, "IA PD Prefix option not in IA PD option");
 442                                 return -EINVAL;
 443                         }
 444
 445                         r = dhcp6_option_parse_pdprefix(option, ia, &lt_valid);
 446                         if (r < 0)
 447                                 return r;
 448
 449                         if (lt_valid < lt_min)
 450                                 lt_min = lt_valid;
 451
 452                         break;
 453
 454                 case SD_DHCP6_OPTION_STATUS_CODE:
 455
 456                         status = dhcp6_option_parse_status(option, optlen + offsetof(DHCP6Option, data));
 457                         if (status < 0)
 458                                 return status;
 459                         if (status > 0) {
 460                                 log_dhcp6_client(client, "IA status %d",
 461                                                  status);
 462
 463                                 return -EINVAL;
 464                         }
 465
 466                         break;
 467
 468                 default:
 469                         log_dhcp6_client(client, "Unknown IA option %d", opt);
 470                         break;
 471                 }
 472
 473                 i += sizeof(*option) + optlen;
 474         }
 475
 476         switch(iatype) {
 477         case SD_DHCP6_OPTION_IA_NA:
 478                 if (!ia->ia_na.lifetime_t1 && !ia->ia_na.lifetime_t2) {
 479                         lt_t1 = lt_min / 2;
 480                         lt_t2 = lt_min / 10 * 8;
 481                         ia->ia_na.lifetime_t1 = htobe32(lt_t1);
 482                         ia->ia_na.lifetime_t2 = htobe32(lt_t2);
 483
 484                         log_dhcp6_client(client, "Computed IA NA T1 %ds and T2 %ds as both were zero",
 485                                          lt_t1, lt_t2);
 486                 }
 487
 488                 break;
 489
 490         case SD_DHCP6_OPTION_IA_PD:
 491                 if (!ia->ia_pd.lifetime_t1 && !ia->ia_pd.lifetime_t2) {
 492                         lt_t1 = lt_min / 2;
 493                         lt_t2 = lt_min / 10 * 8;
 494                         ia->ia_pd.lifetime_t1 = htobe32(lt_t1);
 495                         ia->ia_pd.lifetime_t2 = htobe32(lt_t2);
 496
 497                         log_dhcp6_client(client, "Computed IA PD T1 %ds and T2 %ds as both were zero",
 498                                          lt_t1, lt_t2);
 499                 }
 500
 501                 break;
 502
 503         default:
 504                 break;
 505         }
 506
 507         return 0;
 508 }
 509
 510 int dhcp6_option_parse_ip6addrs(uint8_t *optval, uint16_t optlen,
 511                                 struct in6_addr **addrs, size_t count,
 512                                 size_t *allocated) {
 513
 514         if (optlen == 0 || optlen % sizeof(struct in6_addr) != 0)
 515                 return -EINVAL;
 516
 517         if (!GREEDY_REALLOC(*addrs, *allocated,
 518                             count * sizeof(struct in6_addr) + optlen))
 519                 return -ENOMEM;
 520
 521         memcpy(*addrs + count, optval, optlen);
 522
 523         count += optlen / sizeof(struct in6_addr);
 524
 525         return count;
 526 }
 527
 528 int dhcp6_option_parse_domainname(const uint8_t *optval, uint16_t optlen, char ***str_arr) {
 529         size_t pos = 0, idx = 0;
 530         _cleanup_strv_free_ char **names = NULL;
 531         int r;
 532
 533         assert_return(optlen > 1, -ENODATA);
 534         assert_return(optval[optlen - 1] == '\0', -EINVAL);
 535
 536         while (pos < optlen) {
 537                 _cleanup_free_ char *ret = NULL;
 538                 size_t n = 0, allocated = 0;
 539                 bool first = true;
 540
 541                 for (;;) {
 542                         const char *label;
 543                         uint8_t c;
 544
 545                         c = optval[pos++];
 546
 547                         if (c == 0)
 548                                 /* End of name */
 549                                 break;
 550                         if (c > 63)
 551                                 return -EBADMSG;
 552
 553                         /* Literal label */
 554                         label = (const char *)&optval[pos];
 555                         pos += c;
 556                         if (pos >= optlen)
 557                                 return -EMSGSIZE;
 558
 559                         if (!GREEDY_REALLOC(ret, allocated, n + !first + DNS_LABEL_ESCAPED_MAX))
 560                                 return -ENOMEM;
 561
 562                         if (first)
 563                                 first = false;
 564                         else
 565                                 ret[n++] = '.';
 566
 567                         r = dns_label_escape(label, c, ret + n, DNS_LABEL_ESCAPED_MAX);
 568                         if (r < 0)
 569                                 return r;
 570
 571                         n += r;
 572                 }
 573
 574                 if (n == 0)
 575                         continue;
 576
 577                 if (!GREEDY_REALLOC(ret, allocated, n + 1))
 578                         return -ENOMEM;
 579
 580                 ret[n] = 0;
 581
 582                 r = strv_extend(&names, ret);
 583                 if (r < 0)
 584                         return r;
 585
 586                 idx++;
 587         }
 588
 589         *str_arr = TAKE_PTR(names);
 590
 591         return idx;
 592 }