/src/freeradius-server/src/protocols/dhcpv6/dhcpv6.h

Source
#pragma once
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

/**
 * $Id: 0273f1c832021e550123dd15d70ce57aaf948ce8 $
 *
 * @file protocols/dhcpv6/dhcpv6.h
 * @brief Implementation of the DHCPv6 protocol.
 *
 * @author Arran Cudbard-Bell (a.cudbardb@freeradius.org)
 *
 * @copyright 2018 The FreeRADIUS server project
 * @copyright 2018 NetworkRADIUS SARL (legal@networkradius.com)
 */
RCSIDH(dhcpv6_h, "$Id: 0273f1c832021e550123dd15d70ce57aaf948ce8 $")

#include <freeradius-devel/util/dict.h>

#include <freeradius-devel/protocol/dhcpv6/dictionary.h>

#define DHCPV6_MSG_TYPE_LEN   1U

#define DHCPV6_TRANSACTION_ID_LEN 3U

#define DHCPV6_HOP_COUNT_LEN    1U
#define DHCPV6_LINK_ADDRESS_LEN   16U
#define DHCPV6_PEER_ADDRESS_LEN   16U

#define DHCPV6_HDR_LEN      (DHCPV6_MSG_TYPE_LEN + DHCPV6_TRANSACTION_ID_LEN)
#define DHCPV6_RELAY_HDR_LEN    (DHCPV6_MSG_TYPE_LEN + DHCPV6_HOP_COUNT_LEN + DHCPV6_LINK_ADDRESS_LEN + DHCPV6_PEER_ADDRESS_LEN)
#define DHCPV6_OPT_HDR_LEN    (sizeof(uint16_t) * 2)

#define DHCPV6_GET_OPTION_NUM(_x) fr_nbo_to_uint16(_x)
#define DHCPV6_GET_OPTION_LEN(_x) fr_nbo_to_uint16((_x) + 2)

#define DHCPV6_MAX_RELAY_NESTING  10

#define DHCPV6_MAX_ATTRIBUTES   1024

/*
 *  Defined addresses from RFC 8415 Section 7.1
 */
#define IN6ADDR_ALL_DHCP_RELAY_AGENTS_AND_SERVERS "FF02::1:2"
#define IN6ADDR_ALL_DHCP_RELAY_AGENTS_AND_SERVERS_INIT   {{{ 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,1,2}}}
#define IN6ADDR_ALL_DHCP_SERVERS      "FF05::1:3"
#define IN6ADDR_ALL_DHCP_SERVERS_INIT     {{{ 0xff,0x05,0,0,0,0,0,0,0,0,0,0,0,0,1,3}}}

/*
 *  Copied from src/include/protocols/dhcpv6/freeradius.internal.h
 *  and edited.
 */
typedef enum : uint16_t {
  FR_DHCPV6_INVALID = 0,
  FR_DHCPV6_SOLICIT = 1,
  FR_DHCPV6_ADVERTISE = 2,
  FR_DHCPV6_REQUEST = 3,
  FR_DHCPV6_CONFIRM = 4,
  FR_DHCPV6_RENEW = 5,
  FR_DHCPV6_REBIND = 6,
  FR_DHCPV6_REPLY = 7,
  FR_DHCPV6_RELEASE = 8,
  FR_DHCPV6_DECLINE = 9,
  FR_DHCPV6_RECONFIGURE = 10,
  FR_DHCPV6_INFORMATION_REQUEST = 11,
  FR_DHCPV6_RELAY_FORWARD = 12,
  FR_DHCPV6_RELAY_REPLY = 13,
  FR_DHCPV6_LEASE_QUERY = 14,
  FR_DHCPV6_LEASE_QUERY_REPLY = 15,
  FR_DHCPV6_LEASE_QUERY_DONE = 16,
  FR_DHCPV6_LEASE_QUERY_DATA = 17,
  FR_DHCPV6_RECONFIGURE_REQUEST = 18,
  FR_DHCPV6_RECONFIGURE_REPLY = 19,
  FR_DHCPV6_DHCPV4_QUERY = 20,
  FR_DHCPV6_DHCPV4_RESPONSE = 21,
  FR_DHCPV6_ACTIVE_LEASE_QUERY = 22,
  FR_DHCPV6_START_TLS = 23,
  FR_DHCPV6_BIND_UPDATE = 24,
  FR_DHCPV6_BIND_REPLY = 25,
  FR_DHCPV6_POOL_REQUEST = 26,
  FR_DHCPV6_POOL_RESPONSE = 27,
  FR_DHCPV6_UPDATE_REQUEST = 28,
  FR_DHCPV6_UPDATE_REQUEST_ALL = 29,
  FR_DHCPV6_UPDATE_DONE = 30,
  FR_DHCPV6_CONNECT = 31,
  FR_DHCPV6_CONNECT_REPLY = 32,
  FR_DHCPV6_DISCONNECT = 33,
  FR_DHCPV6_STATE = 34,
  FR_DHCPV6_CONTACT = 35,
  FR_DHCPV6_CODE_MAX = 36,
  FR_DHCPV6_DO_NOT_RESPOND = 256
} fr_dhcpv6_packet_code_t;

#define FR_DHCPV6_PACKET_CODE_VALID(_code) (((_code) > 0) && ((_code) < FR_DHCPV6_CODE_MAX))

extern char const   *fr_dhcpv6_packet_names[FR_DHCPV6_CODE_MAX];

/** subtype values for DHCPv4 and DHCPv6
 *
 */
typedef struct CC_HINT(__packed__) {
  uint8_t   code;
  uint8_t   transaction_id[3];
} fr_dhcpv6_packet_t;

/*
 *  DHCPv6 defines dates to start from Jan 1, 2000.  Which is
 *  exactly this number of seconds off of the standard Unix time
 *  stamps.
 */
#define DHCPV6_DATE_OFFSET (946684800)

typedef struct {
  fr_dict_attr_t const  *root;      //!< Root attribute of the dictionary.
  uint8_t const   *original;    //!< original packet
  size_t      original_length;  //!< length of the original packet
} fr_dhcpv6_encode_ctx_t;

typedef struct {
  TALLOC_CTX    *tmp_ctx;   //!< for temporary things cleaned up during decoding
  uint32_t    transaction_id;   //!< previous transaction ID
  uint8_t const     *duid;      //!< the expected DUID, in wire format
  size_t      duid_len;   //!< length of the expected DUID
} fr_dhcpv6_decode_ctx_t;

typedef struct {
  bool      dns_label;
  bool      partial_dns_label;
} fr_dhcpv6_attr_flags_t;

extern fr_dict_protocol_t libfreeradius_dhcpv6_dict_protocol;

/** Return DHCPv6-specific flags for a given attribute
 *
 * Assert in debug builds when the attribute belongs to another dictionary, as
 * the flags of one protocol say nothing about an attribute of another.
 *
 * If the attribute does not carry the protocol-specific extension, then assert.
 * Other builds log the error and return zeroed flags instead of NULL.
 */
static inline fr_dhcpv6_attr_flags_t const *fr_dhcpv6_attr_flags(fr_dict_attr_t const *da)
{
  static fr_dhcpv6_attr_flags_t const no_flags = {};
  fr_dhcpv6_attr_flags_t const    *flags;

  fr_assert_msg(fr_dict_protocol(da->dict) == &libfreeradius_dhcpv6_dict_protocol,
          "%s is not a DHCPv6 attribute, it is from the \"%s\" dictionary",
          da->name, fr_dict_root(da->dict)->name);

  flags = fr_dict_attr_ext(da, FR_DICT_ATTR_EXT_PROTOCOL_SPECIFIC);
  if (!fr_cond_assert_msg(flags, "%s is not a DHCPv6 attribute, it has no protocol extension",
        da->name)) return &no_flags;

  return flags;
}

static inline bool fr_dhcpv6_flag_dns_label(fr_dict_attr_t const *da)
{
  return fr_dhcpv6_attr_flags(da)->dns_label;
}

static inline bool fr_dhcpv6_flag_partial_dns_label(fr_dict_attr_t const *da)
{
  return fr_dhcpv6_attr_flags(da)->partial_dns_label;
}

static inline bool fr_dhcpv6_flag_any_dns_label(fr_dict_attr_t const *da)
{
  fr_dhcpv6_attr_flags_t const *flags = fr_dhcpv6_attr_flags(da);

  return flags->dns_label || flags->partial_dns_label;
}

/*
 *  base.c
 */
uint8_t const *fr_dhcpv6_option_find(uint8_t const *start, uint8_t const *end, unsigned int option);

bool    fr_dhcpv6_ok(uint8_t const *packet, size_t packet_len,
           uint32_t max_attributes);

bool    fr_dhcpv6_verify(uint8_t const *packet, size_t packet_len, fr_dhcpv6_decode_ctx_t const *packet_ctx,
         bool from_server);

ssize_t   fr_dhcpv6_encode(fr_dbuff_t *dbuff, uint8_t const *original, size_t length,
         int msg_type, fr_pair_list_t *vps);

ssize_t   fr_dhcpv6_decode(TALLOC_CTX *ctx, fr_pair_list_t *out, uint8_t const *packet, size_t packet_len);

void    fr_dhcpv6_print_hex(FILE *fp, uint8_t const *packet, size_t packet_len);

int   fr_dhcpv6_global_init(void);

void    fr_dhcpv6_global_free(void);

/*
 *  encode.c
 */
void    *fr_dhcpv6_next_encodable(fr_dcursor_t *cursor, void *current, void *uctx);

ssize_t   fr_dhcpv6_encode_option(fr_dbuff_t *dbuff, fr_dcursor_t *cursor, void * encode_ctx);

ssize_t   fr_dhcpv6_encode_foreign(fr_dbuff_t *dbuff, fr_pair_list_t const *list);

/*
 *  decode.c
 */
ssize_t   fr_dhcpv6_decode_option(TALLOC_CTX *ctx, fr_pair_list_t *out,
          uint8_t const *data, size_t data_len, void *decode_ctx);

ssize_t   fr_dhcpv6_decode_foreign(TALLOC_CTX *ctx, fr_pair_list_t *out,
           uint8_t const *data, size_t data_len);

Coverage Report

Created: 2026-10-18 06:56