src/libsystemd-network/dhcp6-option.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2014-2015 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include <netinet/in.h>
   7
   8 #include "sd-dhcp6-client.h"
   9 #include "sd-dhcp6-option.h"
  10
  11 #include "alloc-util.h"
  12 #include "dhcp6-internal.h"
  13 #include "dhcp6-option.h"
  14 #include "dhcp6-protocol.h"
  15 #include "dns-def.h"
  16 #include "dns-domain.h"
  17 #include "escape.h"
  18 #include "memory-util.h"
  19 #include "network-common.h"
  20 #include "ordered-set.h"
  21 #include "string-util.h"
  22 #include "strv.h"
  23 #include "unaligned.h"
  24
  25 #define DHCP6_OPTION_IA_NA_LEN (sizeof(struct ia_na))
  26 #define DHCP6_OPTION_IA_PD_LEN (sizeof(struct ia_pd))
  27 #define DHCP6_OPTION_IA_TA_LEN (sizeof(struct ia_ta))
  28
  29 bool dhcp6_option_can_request(uint16_t option) {
  30         /* See Client ORO field in
  31          * https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml#dhcpv6-parameters-2 */
  32
  33         switch (option) {
  34         case SD_DHCP6_OPTION_CLIENTID:
  35         case SD_DHCP6_OPTION_SERVERID:
  36         case SD_DHCP6_OPTION_IA_NA:
  37         case SD_DHCP6_OPTION_IA_TA:
  38         case SD_DHCP6_OPTION_IAADDR:
  39         case SD_DHCP6_OPTION_ORO:
  40         case SD_DHCP6_OPTION_PREFERENCE:
  41         case SD_DHCP6_OPTION_ELAPSED_TIME:
  42         case SD_DHCP6_OPTION_RELAY_MSG:
  43         case SD_DHCP6_OPTION_AUTH:
  44         case SD_DHCP6_OPTION_UNICAST:
  45         case SD_DHCP6_OPTION_STATUS_CODE:
  46         case SD_DHCP6_OPTION_RAPID_COMMIT:
  47         case SD_DHCP6_OPTION_USER_CLASS:
  48         case SD_DHCP6_OPTION_VENDOR_CLASS:
  49                 return false;
  50         case SD_DHCP6_OPTION_VENDOR_OPTS:
  51                 return true;
  52         case SD_DHCP6_OPTION_INTERFACE_ID:
  53         case SD_DHCP6_OPTION_RECONF_MSG:
  54         case SD_DHCP6_OPTION_RECONF_ACCEPT:
  55                 return false;
  56         case SD_DHCP6_OPTION_SIP_SERVER_DOMAIN_NAME:
  57         case SD_DHCP6_OPTION_SIP_SERVER_ADDRESS:
  58         case SD_DHCP6_OPTION_DNS_SERVER:
  59         case SD_DHCP6_OPTION_DOMAIN:
  60                 return true;
  61         case SD_DHCP6_OPTION_IA_PD:
  62         case SD_DHCP6_OPTION_IA_PD_PREFIX:
  63                 return false;
  64         case SD_DHCP6_OPTION_NIS_SERVER:
  65         case SD_DHCP6_OPTION_NISP_SERVER:
  66         case SD_DHCP6_OPTION_NIS_DOMAIN_NAME:
  67         case SD_DHCP6_OPTION_NISP_DOMAIN_NAME:
  68         case SD_DHCP6_OPTION_SNTP_SERVER:
  69                 return true;
  70         case SD_DHCP6_OPTION_INFORMATION_REFRESH_TIME:
  71                 return false; /* This is automatically set when sending INFORMATION_REQUEST message. */
  72         case SD_DHCP6_OPTION_BCMCS_SERVER_D:
  73         case SD_DHCP6_OPTION_BCMCS_SERVER_A:
  74         case SD_DHCP6_OPTION_GEOCONF_CIVIC:
  75                 return true;
  76         case SD_DHCP6_OPTION_REMOTE_ID:
  77         case SD_DHCP6_OPTION_SUBSCRIBER_ID:
  78                 return false;
  79         case SD_DHCP6_OPTION_CLIENT_FQDN:
  80         case SD_DHCP6_OPTION_PANA_AGENT:
  81         case SD_DHCP6_OPTION_POSIX_TIMEZONE:
  82         case SD_DHCP6_OPTION_TZDB_TIMEZONE:
  83                 return true;
  84         case SD_DHCP6_OPTION_ERO:
  85         case SD_DHCP6_OPTION_LQ_QUERY:
  86         case SD_DHCP6_OPTION_CLIENT_DATA:
  87         case SD_DHCP6_OPTION_CLT_TIME:
  88         case SD_DHCP6_OPTION_LQ_RELAY_DATA:
  89         case SD_DHCP6_OPTION_LQ_CLIENT_LINK:
  90                 return false;
  91         case SD_DHCP6_OPTION_MIP6_HNIDF:
  92         case SD_DHCP6_OPTION_MIP6_VDINF:
  93         case SD_DHCP6_OPTION_V6_LOST:
  94         case SD_DHCP6_OPTION_CAPWAP_AC_V6:
  95                 return true;
  96         case SD_DHCP6_OPTION_RELAY_ID:
  97                 return false;
  98         case SD_DHCP6_OPTION_IPV6_ADDRESS_MOS:
  99         case SD_DHCP6_OPTION_IPV6_FQDN_MOS:
 100         case SD_DHCP6_OPTION_NTP_SERVER:
 101         case SD_DHCP6_OPTION_V6_ACCESS_DOMAIN:
 102         case SD_DHCP6_OPTION_SIP_UA_CS_LIST:
 103         case SD_DHCP6_OPTION_BOOTFILE_URL:
 104         case SD_DHCP6_OPTION_BOOTFILE_PARAM:
 105                 return true;
 106         case SD_DHCP6_OPTION_CLIENT_ARCH_TYPE:
 107                 return false;
 108         case SD_DHCP6_OPTION_NII:
 109         case SD_DHCP6_OPTION_GEOLOCATION:
 110         case SD_DHCP6_OPTION_AFTR_NAME:
 111         case SD_DHCP6_OPTION_ERP_LOCAL_DOMAIN_NAME:
 112                 return true;
 113         case SD_DHCP6_OPTION_RSOO:
 114                 return false;
 115         case SD_DHCP6_OPTION_PD_EXCLUDE:
 116                 return true;
 117         case SD_DHCP6_OPTION_VSS:
 118                 return false;
 119         case SD_DHCP6_OPTION_MIP6_IDINF:
 120         case SD_DHCP6_OPTION_MIP6_UDINF:
 121         case SD_DHCP6_OPTION_MIP6_HNP:
 122         case SD_DHCP6_OPTION_MIP6_HAA:
 123         case SD_DHCP6_OPTION_MIP6_HAF:
 124         case SD_DHCP6_OPTION_RDNSS_SELECTION:
 125         case SD_DHCP6_OPTION_KRB_PRINCIPAL_NAME:
 126         case SD_DHCP6_OPTION_KRB_REALM_NAME:
 127         case SD_DHCP6_OPTION_KRB_DEFAULT_REALM_NAME:
 128         case SD_DHCP6_OPTION_KRB_KDC:
 129                 return true;
 130         case SD_DHCP6_OPTION_CLIENT_LINKLAYER_ADDR:
 131         case SD_DHCP6_OPTION_LINK_ADDRESS:
 132         case SD_DHCP6_OPTION_RADIUS:
 133         case SD_DHCP6_OPTION_SOL_MAX_RT: /* Automatically set when sending SOLICIT message. */
 134         case SD_DHCP6_OPTION_INF_MAX_RT: /* Automatically set when sending INFORMATION_REQUEST message. */
 135                 return false;
 136         case SD_DHCP6_OPTION_ADDRSEL:
 137         case SD_DHCP6_OPTION_ADDRSEL_TABLE:
 138         case SD_DHCP6_OPTION_V6_PCP_SERVER:
 139                 return true;
 140         case SD_DHCP6_OPTION_DHCPV4_MSG:
 141                 return false;
 142         case SD_DHCP6_OPTION_DHCP4_O_DHCP6_SERVER:
 143                 return true;
 144         case SD_DHCP6_OPTION_S46_RULE:
 145                 return false;
 146         case SD_DHCP6_OPTION_S46_BR:
 147                 return true;
 148         case SD_DHCP6_OPTION_S46_DMR:
 149         case SD_DHCP6_OPTION_S46_V4V6BIND:
 150         case SD_DHCP6_OPTION_S46_PORTPARAMS:
 151                 return false;
 152         case SD_DHCP6_OPTION_S46_CONT_MAPE:
 153         case SD_DHCP6_OPTION_S46_CONT_MAPT:
 154         case SD_DHCP6_OPTION_S46_CONT_LW:
 155         case SD_DHCP6_OPTION_4RD:
 156         case SD_DHCP6_OPTION_4RD_MAP_RULE:
 157         case SD_DHCP6_OPTION_4RD_NON_MAP_RULE:
 158                 return true;
 159         case SD_DHCP6_OPTION_LQ_BASE_TIME:
 160         case SD_DHCP6_OPTION_LQ_START_TIME:
 161         case SD_DHCP6_OPTION_LQ_END_TIME:
 162                 return false;
 163         case SD_DHCP6_OPTION_CAPTIVE_PORTAL:
 164         case SD_DHCP6_OPTION_MPL_PARAMETERS:
 165                 return true;
 166         case SD_DHCP6_OPTION_ANI_ATT:
 167         case SD_DHCP6_OPTION_ANI_NETWORK_NAME:
 168         case SD_DHCP6_OPTION_ANI_AP_NAME:
 169         case SD_DHCP6_OPTION_ANI_AP_BSSID:
 170         case SD_DHCP6_OPTION_ANI_OPERATOR_ID:
 171         case SD_DHCP6_OPTION_ANI_OPERATOR_REALM:
 172                 return false;
 173         case SD_DHCP6_OPTION_S46_PRIORITY:
 174                 return true;
 175         case SD_DHCP6_OPTION_MUD_URL_V6:
 176                 return false;
 177         case SD_DHCP6_OPTION_V6_PREFIX64:
 178                 return true;
 179         case SD_DHCP6_OPTION_F_BINDING_STATUS:
 180         case SD_DHCP6_OPTION_F_CONNECT_FLAGS:
 181         case SD_DHCP6_OPTION_F_DNS_REMOVAL_INFO:
 182         case SD_DHCP6_OPTION_F_DNS_HOST_NAME:
 183         case SD_DHCP6_OPTION_F_DNS_ZONE_NAME:
 184         case SD_DHCP6_OPTION_F_DNS_FLAGS:
 185         case SD_DHCP6_OPTION_F_EXPIRATION_TIME:
 186         case SD_DHCP6_OPTION_F_MAX_UNACKED_BNDUPD:
 187         case SD_DHCP6_OPTION_F_MCLT:
 188         case SD_DHCP6_OPTION_F_PARTNER_LIFETIME:
 189         case SD_DHCP6_OPTION_F_PARTNER_LIFETIME_SENT:
 190         case SD_DHCP6_OPTION_F_PARTNER_DOWN_TIME:
 191         case SD_DHCP6_OPTION_F_PARTNER_RAW_CLT_TIME:
 192         case SD_DHCP6_OPTION_F_PROTOCOL_VERSION:
 193         case SD_DHCP6_OPTION_F_KEEPALIVE_TIME:
 194         case SD_DHCP6_OPTION_F_RECONFIGURE_DATA:
 195         case SD_DHCP6_OPTION_F_RELATIONSHIP_NAME:
 196         case SD_DHCP6_OPTION_F_SERVER_FLAGS:
 197         case SD_DHCP6_OPTION_F_SERVER_STATE:
 198         case SD_DHCP6_OPTION_F_START_TIME_OF_STATE:
 199         case SD_DHCP6_OPTION_F_STATE_EXPIRATION_TIME:
 200         case SD_DHCP6_OPTION_RELAY_PORT:
 201                 return false;
 202         case SD_DHCP6_OPTION_V6_SZTP_REDIRECT:
 203         case SD_DHCP6_OPTION_S46_BIND_IPV6_PREFIX:
 204                 return true;
 205         case SD_DHCP6_OPTION_IA_LL:
 206         case SD_DHCP6_OPTION_LLADDR:
 207         case SD_DHCP6_OPTION_SLAP_QUAD:
 208                 return false;
 209         case SD_DHCP6_OPTION_V6_DOTS_RI:
 210         case SD_DHCP6_OPTION_V6_DOTS_ADDRESS:
 211         case SD_DHCP6_OPTION_IPV6_ADDRESS_ANDSF:
 212         case SD_DHCP6_OPTION_V6_DNR:
 213         case SD_DHCP6_OPTION_REGISTERED_DOMAIN:
 214         case SD_DHCP6_OPTION_FORWARD_DIST_MANAGER:
 215         case SD_DHCP6_OPTION_REVERSE_DIST_MANAGER:
 216         case SD_DHCP6_OPTION_ADDR_REG_ENABLE:
 217                 return true;
 218         default:
 219                 return false;
 220         }
 221 }
 222
 223 static int option_append_hdr(uint8_t **buf, size_t *offset, uint16_t optcode, size_t optlen) {
 224         assert(buf);
 225         assert(*buf);
 226         assert(offset);
 227
 228         if (optlen > 0xffff)
 229                 return -ENOBUFS;
 230
 231         if (optlen + offsetof(DHCP6Option, data) > SIZE_MAX - *offset)
 232                 return -ENOBUFS;
 233
 234         if (!GREEDY_REALLOC(*buf, *offset + optlen + offsetof(DHCP6Option, data)))
 235                 return -ENOMEM;
 236
 237         unaligned_write_be16(*buf + *offset + offsetof(DHCP6Option, code), optcode);
 238         unaligned_write_be16(*buf + *offset + offsetof(DHCP6Option, len), optlen);
 239
 240         *offset += offsetof(DHCP6Option, data);
 241         return 0;
 242 }
 243
 244 int dhcp6_option_append(
 245                 uint8_t **buf,
 246                 size_t *offset,
 247                 uint16_t code,
 248                 size_t optlen,
 249                 const void *optval) {
 250
 251         int r;
 252
 253         assert(optval || optlen == 0);
 254
 255         r = option_append_hdr(buf, offset, code, optlen);
 256         if (r < 0)
 257                 return r;
 258
 259         memcpy_safe(*buf + *offset, optval, optlen);
 260         *offset += optlen;
 261
 262         return 0;
 263 }
 264
 265 int dhcp6_option_append_vendor_option(uint8_t **buf, size_t *offset, OrderedSet *vendor_options) {
 266         sd_dhcp6_option *options;
 267         int r;
 268
 269         assert(buf);
 270         assert(*buf);
 271         assert(offset);
 272
 273         ORDERED_SET_FOREACH(options, vendor_options) {
 274                 _cleanup_free_ uint8_t *p = NULL;
 275                 size_t total;
 276
 277                 total = 4 + 2 + 2 + options->length;
 278
 279                 p = malloc(total);
 280                 if (!p)
 281                         return -ENOMEM;
 282
 283                 unaligned_write_be32(p, options->enterprise_identifier);
 284                 unaligned_write_be16(p + 4, options->option);
 285                 unaligned_write_be16(p + 6, options->length);
 286                 memcpy(p + 8, options->data, options->length);
 287
 288                 r = dhcp6_option_append(buf, offset, SD_DHCP6_OPTION_VENDOR_OPTS, total, p);
 289                 if (r < 0)
 290                         return r;
 291         }
 292
 293         return 0;
 294 }
 295
 296 static int option_append_ia_address(uint8_t **buf, size_t *offset, const struct iaaddr *address) {
 297         assert(buf);
 298         assert(*buf);
 299         assert(offset);
 300         assert(address);
 301
 302         /* Do not append T1 and T2. */
 303         const struct iaaddr a = {
 304                 .address = address->address,
 305         };
 306
 307         return dhcp6_option_append(buf, offset, SD_DHCP6_OPTION_IAADDR, sizeof(struct iaaddr), &a);
 308 }
 309
 310 static int option_append_pd_prefix(uint8_t **buf, size_t *offset, const struct iapdprefix *prefix) {
 311         assert(buf);
 312         assert(*buf);
 313         assert(offset);
 314         assert(prefix);
 315
 316         if (prefix->prefixlen == 0)
 317                 return -EINVAL;
 318
 319         /* Do not append T1 and T2. */
 320         const struct iapdprefix p = {
 321                 .prefixlen = prefix->prefixlen,
 322                 .address = prefix->address,
 323         };
 324
 325         return dhcp6_option_append(buf, offset, SD_DHCP6_OPTION_IA_PD_PREFIX, sizeof(struct iapdprefix), &p);
 326 }
 327
 328 int dhcp6_option_append_ia(uint8_t **buf, size_t *offset, const DHCP6IA *ia) {
 329         _cleanup_free_ uint8_t *data = NULL;
 330         struct ia_header header;
 331         size_t len;
 332         int r;
 333
 334         assert(buf);
 335         assert(*buf);
 336         assert(offset);
 337         assert(ia);
 338
 339         /* client should not send set T1 and T2. See, RFC 8415, and issue #18090. */
 340
 341         switch (ia->type) {
 342         case SD_DHCP6_OPTION_IA_NA:
 343         case SD_DHCP6_OPTION_IA_PD:
 344                 len = sizeof(struct ia_header);
 345                 header = (struct ia_header) {
 346                         .id = ia->header.id,
 347                 };
 348                 break;
 349
 350         case SD_DHCP6_OPTION_IA_TA:
 351                 len = sizeof(header.id); /* IA_TA does not have lifetime. */
 352                 header = (struct ia_header) {
 353                         .id = ia->header.id,
 354                 };
 355                 break;
 356
 357         default:
 358                 assert_not_reached();
 359         }
 360
 361         if (!GREEDY_REALLOC(data, len))
 362                 return -ENOMEM;
 363
 364         memcpy(data, &header, len);
 365
 366         LIST_FOREACH(addresses, addr, ia->addresses) {
 367                 if (ia->type == SD_DHCP6_OPTION_IA_PD)
 368                         r = option_append_pd_prefix(&data, &len, &addr->iapdprefix);
 369                 else
 370                         r = option_append_ia_address(&data, &len, &addr->iaaddr);
 371                 if (r < 0)
 372                         return r;
 373         }
 374
 375         return dhcp6_option_append(buf, offset, ia->type, len, data);
 376 }
 377
 378 int dhcp6_option_append_fqdn(uint8_t **buf, size_t *offset, const char *fqdn) {
 379         uint8_t buffer[1 + DNS_WIRE_FORMAT_HOSTNAME_MAX];
 380         int r;
 381
 382         assert(buf);
 383         assert(*buf);
 384         assert(offset);
 385
 386         if (isempty(fqdn))
 387                 return 0;
 388
 389         buffer[0] = DHCP6_FQDN_FLAG_S; /* Request server to perform AAAA RR DNS updates */
 390
 391         /* Store domain name after flags field */
 392         r = dns_name_to_wire_format(fqdn, buffer + 1, sizeof(buffer) - 1, false);
 393         if (r <= 0)
 394                 return r;
 395
 396         /*
 397          * According to RFC 4704, chapter 4.2 only add terminating zero-length
 398          * label in case a FQDN is provided. Since dns_name_to_wire_format
 399          * always adds terminating zero-length label remove if only a hostname
 400          * is provided.
 401          */
 402         if (dns_name_is_single_label(fqdn))
 403                 r--;
 404
 405         return dhcp6_option_append(buf, offset, SD_DHCP6_OPTION_CLIENT_FQDN, 1 + r, buffer);
 406 }
 407
 408 int dhcp6_option_append_user_class(uint8_t **buf, size_t *offset, char * const *user_class) {
 409         _cleanup_free_ uint8_t *p = NULL;
 410         size_t n = 0;
 411
 412         assert(buf);
 413         assert(*buf);
 414         assert(offset);
 415
 416         if (strv_isempty(user_class))
 417                 return 0;
 418
 419         STRV_FOREACH(s, user_class) {
 420                 size_t len = strlen(*s);
 421
 422                 if (len > UINT16_MAX || len == 0)
 423                         return -EINVAL;
 424
 425                 if (!GREEDY_REALLOC(p, n + len + 2))
 426                         return -ENOMEM;
 427
 428                 unaligned_write_be16(p + n, len);
 429                 memcpy(p + n + 2, *s, len);
 430                 n += len + 2;
 431         }
 432
 433         return dhcp6_option_append(buf, offset, SD_DHCP6_OPTION_USER_CLASS, n, p);
 434 }
 435
 436 int dhcp6_option_append_vendor_class(uint8_t **buf, size_t *offset, char * const *vendor_class) {
 437         _cleanup_free_ uint8_t *p = NULL;
 438         size_t n = 0;
 439
 440         assert(buf);
 441         assert(*buf);
 442         assert(offset);
 443
 444         if (strv_isempty(vendor_class))
 445                 return 0;
 446
 447         if (!GREEDY_REALLOC(p, sizeof(be32_t)))
 448                 return -ENOMEM;
 449
 450         /* Enterprise Identifier */
 451         unaligned_write_be32(p, SYSTEMD_PEN);
 452         n += sizeof(be32_t);
 453
 454         STRV_FOREACH(s, vendor_class) {
 455                 size_t len = strlen(*s);
 456
 457                 if (len > UINT16_MAX || len == 0)
 458                         return -EINVAL;
 459
 460                 if (!GREEDY_REALLOC(p, n + len + 2))
 461                         return -ENOMEM;
 462
 463                 unaligned_write_be16(p + n, len);
 464                 memcpy(p + n + 2, *s, len);
 465                 n += len + 2;
 466         }
 467
 468         return dhcp6_option_append(buf, offset, SD_DHCP6_OPTION_VENDOR_CLASS, n, p);
 469 }
 470
 471 int dhcp6_option_parse(
 472                 const uint8_t *buf,
 473                 size_t buflen,
 474                 size_t *offset,
 475                 uint16_t *ret_option_code,
 476                 size_t *ret_option_data_len,
 477                 const uint8_t **ret_option_data) {
 478
 479         size_t len;
 480
 481         assert(buf);
 482         assert(offset);
 483         assert(ret_option_code);
 484         assert(ret_option_data_len);
 485         assert(ret_option_data);
 486
 487         if (buflen < offsetof(DHCP6Option, data))
 488                 return -EBADMSG;
 489
 490         if (*offset > buflen - offsetof(DHCP6Option, data))
 491                 return -EBADMSG;
 492
 493         len = unaligned_read_be16(buf + *offset + offsetof(DHCP6Option, len));
 494
 495         if (len > buflen - offsetof(DHCP6Option, data) - *offset)
 496                 return -EBADMSG;
 497
 498         *ret_option_code = unaligned_read_be16(buf + *offset + offsetof(DHCP6Option, code));
 499         *ret_option_data_len = len;
 500         *ret_option_data = len == 0 ? NULL : buf + *offset + offsetof(DHCP6Option, data);
 501         *offset += offsetof(DHCP6Option, data) + len;
 502
 503         return 0;
 504 }
 505
 506 int dhcp6_option_parse_status(const uint8_t *data, size_t data_len, char **ret_status_message) {
 507         DHCP6Status status;
 508
 509         assert(data || data_len == 0);
 510
 511         if (data_len < sizeof(uint16_t))
 512                 return -EBADMSG;
 513
 514         status = unaligned_read_be16(data);
 515
 516         if (ret_status_message) {
 517                 _cleanup_free_ char *msg = NULL;
 518                 const char *s;
 519
 520                 /* The status message MUST NOT be null-terminated. See section 21.13 of RFC8415.
 521                  * Let's escape unsafe characters for safety. */
 522                 msg = cescape_length((const char*) (data + sizeof(uint16_t)), data_len - sizeof(uint16_t));
 523                 if (!msg)
 524                         return -ENOMEM;
 525
 526                 s = dhcp6_message_status_to_string(status);
 527                 if (s && !strextend_with_separator(&msg, ": ", s))
 528                         return -ENOMEM;
 529
 530                 *ret_status_message = TAKE_PTR(msg);
 531         }
 532
 533         return status;
 534 }
 535
 536 /* parse a string from dhcp option field. *ret must be initialized */
 537 int dhcp6_option_parse_string(const uint8_t *data, size_t data_len, char **ret) {
 538         _cleanup_free_ char *string = NULL;
 539         int r;
 540
 541         assert(data || data_len == 0);
 542         assert(ret);
 543
 544         if (data_len <= 0) {
 545                 *ret = mfree(*ret);
 546                 return 0;
 547         }
 548
 549         r = make_cstring((const char *) data, data_len, MAKE_CSTRING_REFUSE_TRAILING_NUL, &string);
 550         if (r < 0)
 551                 return r;
 552
 553         return free_and_replace(*ret, string);
 554 }
 555
 556 static int dhcp6_option_parse_ia_options(sd_dhcp6_client *client, const uint8_t *buf, size_t buflen) {
 557         int r;
 558
 559         assert(buf || buflen == 0);
 560
 561         for (size_t offset = 0; offset < buflen;) {
 562                 const uint8_t *data;
 563                 size_t data_len;
 564                 uint16_t code;
 565
 566                 r = dhcp6_option_parse(buf, buflen, &offset, &code, &data_len, &data);
 567                 if (r < 0)
 568                         return r;
 569
 570                 switch (code) {
 571                 case SD_DHCP6_OPTION_STATUS_CODE: {
 572                         _cleanup_free_ char *msg = NULL;
 573
 574                         r = dhcp6_option_parse_status(data, data_len, &msg);
 575                         if (r == -ENOMEM)
 576                                 return r;
 577                         if (r > 0)
 578                                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 579                                                               "Received an IA address or PD prefix option with non-zero status%s%s",
 580                                                               isempty(msg) ? "." : ": ", strempty(msg));
 581                         if (r < 0)
 582                                 /* Let's log but ignore the invalid status option. */
 583                                 log_dhcp6_client_errno(client, r,
 584                                                        "Received an IA address or PD prefix option with an invalid status sub option, ignoring: %m");
 585                         break;
 586                 }
 587                 default:
 588                         log_dhcp6_client(client, "Received an unknown sub option %u in IA address or PD prefix, ignoring.", code);
 589                 }
 590         }
 591
 592         return 0;
 593 }
 594
 595 static int dhcp6_option_parse_ia_address(sd_dhcp6_client *client, DHCP6IA *ia, const uint8_t *data, size_t len) {
 596         _cleanup_free_ DHCP6Address *a = NULL;
 597         usec_t lt_valid, lt_pref;
 598         int r;
 599
 600         assert(ia);
 601         assert(data || len == 0);
 602
 603         if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_NA, SD_DHCP6_OPTION_IA_TA))
 604                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 605                                               "Received an IA address sub-option in an invalid option, ignoring.");
 606
 607         if (len < sizeof(struct iaaddr))
 608                 return -EBADMSG;
 609
 610         a = new(DHCP6Address, 1);
 611         if (!a)
 612                 return -ENOMEM;
 613
 614         memcpy(&a->iaaddr, data, sizeof(struct iaaddr));
 615
 616         lt_valid = be32_sec_to_usec(a->iaaddr.lifetime_valid, /* max_as_infinity = */ true);
 617         lt_pref = be32_sec_to_usec(a->iaaddr.lifetime_preferred, /* max_as_infinity = */ true);
 618
 619         if (lt_valid == 0)
 620                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 621                                               "Received an IA address with zero valid lifetime, ignoring.");
 622         if (lt_pref > lt_valid)
 623                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 624                                               "Received an IA address with preferred lifetime %s "
 625                                               "larger than valid lifetime %s, ignoring.",
 626                                               FORMAT_TIMESPAN(lt_pref, USEC_PER_SEC),
 627                                               FORMAT_TIMESPAN(lt_valid, USEC_PER_SEC));
 628
 629         if (len > sizeof(struct iaaddr)) {
 630                 r = dhcp6_option_parse_ia_options(client, data + sizeof(struct iaaddr), len - sizeof(struct iaaddr));
 631                 if (r < 0)
 632                         return r;
 633         }
 634
 635         LIST_PREPEND(addresses, ia->addresses, TAKE_PTR(a));
 636         return 0;
 637 }
 638
 639 static int dhcp6_option_parse_ia_pdprefix(sd_dhcp6_client *client, DHCP6IA *ia, const uint8_t *data, size_t len) {
 640         _cleanup_free_ DHCP6Address *a = NULL;
 641         usec_t lt_valid, lt_pref;
 642         int r;
 643
 644         assert(ia);
 645         assert(data || len == 0);
 646
 647         if (ia->type != SD_DHCP6_OPTION_IA_PD)
 648                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 649                                               "Received an PD prefix sub-option in an invalid option, ignoring");
 650
 651         if (len < sizeof(struct iapdprefix))
 652                 return -EBADMSG;
 653
 654         a = new(DHCP6Address, 1);
 655         if (!a)
 656                 return -ENOMEM;
 657
 658         memcpy(&a->iapdprefix, data, sizeof(struct iapdprefix));
 659
 660         lt_valid = be32_sec_to_usec(a->iapdprefix.lifetime_valid, /* max_as_infinity = */ true);
 661         lt_pref = be32_sec_to_usec(a->iapdprefix.lifetime_preferred, /* max_as_infinity = */ true);
 662
 663         if (lt_valid == 0)
 664                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 665                                               "Received a PD prefix with zero valid lifetime, ignoring.");
 666         if (lt_pref > lt_valid)
 667                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 668                                               "Received a PD prefix with preferred lifetime %s "
 669                                               "larger than valid lifetime %s, ignoring.",
 670                                               FORMAT_TIMESPAN(lt_pref, USEC_PER_SEC),
 671                                               FORMAT_TIMESPAN(lt_valid, USEC_PER_SEC));
 672
 673         if (len > sizeof(struct iapdprefix)) {
 674                 r = dhcp6_option_parse_ia_options(client, data + sizeof(struct iapdprefix), len - sizeof(struct iapdprefix));
 675                 if (r < 0)
 676                         return r;
 677         }
 678
 679         LIST_PREPEND(addresses, ia->addresses, TAKE_PTR(a));
 680         return 0;
 681 }
 682
 683 int dhcp6_option_parse_ia(
 684                 sd_dhcp6_client *client,
 685                 be32_t iaid,
 686                 uint16_t option_code,
 687                 size_t option_data_len,
 688                 const uint8_t *option_data,
 689                 DHCP6IA **ret) {
 690
 691         _cleanup_(dhcp6_ia_freep) DHCP6IA *ia = NULL;
 692         usec_t lt_t1, lt_t2;
 693         size_t header_len;
 694         int r;
 695
 696         assert(IN_SET(option_code, SD_DHCP6_OPTION_IA_NA, SD_DHCP6_OPTION_IA_TA, SD_DHCP6_OPTION_IA_PD));
 697         assert(option_data || option_data_len == 0);
 698         assert(ret);
 699
 700         /* This will return the following:
 701          * -ENOMEM: memory allocation error,
 702          * -ENOANO: unmatching IAID,
 703          * -EINVAL: non-zero status code, or invalid lifetime,
 704          * -EBADMSG: invalid message format,
 705          * -ENODATA: no valid address or PD prefix,
 706          * 0: success. */
 707
 708         switch (option_code) {
 709         case SD_DHCP6_OPTION_IA_NA:
 710         case SD_DHCP6_OPTION_IA_PD:
 711                 header_len = sizeof(struct ia_header);
 712                 break;
 713
 714         case SD_DHCP6_OPTION_IA_TA:
 715                 header_len = sizeof(be32_t); /* IA_TA does not have lifetime. */
 716                 break;
 717
 718         default:
 719                 assert_not_reached();
 720         }
 721
 722         if (option_data_len < header_len)
 723                 return -EBADMSG;
 724
 725         ia = new(DHCP6IA, 1);
 726         if (!ia)
 727                 return -ENOMEM;
 728
 729         *ia = (DHCP6IA) {
 730                 .type = option_code,
 731         };
 732         memcpy(&ia->header, option_data, header_len);
 733
 734         /* According to RFC8415, IAs which do not match the client's IAID should be ignored,
 735          * but not necessary to ignore or refuse the whole message. */
 736         if (ia->header.id != iaid)
 737                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(ENOANO),
 738                                               "Received an IA option with a different IAID "
 739                                               "from the one chosen by the client, ignoring.");
 740
 741         /* It is not necessary to check if the lifetime_t2 is zero here, as in that case it will be updated later. */
 742         lt_t1 = be32_sec_to_usec(ia->header.lifetime_t1, /* max_as_infinity = */ true);
 743         lt_t2 = be32_sec_to_usec(ia->header.lifetime_t2, /* max_as_infinity = */ true);
 744
 745         if (lt_t1 > lt_t2)
 746                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 747                                               "Received an IA option with T1 %s > T2 %s, ignoring.",
 748                                               FORMAT_TIMESPAN(lt_t1, USEC_PER_SEC),
 749                                               FORMAT_TIMESPAN(lt_t2, USEC_PER_SEC));
 750         if (lt_t1 == 0 && lt_t2 > 0)
 751                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 752                                               "Received an IA option with zero T1 and non-zero T2 (%s), ignoring.",
 753                                               FORMAT_TIMESPAN(lt_t2, USEC_PER_SEC));
 754
 755         for (size_t offset = header_len; offset < option_data_len;) {
 756                 const uint8_t *subdata;
 757                 size_t subdata_len;
 758                 uint16_t subopt;
 759
 760                 r = dhcp6_option_parse(option_data, option_data_len, &offset, &subopt, &subdata_len, &subdata);
 761                 if (r < 0)
 762                         return r;
 763
 764                 switch (subopt) {
 765                 case SD_DHCP6_OPTION_IAADDR: {
 766                         r = dhcp6_option_parse_ia_address(client, ia, subdata, subdata_len);
 767                         if (r == -ENOMEM)
 768                                 return r;
 769
 770                         /* Ignore non-critical errors in the sub-option. */
 771                         break;
 772                 }
 773                 case SD_DHCP6_OPTION_IA_PD_PREFIX: {
 774                         r = dhcp6_option_parse_ia_pdprefix(client, ia, subdata, subdata_len);
 775                         if (r == -ENOMEM)
 776                                 return r;
 777
 778                         /* Ignore non-critical errors in the sub-option. */
 779                         break;
 780                 }
 781                 case SD_DHCP6_OPTION_STATUS_CODE: {
 782                         _cleanup_free_ char *msg = NULL;
 783
 784                         r = dhcp6_option_parse_status(subdata, subdata_len, &msg);
 785                         if (r == -ENOMEM)
 786                                 return r;
 787                         if (r > 0)
 788                                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
 789                                                               "Received an IA option with non-zero status%s%s",
 790                                                               isempty(msg) ? "." : ": ", strempty(msg));
 791                         if (r < 0)
 792                                 log_dhcp6_client_errno(client, r,
 793                                                        "Received an IA option with an invalid status sub option, ignoring: %m");
 794                         break;
 795                 }
 796                 default:
 797                         log_dhcp6_client(client, "Received an IA option with an unknown sub-option %u, ignoring", subopt);
 798                 }
 799         }
 800
 801         if (!ia->addresses)
 802                 return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(ENODATA),
 803                                               "Received an IA option without valid IA addresses or PD prefixes, ignoring.");
 804
 805         *ret = TAKE_PTR(ia);
 806         return 0;
 807 }
 808
 809 int dhcp6_option_parse_addresses(
 810                 const uint8_t *optval,
 811                 size_t optlen,
 812                 struct in6_addr **addrs,
 813                 size_t *count) {
 814
 815         assert(optval || optlen == 0);
 816         assert(addrs);
 817         assert(count);
 818
 819         if (optlen == 0 || optlen % sizeof(struct in6_addr) != 0)
 820                 return -EBADMSG;
 821
 822         if (!GREEDY_REALLOC(*addrs, *count + optlen / sizeof(struct in6_addr)))
 823                 return -ENOMEM;
 824
 825         memcpy(*addrs + *count, optval, optlen);
 826         *count += optlen / sizeof(struct in6_addr);
 827
 828         return 0;
 829 }
 830
 831 int dhcp6_option_parse_domainname(const uint8_t *optval, size_t optlen, char **ret) {
 832         _cleanup_free_ char *domain = NULL;
 833         int r;
 834
 835         assert(optval || optlen == 0);
 836         assert(ret);
 837
 838         r = dns_name_from_wire_format(&optval, &optlen, &domain);
 839         if (r < 0)
 840                 return r;
 841         if (r == 0)
 842                 return -ENODATA;
 843         if (optlen != 0)
 844                 return -EINVAL;
 845
 846         *ret = TAKE_PTR(domain);
 847         return 0;
 848 }
 849
 850 int dhcp6_option_parse_domainname_list(const uint8_t *optval, size_t optlen, char ***ret) {
 851         _cleanup_strv_free_ char **names = NULL;
 852         int r;
 853
 854         assert(optval || optlen == 0);
 855         assert(ret);
 856
 857         if (optlen <= 1)
 858                 return -ENODATA;
 859         if (optval[optlen - 1] != '\0')
 860                 return -EINVAL;
 861
 862         while (optlen > 0) {
 863                 _cleanup_free_ char *name = NULL;
 864
 865                 r = dns_name_from_wire_format(&optval, &optlen, &name);
 866                 if (r < 0)
 867                         return r;
 868                 if (dns_name_is_root(name)) /* root domain */
 869                         return -EBADMSG;
 870
 871                 r = strv_consume(&names, TAKE_PTR(name));
 872                 if (r < 0)
 873                         return r;
 874         }
 875
 876         *ret = TAKE_PTR(names);
 877         return 0;
 878 }
 879
 880 static sd_dhcp6_option* dhcp6_option_free(sd_dhcp6_option *i) {
 881         if (!i)
 882                 return NULL;
 883
 884         free(i->data);
 885         return mfree(i);
 886 }
 887
 888 int sd_dhcp6_option_new(uint16_t option, const void *data, size_t length, uint32_t enterprise_identifier, sd_dhcp6_option **ret) {
 889         assert_return(ret, -EINVAL);
 890         assert_return(length == 0 || data, -EINVAL);
 891
 892         _cleanup_free_ void *q = memdup(data, length);
 893         if (!q)
 894                 return -ENOMEM;
 895
 896         sd_dhcp6_option *p = new(sd_dhcp6_option, 1);
 897         if (!p)
 898                 return -ENOMEM;
 899
 900         *p = (sd_dhcp6_option) {
 901                 .n_ref = 1,
 902                 .option = option,
 903                 .enterprise_identifier = enterprise_identifier,
 904                 .length = length,
 905                 .data = TAKE_PTR(q),
 906         };
 907
 908         *ret = p;
 909         return 0;
 910 }
 911
 912 DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp6_option, sd_dhcp6_option, dhcp6_option_free);
 913 DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
 914                 dhcp6_option_hash_ops,
 915                 void,
 916                 trivial_hash_func,
 917                 trivial_compare_func,
 918                 sd_dhcp6_option,
 919                 sd_dhcp6_option_unref);