[mirror_frr.git] / pathd / path_pcep.h

/*
 * Copyright (C) 2020  NetDEF, Inc.
 *
 * 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; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef _PATH_PCEP_H_
#define _PATH_PCEP_H_

#include <stdbool.h>
#include <debug.h>
#include <netinet/tcp.h>
#include "memory.h"
#include "pceplib/pcep_utils_logging.h"
#include "pceplib/pcep_pcc_api.h"
#include "mpls.h"
#include "pathd/pathd.h"

DECLARE_MTYPE(PCEP);

#define PCEP_DEFAULT_PORT 4189
#define MAX_PCC 32
#define MAX_PCE 32
#define MAX_TAG_SIZE 50
#define PCEP_DEBUG_MODE_BASIC 0x01
#define PCEP_DEBUG_MODE_PATH 0x02
#define PCEP_DEBUG_MODE_PCEP 0x04
#define PCEP_DEBUG_MODE_PCEPLIB 0x08
#define PCEP_DEBUG(fmt, ...)                                                   \
	do {                                                                   \
		if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_BASIC))    \
			DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__);     \
	} while (0)
#define PCEP_DEBUG_PATH(fmt, ...)                                              \
	do {                                                                   \
		if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PATH))     \
			DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__);     \
	} while (0)
#define PCEP_DEBUG_PCEP(fmt, ...)                                              \
	do {                                                                   \
		if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEP))     \
			DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__);     \
	} while (0)
#define PCEP_DEBUG_PCEPLIB(priority, fmt, ...)                                 \
	do {                                                                   \
		switch (priority) {                                            \
		case LOG_DEBUG:                                                \
			if (DEBUG_FLAGS_CHECK(&pcep_g->dbg,                    \
					      PCEP_DEBUG_MODE_PCEPLIB))        \
				DEBUGD(&pcep_g->dbg, "pcep: " fmt,             \
				       ##__VA_ARGS__);                         \
			break;                                                 \
		case LOG_INFO:                                                 \
			if (DEBUG_FLAGS_CHECK(&pcep_g->dbg,                    \
					      PCEP_DEBUG_MODE_PCEPLIB))        \
				DEBUGI(&pcep_g->dbg, "pcep: " fmt,             \
				       ##__VA_ARGS__);                         \
			break;                                                 \
		case LOG_NOTICE:                                               \
			if (DEBUG_FLAGS_CHECK(&pcep_g->dbg,                    \
					      PCEP_DEBUG_MODE_PCEPLIB))        \
				DEBUGN(&pcep_g->dbg, "pcep: " fmt,             \
				       ##__VA_ARGS__);                         \
			break;                                                 \
		case LOG_WARNING:                                              \
		case LOG_ERR:                                                  \
		default:                                                       \
			zlog(priority, "pcep: " fmt, ##__VA_ARGS__);           \
			break;                                                 \
		}                                                              \
	} while (0)

struct pcep_config_group_opts {
	char name[64];
	char tcp_md5_auth[PCEP_MD5SIG_MAXKEYLEN];
	struct ipaddr source_ip;
	short source_port;
	bool draft07;
	bool pce_initiated;
	int keep_alive_seconds;
	int min_keep_alive_seconds;
	int max_keep_alive_seconds;
	int dead_timer_seconds;
	int min_dead_timer_seconds;
	int max_dead_timer_seconds;
	int pcep_request_time_seconds;
	int session_timeout_inteval_seconds;
	int delegation_timeout_seconds;
};

struct pce_opts {
	struct ipaddr addr;
	short port;
	char pce_name[64];
	struct pcep_config_group_opts config_opts;
	uint8_t precedence; /* Multi-PCE precedence */
};

struct pcc_opts {
	struct ipaddr addr;
	short port;
	short msd;
};

/* Encapsulate the pce_opts with needed CLI information */
struct pce_opts_cli {
	struct pce_opts pce_opts;
	char config_group_name[64];
	/* These are the values configured in the pcc-peer sub-commands.
	 * These need to be stored for later merging. Notice, it could
	 * be that not all of them are set. */
	struct pcep_config_group_opts pce_config_group_opts;
	/* The pce_opts->config_opts will be a merge of the default values,
	 * optional config_group values (which overwrite default values),
	 * and any values configured in the pce sub-commands (which overwrite
	 * both default and config_group values). This flag indicates of the
	 * values need to be merged or not. */
	bool merged;
};

struct lsp_nb_key {
	uint32_t color;
	struct ipaddr endpoint;
	uint32_t preference;
};

struct sid_mpls {
	mpls_label_t label;
	uint8_t traffic_class;
	bool is_bottom;
	uint8_t ttl;
};

struct pcep_caps {
	bool is_stateful;
	/* If we know the objective functions supported by the PCE.
	 * If we don't know, it doesn't mean the PCE doesn't support any */
	bool supported_ofs_are_known;
	/* Defined if we know which objective funtions are supported by the PCE.
	 * One bit per objective function, the bit index being equal to
	 * enum pcep_objfun_type values: bit 0 is not used, bit 1 is
	 * PCEP_OBJFUN_MCP, up to bit 17 that is PCEP_OBJFUN_MSN */
	uint32_t supported_ofs;
};

union sid {
	uint32_t value;
	struct sid_mpls mpls;
};

struct nai {
	/* NAI type */
	enum pcep_sr_subobj_nai type;
	/* Local IP address*/
	struct ipaddr local_addr;
	/* Local interface identifier if the NAI is an unnumbered adjacency */
	uint32_t local_iface;
	/* Remote address if the NAI is an adjacency */
	struct ipaddr remote_addr;
	/* Remote interface identifier if the NAI is an unnumbered adjacency */
	uint32_t remote_iface;
};

struct path_hop {
	/* Pointer to the next hop in the path */
	struct path_hop *next;
	/* Indicateif this ia a loose or strict hop */
	bool is_loose;
	/* Indicate if there is an SID for the hop */
	bool has_sid;
	/* Indicate if the hop as a MPLS label */
	bool is_mpls;
	/* Indicate if the MPLS label has extra attributes (TTL, class..)*/
	bool has_attribs;
	/* Hop's SID if available */
	union sid sid;
	/* Indicate if there is a NAI for this hop */
	bool has_nai;
	/* NAI if available */
	struct nai nai;
};

struct path_metric {
	/* Pointer to the next metric */
	struct path_metric *next;
	/* The metric type */
	enum pcep_metric_types type;
	/* If the metric should be enforced */
	bool enforce;
	/* If the metric value is bound (a maximum) */
	bool is_bound;
	/* If the metric value is computed */
	bool is_computed;
	/* The metric value */
	float value;
};

struct path {
	/* Both the nbkey and the plspid are keys comming from the PCC,
	but the PCE is only using the plspid. The missing key is looked up by
	the PCC so we always have both */

	/* The northbound key identifying this path */
	struct lsp_nb_key nbkey;
	/* The generated unique PLSP identifier for this path.
	   See draft-ietf-pce-stateful-pce */
	uint32_t plsp_id;

	/* The transport address the path is comming from, PCE or PCC*/
	struct ipaddr sender;
	/* The pcc protocol address, must be the same family as the endpoint */
	struct ipaddr pcc_addr;

	/* The identifier of the PCC the path is for/from. If 0 it is undefined,
	meaning it hasn't be set yet or is for all the PCC */
	int pcc_id;

	/* The origin of the path creation */
	enum srte_protocol_origin create_origin;
	/* The origin of the path modification */
	enum srte_protocol_origin update_origin;
	/* The identifier of the entity that originated the path */
	const char *originator;
	/* The type of the path, for PCE initiated or updated path it is always
	SRTE_CANDIDATE_TYPE_DYNAMIC */
	enum srte_candidate_type type;

	/* The following data comes from either the PCC or the PCE if available
	 */

	/* Path's binding SID */
	mpls_label_t binding_sid;
	/* The name of the path */
	const char *name;
	/* The request identifier from the PCE, when getting a path from the
	   PCE. See draft-ietf-pce-stateful-pce */
	uint32_t srp_id;
	/* The request identifier from the PCC , when getting a path from the
	   PCE after a computation request. See rfc5440, section-7.4 */
	uint32_t req_id;
	/* The operational status of the path */
	enum pcep_lsp_operational_status status;
	/* If true, the receiver (PCC) must remove the path.
	   See draft-ietf-pce-pce-initiated-lsp */
	bool do_remove;
	/* Indicate the given path was removed by the PCC.
	   See draft-ietf-pce-stateful-pce, section-7.3, flag R */
	bool was_removed;
	/* Indicate the path is part of the synchronization process.
	   See draft-ietf-pce-stateful-pce, section-7.3, flag S */
	bool is_synching;
	/* Indicate if the path bandwidth requirment is defined */
	bool has_bandwidth;
	/* Indicate if the bandwidth requirment should be enforced */
	bool enforce_bandwidth;
	/* Path required bandwidth if defined */
	float bandwidth;
	/* Specify the list of hop defining the path */
	struct path_hop *first_hop;
	/* Specify the list of metrics */
	struct path_metric *first_metric;
	/* Indicate if the path has a PCC-defined objective function */
	bool has_pcc_objfun;
	/* Indicate the PCC-defined objective function is required */
	bool enforce_pcc_objfun;
	/* PCC-defined Objective Function */
	enum objfun_type pcc_objfun;
	/* Indicate if the path has a PCE-defined objective function */
	bool has_pce_objfun;
	/* PCE-defined Objective Function */
	enum objfun_type pce_objfun;
	/* Indicate if some affinity filters are defined */
	bool has_affinity_filters;
	/* Affinity attribute filters indexed by enum affinity_filter_type - 1
	 */
	uint32_t affinity_filters[MAX_AFFINITY_FILTER_TYPE];

	/* The following data need to be specialized for a given PCE */

	/* Indicate the path is delegated to the PCE.
	   See draft-ietf-pce-stateful-pce, section-7.3, flag D */
	bool is_delegated;
	/* Indicate if the PCE wants the path to get active.
	   See draft-ietf-pce-stateful-pce, section-7.3, flag A */
	bool go_active;
	/* Indicate the given path was created by the PCE,
	   See draft-ietf-pce-pce-initiated-lsp, section-5.3.1, flag C */
	bool was_created;

	/* The following data is defined for comnputation replies */

	/* Indicate that no path could be computed */
	bool no_path;
};

struct pcep_glob {
	struct debug dbg;
	struct thread_master *master;
	struct frr_pthread *fpt;
	uint8_t num_pce_opts_cli;
	struct pce_opts_cli *pce_opts_cli[MAX_PCE];
	uint8_t num_config_group_opts;
	struct pcep_config_group_opts *config_group_opts[MAX_PCE];
};

extern struct pcep_glob *pcep_g;

/* Path Helper Functions */
struct path *pcep_new_path(void);
struct path_hop *pcep_new_hop(void);
struct path_metric *pcep_new_metric(void);
struct path *pcep_copy_path(struct path *path);
void pcep_free_path(struct path *path);


#endif // _PATH_PCEP_H_
Commit	Line	Data
efba0985 SM	1	/*
	2	* Copyright (C) 2020 NetDEF, Inc.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License as published by the Free
	6	* Software Foundation; either version 2 of the License, or (at your option)
	7	* any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along
	15	* with this program; see the file COPYING; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#ifndef _PATH_PCEP_H_
	20	#define _PATH_PCEP_H_
	21
	22	#include <stdbool.h>
	23	#include <debug.h>
	24	#include <netinet/tcp.h>
c7479286	25	#include "memory.h"
74971473 JG	26	#include "pceplib/pcep_utils_logging.h"
74971473 JG	27	#include "pceplib/pcep_pcc_api.h"
efba0985 SM	28	#include "mpls.h"
efba0985 SM	29	#include "pathd/pathd.h"
c7479286 DL	30
c7479286 DL	31	DECLARE_MTYPE(PCEP);
efba0985 SM	32
	33	#define PCEP_DEFAULT_PORT 4189
	34	#define MAX_PCC 32
	35	#define MAX_PCE 32
	36	#define MAX_TAG_SIZE 50
	37	#define PCEP_DEBUG_MODE_BASIC 0x01
	38	#define PCEP_DEBUG_MODE_PATH 0x02
	39	#define PCEP_DEBUG_MODE_PCEP 0x04
	40	#define PCEP_DEBUG_MODE_PCEPLIB 0x08
	41	#define PCEP_DEBUG(fmt, ...) \
	42	do { \
	43	if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_BASIC)) \
	44	DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__); \
	45	} while (0)
	46	#define PCEP_DEBUG_PATH(fmt, ...) \
	47	do { \
	48	if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PATH)) \
	49	DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__); \
	50	} while (0)
	51	#define PCEP_DEBUG_PCEP(fmt, ...) \
	52	do { \
	53	if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEP)) \
	54	DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__); \
	55	} while (0)
	56	#define PCEP_DEBUG_PCEPLIB(priority, fmt, ...) \
	57	do { \
	58	switch (priority) { \
	59	case LOG_DEBUG: \
	60	if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, \
	61	PCEP_DEBUG_MODE_PCEPLIB)) \
	62	DEBUGD(&pcep_g->dbg, "pcep: " fmt, \
	63	##__VA_ARGS__); \
	64	break; \
	65	case LOG_INFO: \
	66	if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, \
	67	PCEP_DEBUG_MODE_PCEPLIB)) \
	68	DEBUGI(&pcep_g->dbg, "pcep: " fmt, \
	69	##__VA_ARGS__); \
	70	break; \
	71	case LOG_NOTICE: \
	72	if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, \
	73	PCEP_DEBUG_MODE_PCEPLIB)) \
	74	DEBUGN(&pcep_g->dbg, "pcep: " fmt, \
	75	##__VA_ARGS__); \
	76	break; \
	77	case LOG_WARNING: \
	78	case LOG_ERR: \
	79	default: \
	80	zlog(priority, "pcep: " fmt, ##__VA_ARGS__); \
	81	break; \
	82	} \
	83	} while (0)
	84
	85	struct pcep_config_group_opts {
	86	char name[64];
2a034138	87	char tcp_md5_auth[PCEP_MD5SIG_MAXKEYLEN];
efba0985 SM	88	struct ipaddr source_ip;
	89	short source_port;
	90	bool draft07;
	91	bool pce_initiated;
	92	int keep_alive_seconds;
	93	int min_keep_alive_seconds;
	94	int max_keep_alive_seconds;
	95	int dead_timer_seconds;
	96	int min_dead_timer_seconds;
	97	int max_dead_timer_seconds;
	98	int pcep_request_time_seconds;
	99	int session_timeout_inteval_seconds;
	100	int delegation_timeout_seconds;
	101	};
	102
	103	struct pce_opts {
	104	struct ipaddr addr;
	105	short port;
	106	char pce_name[64];
	107	struct pcep_config_group_opts config_opts;
	108	uint8_t precedence; /* Multi-PCE precedence */
	109	};
	110
	111	struct pcc_opts {
	112	struct ipaddr addr;
	113	short port;
	114	short msd;
	115	};
	116
	117	/* Encapsulate the pce_opts with needed CLI information */
	118	struct pce_opts_cli {
	119	struct pce_opts pce_opts;
	120	char config_group_name[64];
	121	/* These are the values configured in the pcc-peer sub-commands.
	122	* These need to be stored for later merging. Notice, it could
	123	* be that not all of them are set. */
	124	struct pcep_config_group_opts pce_config_group_opts;
	125	/* The pce_opts->config_opts will be a merge of the default values,
	126	* optional config_group values (which overwrite default values),
	127	* and any values configured in the pce sub-commands (which overwrite
	128	* both default and config_group values). This flag indicates of the
	129	* values need to be merged or not. */
	130	bool merged;
	131	};
	132
	133	struct lsp_nb_key {
	134	uint32_t color;
	135	struct ipaddr endpoint;
	136	uint32_t preference;
	137	};
	138
	139	struct sid_mpls {
	140	mpls_label_t label;
	141	uint8_t traffic_class;
	142	bool is_bottom;
	143	uint8_t ttl;
	144	};
	145
	146	struct pcep_caps {
	147	bool is_stateful;
	148	/* If we know the objective functions supported by the PCE.
	149	* If we don't know, it doesn't mean the PCE doesn't support any */
	150	bool supported_ofs_are_known;
	151	/* Defined if we know which objective funtions are supported by the PCE.
152	* One bit per objective function, the bit index being equal to
153	* enum pcep_objfun_type values: bit 0 is not used, bit 1 is
154	* PCEP_OBJFUN_MCP, up to bit 17 that is PCEP_OBJFUN_MSN */
155	uint32_t supported_ofs;
156	};
157
158	union sid {
159	uint32_t value;
160	struct sid_mpls mpls;
161	};
162
163	struct nai {
164	/* NAI type */
165	enum pcep_sr_subobj_nai type;
166	/* Local IP address*/
167	struct ipaddr local_addr;
168	/* Local interface identifier if the NAI is an unnumbered adjacency */
169	uint32_t local_iface;
170	/* Remote address if the NAI is an adjacency */
171	struct ipaddr remote_addr;
172	/* Remote interface identifier if the NAI is an unnumbered adjacency */
173	uint32_t remote_iface;
174	};
175
176	struct path_hop {
177	/* Pointer to the next hop in the path */
178	struct path_hop *next;
179	/* Indicateif this ia a loose or strict hop */
180	bool is_loose;
181	/* Indicate if there is an SID for the hop */
182	bool has_sid;
183	/* Indicate if the hop as a MPLS label */
184	bool is_mpls;
185	/* Indicate if the MPLS label has extra attributes (TTL, class..)*/
186	bool has_attribs;
187	/* Hop's SID if available */
188	union sid sid;
189	/* Indicate if there is a NAI for this hop */
190	bool has_nai;
191	/* NAI if available */
192	struct nai nai;
193	};
194
195	struct path_metric {
196	/* Pointer to the next metric */
197	struct path_metric *next;
198	/* The metric type */
199	enum pcep_metric_types type;
200	/* If the metric should be enforced */
201	bool enforce;
202	/* If the metric value is bound (a maximum) */
203	bool is_bound;
204	/* If the metric value is computed */
205	bool is_computed;
206	/* The metric value */
207	float value;
208	};
209
210	struct path {
211	/* Both the nbkey and the plspid are keys comming from the PCC,
212	but the PCE is only using the plspid. The missing key is looked up by
213	the PCC so we always have both */
214
215	/* The northbound key identifying this path */
216	struct lsp_nb_key nbkey;
217	/* The generated unique PLSP identifier for this path.
218	See draft-ietf-pce-stateful-pce */
219	uint32_t plsp_id;
220
221	/* The transport address the path is comming from, PCE or PCC*/
222	struct ipaddr sender;
223	/* The pcc protocol address, must be the same family as the endpoint */
224	struct ipaddr pcc_addr;
225
226	/* The identifier of the PCC the path is for/from. If 0 it is undefined,
227	meaning it hasn't be set yet or is for all the PCC */
228	int pcc_id;
229
230	/* The origin of the path creation */
231	enum srte_protocol_origin create_origin;
232	/* The origin of the path modification */
233	enum srte_protocol_origin update_origin;
234	/* The identifier of the entity that originated the path */
235	const char *originator;
236	/* The type of the path, for PCE initiated or updated path it is always
237	SRTE_CANDIDATE_TYPE_DYNAMIC */
238	enum srte_candidate_type type;
239
240	/* The following data comes from either the PCC or the PCE if available
241	*/
242
243	/* Path's binding SID */
244	mpls_label_t binding_sid;
245	/* The name of the path */
246	const char *name;
247	/* The request identifier from the PCE, when getting a path from the
248	PCE. See draft-ietf-pce-stateful-pce */
249	uint32_t srp_id;
250	/* The request identifier from the PCC , when getting a path from the
251	PCE after a computation request. See rfc5440, section-7.4 */
252	uint32_t req_id;
253	/* The operational status of the path */
254	enum pcep_lsp_operational_status status;
255	/* If true, the receiver (PCC) must remove the path.
256	See draft-ietf-pce-pce-initiated-lsp */
257	bool do_remove;
258	/* Indicate the given path was removed by the PCC.
259	See draft-ietf-pce-stateful-pce, section-7.3, flag R */
260	bool was_removed;
261	/* Indicate the path is part of the synchronization process.
262	See draft-ietf-pce-stateful-pce, section-7.3, flag S */
263	bool is_synching;
264	/* Indicate if the path bandwidth requirment is defined */
265	bool has_bandwidth;
266	/* Indicate if the bandwidth requirment should be enforced */
267	bool enforce_bandwidth;
268	/* Path required bandwidth if defined */
269	float bandwidth;
270	/* Specify the list of hop defining the path */
271	struct path_hop *first_hop;
272	/* Specify the list of metrics */
273	struct path_metric *first_metric;
274	/* Indicate if the path has a PCC-defined objective function */
275	bool has_pcc_objfun;
276	/* Indicate the PCC-defined objective function is required */
277	bool enforce_pcc_objfun;
278	/* PCC-defined Objective Function */
279	enum objfun_type pcc_objfun;
280	/* Indicate if the path has a PCE-defined objective function */
281	bool has_pce_objfun;
282	/* PCE-defined Objective Function */
283	enum objfun_type pce_objfun;
284	/* Indicate if some affinity filters are defined */
285	bool has_affinity_filters;
286	/* Affinity attribute filters indexed by enum affinity_filter_type - 1
287	*/
288	uint32_t affinity_filters[MAX_AFFINITY_FILTER_TYPE];
289
290	/* The following data need to be specialized for a given PCE */
291
292	/* Indicate the path is delegated to the PCE.
293	See draft-ietf-pce-stateful-pce, section-7.3, flag D */
294	bool is_delegated;
295	/* Indicate if the PCE wants the path to get active.
296	See draft-ietf-pce-stateful-pce, section-7.3, flag A */
297	bool go_active;
298	/* Indicate the given path was created by the PCE,
299	See draft-ietf-pce-pce-initiated-lsp, section-5.3.1, flag C */
300	bool was_created;
301
302	/* The following data is defined for comnputation replies */
303
304	/* Indicate that no path could be computed */
305	bool no_path;
306	};
307
308	struct pcep_glob {
309	struct debug dbg;
310	struct thread_master *master;
311	struct frr_pthread *fpt;
312	uint8_t num_pce_opts_cli;
313	struct pce_opts_cli *pce_opts_cli[MAX_PCE];
314	uint8_t num_config_group_opts;
315	struct pcep_config_group_opts *config_group_opts[MAX_PCE];
316	};
317
318	extern struct pcep_glob *pcep_g;
319
320	/* Path Helper Functions */
321	struct path *pcep_new_path(void);
322	struct path_hop *pcep_new_hop(void);
323	struct path_metric *pcep_new_metric(void);
324	struct path pcep_copy_path(struct path path);
325	void pcep_free_path(struct path *path);
326
327
328	#endif // _PATH_PCEP_H_