[mirror_frr.git] / pceplib / pcep_msg_tlvs.c

/*
 * This file is part of the PCEPlib, a PCEP protocol library.
 *
 * Copyright (C) 2020 Volta Networks https://voltanet.io/
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * Author : Brady Johnson <brady@voltanet.io>
 *
 */


/*
 * This is the implementation of a High Level PCEP message object TLV API.
 */

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>

#include "pcep_msg_tlvs.h"
#include "pcep_msg_encoding.h"
#include "pcep_utils_memory.h"

static struct pcep_object_tlv_header *
pcep_tlv_common_create(enum pcep_object_tlv_types type, uint16_t size)
{
	struct pcep_object_tlv_header *tlv =
		pceplib_malloc(PCEPLIB_MESSAGES, size);
	memset(tlv, 0, size);
	tlv->type = type;

	return tlv;
}

/*
 * Open Object TLVs
 */

struct pcep_object_tlv_stateful_pce_capability *
pcep_tlv_create_stateful_pce_capability(
	bool flag_u_lsp_update_capability, bool flag_s_include_db_version,
	bool flag_i_lsp_instantiation_capability, bool flag_t_triggered_resync,
	bool flag_d_delta_lsp_sync, bool flag_f_triggered_initial_sync)
{
	struct pcep_object_tlv_stateful_pce_capability *tlv =
		(struct pcep_object_tlv_stateful_pce_capability *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY,
				sizeof(struct
				       pcep_object_tlv_stateful_pce_capability));
	tlv->flag_u_lsp_update_capability = flag_u_lsp_update_capability;
	tlv->flag_s_include_db_version = flag_s_include_db_version;
	tlv->flag_i_lsp_instantiation_capability =
		flag_i_lsp_instantiation_capability;
	tlv->flag_t_triggered_resync = flag_t_triggered_resync;
	tlv->flag_d_delta_lsp_sync = flag_d_delta_lsp_sync;
	tlv->flag_f_triggered_initial_sync = flag_f_triggered_initial_sync;

	return tlv;
}

struct pcep_object_tlv_lsp_db_version *
pcep_tlv_create_lsp_db_version(uint64_t lsp_db_version)
{
	struct pcep_object_tlv_lsp_db_version *tlv =
		(struct pcep_object_tlv_lsp_db_version *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION,
			sizeof(struct pcep_object_tlv_lsp_db_version));
	tlv->lsp_db_version = lsp_db_version;

	return tlv;
}

struct pcep_object_tlv_speaker_entity_identifier *
pcep_tlv_create_speaker_entity_id(double_linked_list *speaker_entity_id_list)
{
	if (speaker_entity_id_list == NULL) {
		return NULL;
	}

	if (speaker_entity_id_list->num_entries == 0) {
		return NULL;
	}

	struct pcep_object_tlv_speaker_entity_identifier *tlv =
		(struct pcep_object_tlv_speaker_entity_identifier *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID,
				sizeof(struct
				       pcep_object_tlv_speaker_entity_identifier));
	tlv->speaker_entity_id_list = speaker_entity_id_list;

	return tlv;
}

struct pcep_object_tlv_path_setup_type *
pcep_tlv_create_path_setup_type(uint8_t pst)
{
	struct pcep_object_tlv_path_setup_type *tlv =
		(struct pcep_object_tlv_path_setup_type *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE,
				sizeof(struct pcep_object_tlv_path_setup_type));
	tlv->path_setup_type = pst;

	return tlv;
}

struct pcep_object_tlv_path_setup_type_capability *
pcep_tlv_create_path_setup_type_capability(double_linked_list *pst_list,
					   double_linked_list *sub_tlv_list)
{
	if (pst_list == NULL) {
		return NULL;
	}

	if (pst_list->num_entries == 0) {
		return NULL;
	}

	struct pcep_object_tlv_path_setup_type_capability *tlv =
		(struct pcep_object_tlv_path_setup_type_capability *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE_CAPABILITY,
				sizeof(struct
				       pcep_object_tlv_path_setup_type_capability));

	tlv->pst_list = pst_list;
	tlv->sub_tlv_list = sub_tlv_list;

	return tlv;
}

struct pcep_object_tlv_sr_pce_capability *
pcep_tlv_create_sr_pce_capability(bool flag_n, bool flag_x,
				  uint8_t max_sid_depth)
{
	struct pcep_object_tlv_sr_pce_capability *tlv =
		(struct pcep_object_tlv_sr_pce_capability *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY,
				sizeof(struct
				       pcep_object_tlv_sr_pce_capability));
	tlv->flag_n = flag_n;
	tlv->flag_x = flag_x;
	tlv->max_sid_depth = max_sid_depth;

	return tlv;
}

struct pcep_object_tlv_of_list *
pcep_tlv_create_of_list(double_linked_list *of_list)
{
	if (of_list == NULL) {
		return NULL;
	}

	struct pcep_object_tlv_of_list *tlv =
		(struct pcep_object_tlv_of_list *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_OBJECTIVE_FUNCTION_LIST,
			sizeof(struct pcep_object_tlv_of_list));

	tlv->of_list = of_list;

	return tlv;
}

/*
 * LSP Object TLVs
 */

struct pcep_object_tlv_ipv4_lsp_identifier *
pcep_tlv_create_ipv4_lsp_identifiers(struct in_addr *ipv4_tunnel_sender,
				     struct in_addr *ipv4_tunnel_endpoint,
				     uint16_t lsp_id, uint16_t tunnel_id,
				     struct in_addr *extended_tunnel_id)
{
	if (ipv4_tunnel_sender == NULL || ipv4_tunnel_endpoint == NULL) {
		return NULL;
	}

	struct pcep_object_tlv_ipv4_lsp_identifier *tlv =
		(struct pcep_object_tlv_ipv4_lsp_identifier *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS,
				sizeof(struct
				       pcep_object_tlv_ipv4_lsp_identifier));
	tlv->ipv4_tunnel_sender.s_addr = ipv4_tunnel_sender->s_addr;
	tlv->ipv4_tunnel_endpoint.s_addr = ipv4_tunnel_endpoint->s_addr;
	tlv->lsp_id = lsp_id;
	tlv->tunnel_id = tunnel_id;
	tlv->extended_tunnel_id.s_addr =
		(extended_tunnel_id == NULL ? INADDR_ANY
					    : extended_tunnel_id->s_addr);

	return tlv;
}

struct pcep_object_tlv_ipv6_lsp_identifier *
pcep_tlv_create_ipv6_lsp_identifiers(struct in6_addr *ipv6_tunnel_sender,
				     struct in6_addr *ipv6_tunnel_endpoint,
				     uint16_t lsp_id, uint16_t tunnel_id,
				     struct in6_addr *extended_tunnel_id)
{
	if (ipv6_tunnel_sender == NULL || ipv6_tunnel_endpoint == NULL) {
		return NULL;
	}

	struct pcep_object_tlv_ipv6_lsp_identifier *tlv =
		(struct pcep_object_tlv_ipv6_lsp_identifier *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS,
				sizeof(struct
				       pcep_object_tlv_ipv6_lsp_identifier));

	memcpy(&tlv->ipv6_tunnel_sender, ipv6_tunnel_sender,
	       sizeof(struct in6_addr));

	tlv->tunnel_id = tunnel_id;
	tlv->lsp_id = lsp_id;

	memcpy(&tlv->extended_tunnel_id, extended_tunnel_id,
	       sizeof(struct in6_addr));

	memcpy(&tlv->ipv6_tunnel_endpoint, ipv6_tunnel_endpoint,
	       sizeof(struct in6_addr));

	return tlv;
}

struct pcep_object_tlv_symbolic_path_name *
pcep_tlv_create_symbolic_path_name(const char *symbolic_path_name,
				   uint16_t symbolic_path_name_length)
{
	/* symbolic_path_name_length should NOT include the null terminator and
	 * cannot be zero */
	if (symbolic_path_name == NULL || symbolic_path_name_length == 0) {
		return NULL;
	}

	struct pcep_object_tlv_symbolic_path_name *tlv =
		(struct pcep_object_tlv_symbolic_path_name *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME,
				sizeof(struct
				       pcep_object_tlv_symbolic_path_name));

	uint16_t length = (symbolic_path_name_length > MAX_SYMBOLIC_PATH_NAME)
				  ? MAX_SYMBOLIC_PATH_NAME
				  : symbolic_path_name_length;
	memcpy(tlv->symbolic_path_name, symbolic_path_name, length);
	tlv->symbolic_path_name_length = length;

	return tlv;
}

struct pcep_object_tlv_lsp_error_code *
pcep_tlv_create_lsp_error_code(enum pcep_tlv_lsp_error_codes lsp_error_code)
{
	struct pcep_object_tlv_lsp_error_code *tlv =
		(struct pcep_object_tlv_lsp_error_code *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE,
			sizeof(struct pcep_object_tlv_lsp_error_code));
	tlv->lsp_error_code = lsp_error_code;

	return tlv;
}

struct pcep_object_tlv_rsvp_error_spec *
pcep_tlv_create_rsvp_ipv4_error_spec(struct in_addr *error_node_ip,
				     uint8_t error_code, uint16_t error_value)
{
	if (error_node_ip == NULL) {
		return NULL;
	}

	struct pcep_object_tlv_rsvp_error_spec *tlv =
		(struct pcep_object_tlv_rsvp_error_spec *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC,
				sizeof(struct pcep_object_tlv_rsvp_error_spec));

	tlv->c_type = RSVP_ERROR_SPEC_IPV4_CTYPE;
	tlv->class_num = RSVP_ERROR_SPEC_CLASS_NUM;
	tlv->error_code = error_code;
	tlv->error_value = error_value;
	tlv->error_spec_ip.ipv4_error_node_address.s_addr =
		error_node_ip->s_addr;

	return tlv;
}

struct pcep_object_tlv_rsvp_error_spec *
pcep_tlv_create_rsvp_ipv6_error_spec(struct in6_addr *error_node_ip,
				     uint8_t error_code, uint16_t error_value)
{
	if (error_node_ip == NULL) {
		return NULL;
	}

	struct pcep_object_tlv_rsvp_error_spec *tlv =
		(struct pcep_object_tlv_rsvp_error_spec *)
			pcep_tlv_common_create(
				PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC,
				sizeof(struct pcep_object_tlv_rsvp_error_spec));

	tlv->c_type = RSVP_ERROR_SPEC_IPV6_CTYPE;
	tlv->class_num = RSVP_ERROR_SPEC_CLASS_NUM;
	tlv->error_code = error_code;
	tlv->error_value = error_value;
	memcpy(&tlv->error_spec_ip, error_node_ip, sizeof(struct in6_addr));

	return tlv;
}

struct pcep_object_tlv_nopath_vector *
pcep_tlv_create_nopath_vector(uint32_t error_code)
{
	struct pcep_object_tlv_nopath_vector *tlv =
		(struct pcep_object_tlv_nopath_vector *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_NO_PATH_VECTOR,
			sizeof(struct pcep_object_tlv_nopath_vector));

	tlv->error_code = error_code;

	return tlv;
}

struct pcep_object_tlv_vendor_info *
pcep_tlv_create_vendor_info(uint32_t enterprise_number,
			    uint32_t enterprise_specific_info)
{
	struct pcep_object_tlv_vendor_info *tlv =
		(struct pcep_object_tlv_vendor_info *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_VENDOR_INFO,
			sizeof(struct pcep_object_tlv_vendor_info));

	tlv->enterprise_number = enterprise_number;
	tlv->enterprise_specific_info = enterprise_specific_info;

	return tlv;
}

/*
 * SRPAG (SR Association Group) TLVs
 */

struct pcep_object_tlv_srpag_pol_id *
pcep_tlv_create_srpag_pol_id_ipv4(uint32_t color, struct in_addr *ipv4)
{
	struct pcep_object_tlv_srpag_pol_id *tlv =
		(struct pcep_object_tlv_srpag_pol_id *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID,
			sizeof(struct pcep_object_tlv_srpag_pol_id));
	tlv->color = color;
	tlv->is_ipv4 = true;
	memcpy(&tlv->end_point.ipv4.s_addr, ipv4, sizeof(struct in_addr));

	return tlv;
}

struct pcep_object_tlv_srpag_pol_id *
pcep_tlv_create_srpag_pol_id_ipv6(uint32_t color, struct in6_addr *ipv6)
{
	struct pcep_object_tlv_srpag_pol_id *tlv =
		(struct pcep_object_tlv_srpag_pol_id *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID,
			sizeof(struct pcep_object_tlv_srpag_pol_id));
	tlv->color = color;
	tlv->is_ipv4 = false;
	memcpy(&tlv->end_point.ipv6, ipv6, sizeof(struct in6_addr));

	return tlv;
}


struct pcep_object_tlv_srpag_pol_name *
pcep_tlv_create_srpag_pol_name(const char *pol_name, uint16_t pol_name_length)
{
	if (pol_name == NULL) {
		return NULL;
	}
	struct pcep_object_tlv_srpag_pol_name *tlv =
		(struct pcep_object_tlv_srpag_pol_name *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_NAME,
			sizeof(struct pcep_object_tlv_srpag_pol_name));
	uint16_t length =
		(normalize_pcep_tlv_length(pol_name_length) > MAX_POLICY_NAME)
			? MAX_POLICY_NAME
			: pol_name_length;
	memcpy(tlv->name, pol_name, length);
	tlv->name_length = length;

	return tlv;
}
struct pcep_object_tlv_srpag_cp_id *
pcep_tlv_create_srpag_cp_id(uint8_t proto_origin, uint32_t asn,
			    struct in6_addr *in6_addr_with_mapped_ipv4,
			    uint32_t discriminator)
{
	if (!in6_addr_with_mapped_ipv4) {
		return NULL;
	}

	struct pcep_object_tlv_srpag_cp_id *tlv =
		(struct pcep_object_tlv_srpag_cp_id *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_ID,
			sizeof(struct pcep_object_tlv_srpag_cp_id));
	tlv->proto = proto_origin;
	tlv->orig_asn = asn;
	memcpy(&(tlv->orig_addres), in6_addr_with_mapped_ipv4,
	       sizeof(*in6_addr_with_mapped_ipv4));
	tlv->discriminator = discriminator;

	return tlv;
}
struct pcep_object_tlv_srpag_cp_pref *
pcep_tlv_create_srpag_cp_pref(uint32_t pref)
{

	struct pcep_object_tlv_srpag_cp_pref *tlv =
		(struct pcep_object_tlv_srpag_cp_pref *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_PREFERENCE,
			sizeof(struct pcep_object_tlv_srpag_cp_pref));
	tlv->preference = pref;

	return tlv;
}

struct pcep_object_tlv_arbitrary *
pcep_tlv_create_tlv_arbitrary(const char *data, uint16_t data_length,
			      int tlv_id)
{
	if (data == NULL || data_length == 0) {
		return NULL;
	}

	struct pcep_object_tlv_arbitrary *tlv =
		(struct pcep_object_tlv_arbitrary *)pcep_tlv_common_create(
			PCEP_OBJ_TLV_TYPE_ARBITRARY,
			sizeof(struct pcep_object_tlv_arbitrary));

	uint16_t length = (data_length > MAX_ARBITRARY_SIZE)
				  ? MAX_ARBITRARY_SIZE
				  : data_length;
	memcpy(tlv->data, data, length);
	tlv->data_length = length;
	tlv->arbitraty_type = tlv_id;

	return tlv;
}
Commit	Line	Data
74971473 JG	1	/*
	2	* This file is part of the PCEPlib, a PCEP protocol library.
	3	*
	4	* Copyright (C) 2020 Volta Networks https://voltanet.io/
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2 of the License, or (at your option) any later version.
	10	*
	11	* This library is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public License
	17	* along with this program. If not, see <https://www.gnu.org/licenses/>.
	18	*
	19	* Author : Brady Johnson <brady@voltanet.io>
	20	*
	21	*/
	22
	23
	24	/*
	25	* This is the implementation of a High Level PCEP message object TLV API.
	26	*/
	27
	28	#include <stdbool.h>
	29	#include <stdint.h>
	30	#include <string.h>
	31	#include <unistd.h>
	32
	33	#include "pcep_msg_tlvs.h"
	34	#include "pcep_msg_encoding.h"
	35	#include "pcep_utils_memory.h"
	36
	37	static struct pcep_object_tlv_header *
	38	pcep_tlv_common_create(enum pcep_object_tlv_types type, uint16_t size)
	39	{
	40	struct pcep_object_tlv_header *tlv =
	41	pceplib_malloc(PCEPLIB_MESSAGES, size);
	42	memset(tlv, 0, size);
	43	tlv->type = type;
	44
	45	return tlv;
	46	}
	47
	48	/*
	49	* Open Object TLVs
	50	*/
	51
	52	struct pcep_object_tlv_stateful_pce_capability *
	53	pcep_tlv_create_stateful_pce_capability(
	54	bool flag_u_lsp_update_capability, bool flag_s_include_db_version,
	55	bool flag_i_lsp_instantiation_capability, bool flag_t_triggered_resync,
	56	bool flag_d_delta_lsp_sync, bool flag_f_triggered_initial_sync)
	57	{
	58	struct pcep_object_tlv_stateful_pce_capability *tlv =
	59	(struct pcep_object_tlv_stateful_pce_capability *)
	60	pcep_tlv_common_create(
	61	PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY,
	62	sizeof(struct
	63	pcep_object_tlv_stateful_pce_capability));
	64	tlv->flag_u_lsp_update_capability = flag_u_lsp_update_capability;
65	tlv->flag_s_include_db_version = flag_s_include_db_version;
66	tlv->flag_i_lsp_instantiation_capability =
67	flag_i_lsp_instantiation_capability;
68	tlv->flag_t_triggered_resync = flag_t_triggered_resync;
69	tlv->flag_d_delta_lsp_sync = flag_d_delta_lsp_sync;
70	tlv->flag_f_triggered_initial_sync = flag_f_triggered_initial_sync;
71
72	return tlv;
73	}
74
75	struct pcep_object_tlv_lsp_db_version *
76	pcep_tlv_create_lsp_db_version(uint64_t lsp_db_version)
77	{
78	struct pcep_object_tlv_lsp_db_version *tlv =
79	(struct pcep_object_tlv_lsp_db_version *)pcep_tlv_common_create(
80	PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION,
81	sizeof(struct pcep_object_tlv_lsp_db_version));
82	tlv->lsp_db_version = lsp_db_version;
83
84	return tlv;
85	}
86
87	struct pcep_object_tlv_speaker_entity_identifier *
88	pcep_tlv_create_speaker_entity_id(double_linked_list *speaker_entity_id_list)
89	{
90	if (speaker_entity_id_list == NULL) {
91	return NULL;
92	}
93
94	if (speaker_entity_id_list->num_entries == 0) {
95	return NULL;
96	}
97
98	struct pcep_object_tlv_speaker_entity_identifier *tlv =
99	(struct pcep_object_tlv_speaker_entity_identifier *)
100	pcep_tlv_common_create(
101	PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID,
102	sizeof(struct
103	pcep_object_tlv_speaker_entity_identifier));
104	tlv->speaker_entity_id_list = speaker_entity_id_list;
105
106	return tlv;
107	}
108
109	struct pcep_object_tlv_path_setup_type *
110	pcep_tlv_create_path_setup_type(uint8_t pst)
111	{
112	struct pcep_object_tlv_path_setup_type *tlv =
113	(struct pcep_object_tlv_path_setup_type *)
114	pcep_tlv_common_create(
115	PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE,
116	sizeof(struct pcep_object_tlv_path_setup_type));
117	tlv->path_setup_type = pst;
118
119	return tlv;
120	}
121
122	struct pcep_object_tlv_path_setup_type_capability *
123	pcep_tlv_create_path_setup_type_capability(double_linked_list *pst_list,
124	double_linked_list *sub_tlv_list)
125	{
126	if (pst_list == NULL) {
127	return NULL;
128	}
129
130	if (pst_list->num_entries == 0) {
131	return NULL;
132	}
133
134	struct pcep_object_tlv_path_setup_type_capability *tlv =
135	(struct pcep_object_tlv_path_setup_type_capability *)
136	pcep_tlv_common_create(
137	PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE_CAPABILITY,
138	sizeof(struct
139	pcep_object_tlv_path_setup_type_capability));
140
141	tlv->pst_list = pst_list;
142	tlv->sub_tlv_list = sub_tlv_list;
143
144	return tlv;
145	}
146
147	struct pcep_object_tlv_sr_pce_capability *
148	pcep_tlv_create_sr_pce_capability(bool flag_n, bool flag_x,
149	uint8_t max_sid_depth)
150	{
151	struct pcep_object_tlv_sr_pce_capability *tlv =
152	(struct pcep_object_tlv_sr_pce_capability *)
153	pcep_tlv_common_create(
154	PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY,
155	sizeof(struct
156	pcep_object_tlv_sr_pce_capability));
157	tlv->flag_n = flag_n;
158	tlv->flag_x = flag_x;
159	tlv->max_sid_depth = max_sid_depth;
160
161	return tlv;
162	}
163
164	struct pcep_object_tlv_of_list *
165	pcep_tlv_create_of_list(double_linked_list *of_list)
166	{
167	if (of_list == NULL) {
168	return NULL;
169	}
170
171	struct pcep_object_tlv_of_list *tlv =
172	(struct pcep_object_tlv_of_list *)pcep_tlv_common_create(
173	PCEP_OBJ_TLV_TYPE_OBJECTIVE_FUNCTION_LIST,
174	sizeof(struct pcep_object_tlv_of_list));
175
176	tlv->of_list = of_list;
177
178	return tlv;
179	}
180
181	/*
182	* LSP Object TLVs
183	*/
184
185	struct pcep_object_tlv_ipv4_lsp_identifier *
186	pcep_tlv_create_ipv4_lsp_identifiers(struct in_addr *ipv4_tunnel_sender,
187	struct in_addr *ipv4_tunnel_endpoint,
188	uint16_t lsp_id, uint16_t tunnel_id,
189	struct in_addr *extended_tunnel_id)
190	{
191	if (ipv4_tunnel_sender == NULL \|\| ipv4_tunnel_endpoint == NULL) {
192	return NULL;
193	}
194
195	struct pcep_object_tlv_ipv4_lsp_identifier *tlv =
196	(struct pcep_object_tlv_ipv4_lsp_identifier *)
197	pcep_tlv_common_create(
198	PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS,
199	sizeof(struct
200	pcep_object_tlv_ipv4_lsp_identifier));
201	tlv->ipv4_tunnel_sender.s_addr = ipv4_tunnel_sender->s_addr;
202	tlv->ipv4_tunnel_endpoint.s_addr = ipv4_tunnel_endpoint->s_addr;
203	tlv->lsp_id = lsp_id;
204	tlv->tunnel_id = tunnel_id;
205	tlv->extended_tunnel_id.s_addr =
206	(extended_tunnel_id == NULL ? INADDR_ANY
207	: extended_tunnel_id->s_addr);
208
209	return tlv;
210	}
211
212	struct pcep_object_tlv_ipv6_lsp_identifier *
213	pcep_tlv_create_ipv6_lsp_identifiers(struct in6_addr *ipv6_tunnel_sender,
214	struct in6_addr *ipv6_tunnel_endpoint,
215	uint16_t lsp_id, uint16_t tunnel_id,
216	struct in6_addr *extended_tunnel_id)
217	{
218	if (ipv6_tunnel_sender == NULL \|\| ipv6_tunnel_endpoint == NULL) {
219	return NULL;
220	}
221
222	struct pcep_object_tlv_ipv6_lsp_identifier *tlv =
223	(struct pcep_object_tlv_ipv6_lsp_identifier *)
224	pcep_tlv_common_create(
225	PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS,
226	sizeof(struct
227	pcep_object_tlv_ipv6_lsp_identifier));
228
229	memcpy(&tlv->ipv6_tunnel_sender, ipv6_tunnel_sender,
230	sizeof(struct in6_addr));
231
232	tlv->tunnel_id = tunnel_id;
233	tlv->lsp_id = lsp_id;
234
235	memcpy(&tlv->extended_tunnel_id, extended_tunnel_id,
236	sizeof(struct in6_addr));
237
238	memcpy(&tlv->ipv6_tunnel_endpoint, ipv6_tunnel_endpoint,
239	sizeof(struct in6_addr));
240
241	return tlv;
242	}
243
244	struct pcep_object_tlv_symbolic_path_name *
245	pcep_tlv_create_symbolic_path_name(const char *symbolic_path_name,
246	uint16_t symbolic_path_name_length)
247	{
248	/* symbolic_path_name_length should NOT include the null terminator and
249	* cannot be zero */
250	if (symbolic_path_name == NULL \|\| symbolic_path_name_length == 0) {
251	return NULL;
252	}
253
254	struct pcep_object_tlv_symbolic_path_name *tlv =
255	(struct pcep_object_tlv_symbolic_path_name *)
256	pcep_tlv_common_create(
257	PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME,
258	sizeof(struct
259	pcep_object_tlv_symbolic_path_name));
260
261	uint16_t length = (symbolic_path_name_length > MAX_SYMBOLIC_PATH_NAME)
262	? MAX_SYMBOLIC_PATH_NAME
263	: symbolic_path_name_length;
264	memcpy(tlv->symbolic_path_name, symbolic_path_name, length);
265	tlv->symbolic_path_name_length = length;
266
267	return tlv;
268	}
269
270	struct pcep_object_tlv_lsp_error_code *
271	pcep_tlv_create_lsp_error_code(enum pcep_tlv_lsp_error_codes lsp_error_code)
272	{
273	struct pcep_object_tlv_lsp_error_code *tlv =
274	(struct pcep_object_tlv_lsp_error_code *)pcep_tlv_common_create(
275	PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE,
276	sizeof(struct pcep_object_tlv_lsp_error_code));
277	tlv->lsp_error_code = lsp_error_code;
278
279	return tlv;
280	}
281
282	struct pcep_object_tlv_rsvp_error_spec *
283	pcep_tlv_create_rsvp_ipv4_error_spec(struct in_addr *error_node_ip,
284	uint8_t error_code, uint16_t error_value)
285	{
286	if (error_node_ip == NULL) {
287	return NULL;
288	}
289
290	struct pcep_object_tlv_rsvp_error_spec *tlv =
291	(struct pcep_object_tlv_rsvp_error_spec *)
292	pcep_tlv_common_create(
293	PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC,
294	sizeof(struct pcep_object_tlv_rsvp_error_spec));
295
296	tlv->c_type = RSVP_ERROR_SPEC_IPV4_CTYPE;
297	tlv->class_num = RSVP_ERROR_SPEC_CLASS_NUM;
298	tlv->error_code = error_code;
299	tlv->error_value = error_value;
300	tlv->error_spec_ip.ipv4_error_node_address.s_addr =
301	error_node_ip->s_addr;
302
303	return tlv;
304	}
305
306	struct pcep_object_tlv_rsvp_error_spec *
307	pcep_tlv_create_rsvp_ipv6_error_spec(struct in6_addr *error_node_ip,
308	uint8_t error_code, uint16_t error_value)
309	{
310	if (error_node_ip == NULL) {
311	return NULL;
312	}
313
314	struct pcep_object_tlv_rsvp_error_spec *tlv =
315	(struct pcep_object_tlv_rsvp_error_spec *)
316	pcep_tlv_common_create(
317	PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC,
318	sizeof(struct pcep_object_tlv_rsvp_error_spec));
319
320	tlv->c_type = RSVP_ERROR_SPEC_IPV6_CTYPE;
321	tlv->class_num = RSVP_ERROR_SPEC_CLASS_NUM;
322	tlv->error_code = error_code;
323	tlv->error_value = error_value;
324	memcpy(&tlv->error_spec_ip, error_node_ip, sizeof(struct in6_addr));
325
326	return tlv;
327	}
328
329	struct pcep_object_tlv_nopath_vector *
330	pcep_tlv_create_nopath_vector(uint32_t error_code)
331	{
332	struct pcep_object_tlv_nopath_vector *tlv =
333	(struct pcep_object_tlv_nopath_vector *)pcep_tlv_common_create(
334	PCEP_OBJ_TLV_TYPE_NO_PATH_VECTOR,
335	sizeof(struct pcep_object_tlv_nopath_vector));
336
337	tlv->error_code = error_code;
338
339	return tlv;
340	}
341
342	struct pcep_object_tlv_vendor_info *
343	pcep_tlv_create_vendor_info(uint32_t enterprise_number,
344	uint32_t enterprise_specific_info)
345	{
346	struct pcep_object_tlv_vendor_info *tlv =
347	(struct pcep_object_tlv_vendor_info *)pcep_tlv_common_create(
348	PCEP_OBJ_TLV_TYPE_VENDOR_INFO,
349	sizeof(struct pcep_object_tlv_vendor_info));
350
351	tlv->enterprise_number = enterprise_number;
352	tlv->enterprise_specific_info = enterprise_specific_info;
353
354	return tlv;
355	}
356
357	/*
358	* SRPAG (SR Association Group) TLVs
359	*/
360
361	struct pcep_object_tlv_srpag_pol_id *
362	pcep_tlv_create_srpag_pol_id_ipv4(uint32_t color, struct in_addr *ipv4)
363	{
364	struct pcep_object_tlv_srpag_pol_id *tlv =
365	(struct pcep_object_tlv_srpag_pol_id *)pcep_tlv_common_create(
366	PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID,
367	sizeof(struct pcep_object_tlv_srpag_pol_id));
368	tlv->color = color;
369	tlv->is_ipv4 = true;
370	memcpy(&tlv->end_point.ipv4.s_addr, ipv4, sizeof(struct in_addr));
371
372	return tlv;
373	}
374
375	struct pcep_object_tlv_srpag_pol_id *
376	pcep_tlv_create_srpag_pol_id_ipv6(uint32_t color, struct in6_addr *ipv6)
377	{
378	struct pcep_object_tlv_srpag_pol_id *tlv =
379	(struct pcep_object_tlv_srpag_pol_id *)pcep_tlv_common_create(
380	PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID,
381	sizeof(struct pcep_object_tlv_srpag_pol_id));
382	tlv->color = color;
383	tlv->is_ipv4 = false;
384	memcpy(&tlv->end_point.ipv6, ipv6, sizeof(struct in6_addr));
385
386	return tlv;
387	}
388
389
390	struct pcep_object_tlv_srpag_pol_name *
391	pcep_tlv_create_srpag_pol_name(const char *pol_name, uint16_t pol_name_length)
392	{
393	if (pol_name == NULL) {
394	return NULL;
395	}
396	struct pcep_object_tlv_srpag_pol_name *tlv =
397	(struct pcep_object_tlv_srpag_pol_name *)pcep_tlv_common_create(
398	PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_NAME,
399	sizeof(struct pcep_object_tlv_srpag_pol_name));
400	uint16_t length =
401	(normalize_pcep_tlv_length(pol_name_length) > MAX_POLICY_NAME)
402	? MAX_POLICY_NAME
403	: pol_name_length;
7ed8c4b1	404	memcpy(tlv->name, pol_name, length);
74971473 JG	405	tlv->name_length = length;
	406
	407	return tlv;
	408	}
	409	struct pcep_object_tlv_srpag_cp_id *
	410	pcep_tlv_create_srpag_cp_id(uint8_t proto_origin, uint32_t asn,
	411	struct in6_addr *in6_addr_with_mapped_ipv4,
	412	uint32_t discriminator)
	413	{
	414	if (!in6_addr_with_mapped_ipv4) {
	415	return NULL;
	416	}
	417
	418	struct pcep_object_tlv_srpag_cp_id *tlv =
	419	(struct pcep_object_tlv_srpag_cp_id *)pcep_tlv_common_create(
	420	PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_ID,
	421	sizeof(struct pcep_object_tlv_srpag_cp_id));
	422	tlv->proto = proto_origin;
	423	tlv->orig_asn = asn;
	424	memcpy(&(tlv->orig_addres), in6_addr_with_mapped_ipv4,
	425	sizeof(*in6_addr_with_mapped_ipv4));
	426	tlv->discriminator = discriminator;
	427
	428	return tlv;
	429	}
	430	struct pcep_object_tlv_srpag_cp_pref *
	431	pcep_tlv_create_srpag_cp_pref(uint32_t pref)
	432	{
	433
	434	struct pcep_object_tlv_srpag_cp_pref *tlv =
	435	(struct pcep_object_tlv_srpag_cp_pref *)pcep_tlv_common_create(
	436	PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_PREFERENCE,
	437	sizeof(struct pcep_object_tlv_srpag_cp_pref));
	438	tlv->preference = pref;
	439
	440	return tlv;
	441	}
	442
	443	struct pcep_object_tlv_arbitrary *
	444	pcep_tlv_create_tlv_arbitrary(const char *data, uint16_t data_length,
	445	int tlv_id)
	446	{
	447	if (data == NULL \|\| data_length == 0) {
	448	return NULL;
	449	}
	450
	451	struct pcep_object_tlv_arbitrary *tlv =
	452	(struct pcep_object_tlv_arbitrary *)pcep_tlv_common_create(
	453	PCEP_OBJ_TLV_TYPE_ARBITRARY,
	454	sizeof(struct pcep_object_tlv_arbitrary));
	455
	456	uint16_t length = (data_length > MAX_ARBITRARY_SIZE)
	457	? MAX_ARBITRARY_SIZE
	458	: data_length;
7ed8c4b1	459	memcpy(tlv->data, data, length);
74971473 JG	460	tlv->data_length = length;
	461	tlv->arbitraty_type = tlv_id;
	462
	463	return tlv;
	464	}