]> git.proxmox.com Git - mirror_frr.git/blob - pathd/path_pcep_debug.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #8598 from idryzhov/fix-topotest-bgp-auth
[mirror_frr.git] / pathd / path_pcep_debug.c
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 #include <zebra.h>
20
21 #include <string.h>
22 #include <stdbool.h>
23 #include <time.h>
24 #include <libyang/libyang.h>
25
26 #include "printfrr.h"
27 #include "ipaddr.h"
28
29 #include "pathd/path_pcep_debug.h"
30
31 static void _format_pcc_opts(int ps, struct pcc_opts *ops);
32 static void _format_pce_opts(int ps, struct pce_opts *ops);
33 static void _format_pcc_caps(int ps, struct pcep_caps *caps);
34 static void _format_pcc_state(int ps, struct pcc_state *state);
35 static void _format_ctrl_state(int ps, struct ctrl_state *state);
36 static void _format_path(int ps, struct path *path);
37 static void _format_path_hop(int ps, struct path_hop *hop);
38 static void _format_path_metric(int ps, struct path_metric *metric);
39 static void _format_pcep_event(int ps, pcep_event *event);
40 static void _format_pcep_message(int ps, struct pcep_message *msg);
41 static void _format_pcep_objects(int ps, double_linked_list *objs);
42 static void _format_pcep_object(int ps, struct pcep_object_header *obj);
43 static void _format_pcep_object_details(int ps, struct pcep_object_header *obj);
44 static void _format_pcep_object_error(int ps, struct pcep_object_error *obj);
45 static void _format_pcep_object_open(int ps, struct pcep_object_open *obj);
46 static void _format_pcep_object_rp(int ps, struct pcep_object_rp *obj);
47 static void _format_pcep_object_srp(int ps, struct pcep_object_srp *obj);
48 static void _format_pcep_object_lsp(int psps, struct pcep_object_lsp *obj);
49 static void _format_pcep_object_lspa(int psps, struct pcep_object_lspa *obj);
50 static void
51 _format_pcep_object_ipv4_endpoint(int ps,
52 struct pcep_object_endpoints_ipv4 *obj);
53 static void _format_pcep_object_metric(int ps, struct pcep_object_metric *obj);
54 static void _format_pcep_object_bandwidth(int ps,
55 struct pcep_object_bandwidth *obj);
56 static void _format_pcep_object_nopath(int ps, struct pcep_object_nopath *obj);
57 static void
58 _format_pcep_object_objfun(int ps, struct pcep_object_objective_function *obj);
59 static void _format_pcep_object_ro(int ps, struct pcep_object_ro *obj);
60 static void _format_pcep_object_ro_details(int ps,
61 struct pcep_object_ro_subobj *ro);
62 static void _format_pcep_object_ro_ipv4(int ps,
63 struct pcep_ro_subobj_ipv4 *obj);
64 static void _format_pcep_object_ro_sr(int ps, struct pcep_ro_subobj_sr *obj);
65 static void _format_pcep_object_tlvs(int ps, struct pcep_object_header *obj);
66 static void _format_pcep_object_tlv(int ps,
67 struct pcep_object_tlv_header *tlv_header);
68 static void
69 _format_pcep_object_tlv_details(int ps,
70 struct pcep_object_tlv_header *tlv_header);
71 static void _format_pcep_object_tlv_symbolic_path_name(
72 int ps, struct pcep_object_tlv_symbolic_path_name *tlv);
73 static void _format_pcep_object_tlv_stateful_pce_capability(
74 int ps, struct pcep_object_tlv_stateful_pce_capability *tlv);
75 static void _format_pcep_object_tlv_sr_pce_capability(
76 int ps, struct pcep_object_tlv_sr_pce_capability *tlv);
77 static void _format_pcep_object_tlv_path_setup_type(
78 int ps, struct pcep_object_tlv_path_setup_type *tlv);
79
80 const char *pcc_status_name(enum pcc_status status)
81 {
82 switch (status) {
83 case PCEP_PCC_INITIALIZED:
84 return "INITIALIZED";
85 case PCEP_PCC_DISCONNECTED:
86 return "DISCONNECTED";
87 case PCEP_PCC_CONNECTING:
88 return "CONNECTING";
89 case PCEP_PCC_SYNCHRONIZING:
90 return "SYNCHRONIZING";
91 case PCEP_PCC_OPERATING:
92 return "OPERATING";
93 default:
94 return "UNKNOWN";
95 }
96 }
97
98 const char *pcep_event_type_name(pcep_event_type event_type)
99 {
100 switch (event_type) {
101 case MESSAGE_RECEIVED:
102 return "MESSAGE_RECEIVED";
103 case PCE_CLOSED_SOCKET:
104 return "PCE_CLOSED_SOCKET";
105 case PCE_SENT_PCEP_CLOSE:
106 return "PCE_SENT_PCEP_CLOSE";
107 case PCE_DEAD_TIMER_EXPIRED:
108 return "PCE_DEAD_TIMER_EXPIRED";
109 case PCE_OPEN_KEEP_WAIT_TIMER_EXPIRED:
110 return "PCE_OPEN_KEEP_WAIT_TIMER_EXPIRED";
111 case PCC_CONNECTED_TO_PCE:
112 return "PCC_CONNECTED_TO_PCE";
113 case PCC_PCEP_SESSION_CLOSED:
114 return "PCC_PCEP_SESSION_CLOSED";
115 case PCC_RCVD_INVALID_OPEN:
116 return "PCC_RCVD_INVALID_OPEN";
117 case PCC_RCVD_MAX_INVALID_MSGS:
118 return "PCC_RCVD_MAX_INVALID_MSGS";
119 case PCC_RCVD_MAX_UNKOWN_MSGS:
120 return "PCC_RCVD_MAX_UNKOWN_MSGS";
121 default:
122 return "UNKNOWN";
123 }
124 }
125
126 const char *pcep_error_type_name(enum pcep_error_type error_type)
127 {
128 switch (error_type) {
129
130 case PCEP_ERRT_SESSION_FAILURE:
131 return "SESSION_FAILURE";
132 case PCEP_ERRT_CAPABILITY_NOT_SUPPORTED:
133 return "CAPABILITY_NOT_SUPPORTED";
134 case PCEP_ERRT_UNKNOW_OBJECT:
135 return "UNKNOW_OBJECT";
136 case PCEP_ERRT_NOT_SUPPORTED_OBJECT:
137 return "NOT_SUPPORTED_OBJECT";
138 case PCEP_ERRT_POLICY_VIOLATION:
139 return "POLICY_VIOLATION";
140 case PCEP_ERRT_MANDATORY_OBJECT_MISSING:
141 return "MANDATORY_OBJECT_MISSING";
142 case PCEP_ERRT_SYNC_PC_REQ_MISSING:
143 return "SYNC_PC_REQ_MISSING";
144 case PCEP_ERRT_UNKNOWN_REQ_REF:
145 return "UNKNOWN_REQ_REF";
146 case PCEP_ERRT_ATTEMPT_TO_ESTABLISH_2ND_PCEP_SESSION:
147 return "ATTEMPT_TO_ESTABLISH_2ND_PCEP_SESSION";
148 case PCEP_ERRT_RECEPTION_OF_INV_OBJECT:
149 return "RECEPTION_OF_INV_OBJECT";
150 case PCEP_ERRT_UNRECOGNIZED_EXRS_SUBOBJ:
151 return "UNRECOGNIZED_EXRS_SUBOBJ";
152 case PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR:
153 return "DIFFSERV_AWARE_TE_ERROR";
154 case PCEP_ERRT_BRPC_PROC_COMPLETION_ERROR:
155 return "BRPC_PROC_COMPLETION_ERROR";
156 case PCEP_ERRT_UNASSIGNED14:
157 return "UNASSIGNED14";
158 case PCEP_ERRT_GLOBAL_CONCURRENT_ERROR:
159 return "GLOBAL_CONCURRENT_ERROR";
160 case PCEP_ERRT_P2PMP_CAP_ERROR:
161 return "P2PMP_CAP_ERROR";
162 case PCEP_ERRT_P2P_ENDPOINTS_ERROR:
163 return "P2P_ENDPOINTS_ERROR";
164 case PCEP_ERRT_P2P_FRAGMENTATION_ERROR:
165 return "P2P_FRAGMENTATION_ERROR";
166 case PCEP_ERRT_INVALID_OPERATION:
167 return "INVALID_OPERATION";
168 case PCEP_ERRT_LSP_STATE_SYNC_ERROR:
169 return "LSP_STATE_SYNC_ERROR";
170 case PCEP_ERRT_INVALID_TE_PATH_SETUP_TYPE:
171 return "INVALID_TE_PATH_SETUP_TYPE";
172 case PCEP_ERRT_UNASSIGNED22:
173 return "UNASSIGNED22";
174 case PCEP_ERRT_BAD_PARAMETER_VALUE:
175 return "BAD_PARAMETER_VALUE";
176 case PCEP_ERRT_LSP_INSTANTIATE_ERROR:
177 return "LSP_INSTANTIATE_ERROR";
178 case PCEP_ERRT_START_TLS_FAILURE:
179 return "START_TLS_FAILURE";
180 case PCEP_ERRT_ASSOCIATION_ERROR:
181 return "ASSOCIATION_ERROR";
182 case PCEP_ERRT_WSON_RWA_ERROR:
183 return "WSON_RWA_ERROR";
184 case PCEP_ERRT_H_PCE_ERROR:
185 return "H_PCE_ERROR";
186 case PCEP_ERRT_PATH_COMP_FAILURE:
187 return "PATH_COMP_FAILURE";
188 case PCEP_ERRT_UNASSIGNED30:
189 return "UNASSIGNED30";
190 default:
191 return "UNKNOWN";
192 }
193 }
194
195 const char *pcep_error_value_name(enum pcep_error_type error_type,
196 enum pcep_error_value error_value)
197 {
198 switch (TUP(error_type, error_value)) {
199
200 case TUP(PCEP_ERRT_CAPABILITY_NOT_SUPPORTED, PCEP_ERRV_UNASSIGNED):
201 case TUP(PCEP_ERRT_SYNC_PC_REQ_MISSING, PCEP_ERRV_UNASSIGNED):
202 case TUP(PCEP_ERRT_UNKNOWN_REQ_REF, PCEP_ERRV_UNASSIGNED):
203 case TUP(PCEP_ERRT_ATTEMPT_TO_ESTABLISH_2ND_PCEP_SESSION,
204 PCEP_ERRV_UNASSIGNED):
205 case TUP(PCEP_ERRT_UNRECOGNIZED_EXRS_SUBOBJ, PCEP_ERRV_UNASSIGNED):
206 return "UNASSIGNED";
207
208 case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_RECVD_INVALID_OPEN_MSG):
209 return "RECVD_INVALID_OPEN_MSG";
210 case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_OPENWAIT_TIMED_OUT):
211 return "OPENWAIT_TIMED_OUT";
212 case TUP(PCEP_ERRT_SESSION_FAILURE,
213 PCEP_ERRV_UNACCEPTABLE_OPEN_MSG_NO_NEG):
214 return "UNACCEPTABLE_OPEN_MSG_NO_NEG";
215 case TUP(PCEP_ERRT_SESSION_FAILURE,
216 PCEP_ERRV_UNACCEPTABLE_OPEN_MSG_NEG):
217 return "UNACCEPTABLE_OPEN_MSG_NEG";
218 case TUP(PCEP_ERRT_SESSION_FAILURE,
219 PCEP_ERRV_RECVD_SECOND_OPEN_MSG_UNACCEPTABLE):
220 return "RECVD_SECOND_OPEN_MSG_UNACCEPTABLE";
221 case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_RECVD_PCERR):
222 return "RECVD_PCERR";
223 case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_KEEPALIVEWAIT_TIMED_OUT):
224 return "KEEPALIVEWAIT_TIMED_OUT";
225 case TUP(PCEP_ERRT_SESSION_FAILURE,
226 PCEP_ERRV_PCEP_VERSION_NOT_SUPPORTED):
227 return "PCEP_VERSION_NOT_SUPPORTED";
228
229 case TUP(PCEP_ERRT_UNKNOW_OBJECT, PCEP_ERRV_UNREC_OBJECT_CLASS):
230 return "UNREC_OBJECT_CLASS";
231 case TUP(PCEP_ERRT_UNKNOW_OBJECT, PCEP_ERRV_UNREC_OBJECT_TYPE):
232 return "UNREC_OBJECT_TYPE";
233
234 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
235 PCEP_ERRV_NOT_SUPPORTED_OBJECT_CLASS):
236 return "NOT_SUPPORTED_OBJECT_CLASS";
237 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
238 PCEP_ERRV_NOT_SUPPORTED_OBJECT_TYPE):
239 return "NOT_SUPPORTED_OBJECT_TYPE";
240 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT, PCEP_ERRV_UNSUPPORTED_PARAM):
241 return "UNSUPPORTED_PARAM";
242 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
243 PCEP_ERRV_UNSUPPORTED_NW_PERF_CONSTRAINT):
244 return "UNSUPPORTED_NW_PERF_CONSTRAINT";
245 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
246 PCEP_ERRV_NOT_SUPPORTED_BW_OBJECT_3_4):
247 return "NOT_SUPPORTED_BW_OBJECT_3_4";
248 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
249 PCEP_ERRV_UNSUPPORTED_ENDPOINT_TYPE):
250 return "UNSUPPORTED_ENDPOINT_TYPE";
251 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
252 PCEP_ERRV_UNSUPPORTED_ENDPOINT_TLV):
253 return "UNSUPPORTED_ENDPOINT_TLV";
254 case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
255 PCEP_ERRV_UNSUPPORTED_RP_FLAG_GRANULARITY):
256 return "UNSUPPORTED_RP_FLAG_GRANULARITY";
257
258 case TUP(PCEP_ERRT_POLICY_VIOLATION,
259 PCEP_ERRV_C_BIT_SET_IN_METRIC_OBJECT):
260 return "C_BIT_SET_IN_METRIC_OBJECT";
261 case TUP(PCEP_ERRT_POLICY_VIOLATION,
262 PCEP_ERRV_O_BIT_CLEARD_IN_RP_OBJECT):
263 return "O_BIT_CLEARD_IN_RP_OBJECT";
264 case TUP(PCEP_ERRT_POLICY_VIOLATION,
265 PCEP_ERRV_OBJECTIVE_FUNC_NOT_ALLOWED):
266 return "OBJECTIVE_FUNC_NOT_ALLOWED";
267 case TUP(PCEP_ERRT_POLICY_VIOLATION, PCEP_ERRV_RP_OF_BIT_SET):
268 return "RP_OF_BIT_SET";
269 case TUP(PCEP_ERRT_POLICY_VIOLATION,
270 PCEP_ERRV_GLOBAL_CONCURRENCY_NOT_ALLOWED):
271 return "GLOBAL_CONCURRENCY_NOT_ALLOWED";
272 case TUP(PCEP_ERRT_POLICY_VIOLATION, PCEP_ERRV_MONITORING_MSG_REJECTED):
273 return "MONITORING_MSG_REJECTED";
274 case TUP(PCEP_ERRT_POLICY_VIOLATION,
275 PCEP_ERRV_P2MP_PATH_COMP_NOT_ALLOWED):
276 return "P2MP_PATH_COMP_NOT_ALLOWED";
277 case TUP(PCEP_ERRT_POLICY_VIOLATION,
278 PCEP_ERRV_UNALLOWED_NW_PERF_CONSTRAINT):
279 return "UNALLOWED_NW_PERF_CONSTRAINT";
280
281 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
282 PCEP_ERRV_RP_OBJECT_MISSING):
283 return "RP_OBJECT_MISSING";
284 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
285 PCEP_ERRV_RRO_OBJECT_MISSING_FOR_REOP):
286 return "RRO_OBJECT_MISSING_FOR_REOP";
287 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
288 PCEP_ERRV_EP_OBJECT_MISSING):
289 return "EP_OBJECT_MISSING";
290 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
291 PCEP_ERRV_MONITOR_OBJECT_MISSING):
292 return "MONITOR_OBJECT_MISSING";
293 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
294 PCEP_ERRV_LSP_OBJECT_MISSING):
295 return "LSP_OBJECT_MISSING";
296 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
297 PCEP_ERRV_ERO_OBJECT_MISSING):
298 return "ERO_OBJECT_MISSING";
299 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
300 PCEP_ERRV_SRP_OBJECT_MISSING):
301 return "SRP_OBJECT_MISSING";
302 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
303 PCEP_ERRV_LSP_ID_TLV_MISSING):
304 return "LSP_ID_TLV_MISSING";
305 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
306 PCEP_ERRV_LSP_DB_TLV_MISSING):
307 return "LSP_DB_TLV_MISSING";
308 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
309 PCEP_ERRV_S2LS_OBJECT_MISSING):
310 return "S2LS_OBJECT_MISSING";
311 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
312 PCEP_ERRV_P2MP_LSP_ID_TLV_MISSING):
313 return "P2MP_LSP_ID_TLV_MISSING";
314 case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
315 PCEP_ERRV_DISJOINTED_CONF_TLV_MISSING):
316 return "DISJOINTED_CONF_TLV_MISSING";
317
318 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
319 PCEP_ERRV_P_FLAG_NOT_CORRECT_IN_OBJECT):
320 return "P_FLAG_NOT_CORRECT_IN_OBJECT";
321 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_BAD_LABEL_VALUE):
322 return "BAD_LABEL_VALUE";
323 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
324 PCEP_ERRV_UNSUPPORTED_NUM_SR_ERO_SUBOBJECTS):
325 return "UNSUPPORTED_NUM_SR_ERO_SUBOBJECTS";
326 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_BAD_LABEL_FORMAT):
327 return "BAD_LABEL_FORMAT";
328 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_ERO_SR_ERO_MIX):
329 return "ERO_SR_ERO_MIX";
330 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
331 PCEP_ERRV_SR_ERO_SID_NAI_ABSENT):
332 return "SR_ERO_SID_NAI_ABSENT";
333 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
334 PCEP_ERRV_SR_RRO_SID_NAI_ABSENT):
335 return "SR_RRO_SID_NAI_ABSENT";
336 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
337 PCEP_ERRV_SYMBOLIC_PATH_NAME_TLV_MISSING):
338 return "SYMBOLIC_PATH_NAME_TLV_MISSING";
339 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
340 PCEP_ERRV_MSD_EXCEEDS_PCEP_SESSION_MAX):
341 return "MSD_EXCEEDS_PCEP_SESSION_MAX";
342 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_RRO_SR_RRO_MIX):
343 return "RRO_SR_RRO_MIX";
344 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_MALFORMED_OBJECT):
345 return "MALFORMED_OBJECT";
346 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
347 PCEP_ERRV_MISSING_PCE_SR_CAP_TLV):
348 return "MISSING_PCE_SR_CAP_TLV";
349 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_UNSUPPORTED_NAI):
350 return "UNSUPPORTED_NAI";
351 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_UNKNOWN_SID):
352 return "UNKNOWN_SID";
353 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
354 PCEP_ERRV_CANNOT_RESOLVE_NAI_TO_SID):
355 return "CANNOT_RESOLVE_NAI_TO_SID";
356 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
357 PCEP_ERRV_COULD_NOT_FIND_SRGB):
358 return "COULD_NOT_FIND_SRGB";
359 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_SID_EXCEEDS_SRGB):
360 return "SID_EXCEEDS_SRGB";
361 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
362 PCEP_ERRV_COULD_NOT_FIND_SRLB):
363 return "COULD_NOT_FIND_SRLB";
364 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_SID_EXCEEDS_SRLB):
365 return "SID_EXCEEDS_SRLB";
366 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_INCONSISTENT_SID):
367 return "INCONSISTENT_SID";
368 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
369 PCEP_ERRV_MSD_MUST_BE_NONZERO):
370 return "MSD_MUST_BE_NONZERO";
371 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
372 PCEP_ERRV_MISMATCH_O_S2LS_LSP):
373 return "MISMATCH_O_S2LS_LSP";
374 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
375 PCEP_ERRV_INCOMPATIBLE_H_PCE_OF):
376 return "INCOMPATIBLE_H_PCE_OF";
377 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
378 PCEP_ERRV_BAD_BANDWIDTH_TYPE_3_4):
379 return "BAD_BANDWIDTH_TYPE_3_4";
380 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
381 PCEP_ERRV_UNSUPPORTED_LSP_PROT_FLAGS):
382 return "UNSUPPORTED_LSP_PROT_FLAGS";
383 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
384 PCEP_ERRV_UNSUPPORTED_2ND_LSP_PROT_FLAGS):
385 return "UNSUPPORTED_2ND_LSP_PROT_FLAGS";
386 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
387 PCEP_ERRV_UNSUPPORTED_LINK_PROT_TYPE):
388 return "UNSUPPORTED_LINK_PROT_TYPE";
389 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
390 PCEP_ERRV_LABEL_SET_TLV_NO_RP_R):
391 return "LABEL_SET_TLV_NO_RP_R";
392 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
393 PCEP_ERRV_WRONG_LABEL_SET_TLV_O_L_SET):
394 return "WRONG_LABEL_SET_TLV_O_L_SET";
395 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
396 PCEP_ERRV_WRONG_LABEL_SET_O_SET):
397 return "WRONG_LABEL_SET_O_SET";
398 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
399 PCEP_ERRV_MISSING_GMPLS_CAP_TLV):
400 return "MISSING_GMPLS_CAP_TLV";
401 case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
402 PCEP_ERRV_INCOMPATIBLE_OF_CODE):
403 return "INCOMPATIBLE_OF_CODE";
404
405 case TUP(PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR,
406 PCEP_ERRV_UNSUPPORTED_CLASS_TYPE):
407 return "UNSUPPORTED_CLASS_TYPE";
408 case TUP(PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR,
409 PCEP_ERRV_INVALID_CLASS_TYPE):
410 return "INVALID_CLASS_TYPE";
411 case TUP(PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR,
412 PCEP_ERRV_CLASS_SETUP_TYPE_NOT_TE_CLASS):
413 return "CLASS_SETUP_TYPE_NOT_TE_CLASS";
414
415 case TUP(PCEP_ERRT_BRPC_PROC_COMPLETION_ERROR,
416 PCEP_ERRV_BRPC_PROC_NOT_SUPPORTED):
417 return "BRPC_PROC_NOT_SUPPORTED";
418
419 case TUP(PCEP_ERRT_GLOBAL_CONCURRENT_ERROR,
420 PCEP_ERRV_INSUFFICIENT_MEMORY):
421 return "INSUFFICIENT_MEMORY";
422 case TUP(PCEP_ERRT_GLOBAL_CONCURRENT_ERROR,
423 PCEP_ERRV_GLOBAL_CONCURRENT_OPT_NOT_SUPPORTED):
424 return "GLOBAL_CONCURRENT_OPT_NOT_SUPPORTED";
425
426 case TUP(PCEP_ERRT_P2PMP_CAP_ERROR, PCEP_ERRV_PCE_INSUFFICIENT_MEMORY):
427 return "PCE_INSUFFICIENT_MEMORY";
428 case TUP(PCEP_ERRT_P2PMP_CAP_ERROR,
429 PCEP_ERRV_PCE_NOT_CAPABLE_P2MP_COMP):
430 return "PCE_NOT_CAPABLE_P2MP_COMP";
431
432 case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR,
433 PCEP_ERRV_NO_EP_WITH_LEAF_TYPE2):
434 return "NO_EP_WITH_LEAF_TYPE2";
435 case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR,
436 PCEP_ERRV_NO_EP_WITH_LEAF_TYPE3):
437 return "NO_EP_WITH_LEAF_TYPE3";
438 case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR,
439 PCEP_ERRV_NO_EP_WITH_LEAF_TYPE4):
440 return "NO_EP_WITH_LEAF_TYPE4";
441 case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR, PCEP_ERRV_INCONSITENT_EP):
442 return "INCONSITENT_EP";
443
444 case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
445 PCEP_ERRV_FRAG_REQUEST_FAILURE):
446 return "FRAG_REQUEST_FAILURE";
447 case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
448 PCEP_ERRV_FRAG_REPORT_FAILURE):
449 return "FRAG_REPORT_FAILURE";
450 case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
451 PCEP_ERRV_FRAG_UPDATE_FAILURE):
452 return "FRAG_UPDATE_FAILURE";
453 case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
454 PCEP_ERRV_FRAG_INSTANTIATION_FAILURE):
455 return "FRAG_INSTANTIATION_FAILURE";
456
457 case TUP(PCEP_ERRT_INVALID_OPERATION,
458 PCEP_ERRV_LSP_UPDATE_FOR_NON_DELEGATED_LSP):
459 return "LSP_UPDATE_FOR_NON_DELEGATED_LS";
460 case TUP(PCEP_ERRT_INVALID_OPERATION,
461 PCEP_ERRV_LSP_UPDATE_NON_ADVERTISED_PCE):
462 return "LSP_UPDATE_NON_ADVERTISED_PC";
463 case TUP(PCEP_ERRT_INVALID_OPERATION,
464 PCEP_ERRV_LSP_UPDATE_UNKNOWN_PLSP_ID):
465 return "LSP_UPDATE_UNKNOWN_PLSP_I";
466 case TUP(PCEP_ERRT_INVALID_OPERATION,
467 PCEP_ERRV_LSP_REPORT_NON_ADVERTISED_PCE):
468 return "LSP_REPORT_NON_ADVERTISED_PC";
469 case TUP(PCEP_ERRT_INVALID_OPERATION,
470 PCEP_ERRV_PCE_INIT_LSP_LIMIT_REACHED):
471 return "PCE_INIT_LSP_LIMIT_REACHE";
472 case TUP(PCEP_ERRT_INVALID_OPERATION,
473 PCEP_ERRV_PCE_INIT_LSP_DELEGATION_CANT_REVOKE):
474 return "PCE_INIT_LSP_DELEGATION_CANT_REVOK";
475 case TUP(PCEP_ERRT_INVALID_OPERATION,
476 PCEP_ERRV_LSP_INIT_NON_ZERO_PLSP_ID):
477 return "LSP_INIT_NON_ZERO_PLSP_I";
478 case TUP(PCEP_ERRT_INVALID_OPERATION, PCEP_ERRV_LSP_NOT_PCE_INITIATED):
479 return "LSP_NOT_PCE_INITIATE";
480 case TUP(PCEP_ERRT_INVALID_OPERATION,
481 PCEP_ERRV_PCE_INIT_OP_FREQ_LIMIT_REACHED):
482 return "PCE_INIT_OP_FREQ_LIMIT_REACHE";
483 case TUP(PCEP_ERRT_INVALID_OPERATION,
484 PCEP_ERRV_LSP_REPORT_P2MP_NOT_ADVERTISED):
485 return "LSP_REPORT_P2MP_NOT_ADVERTISE";
486 case TUP(PCEP_ERRT_INVALID_OPERATION,
487 PCEP_ERRV_LSP_UPDATE_P2MP_NOT_ADVERTISED):
488 return "LSP_UPDATE_P2MP_NOT_ADVERTISE";
489 case TUP(PCEP_ERRT_INVALID_OPERATION,
490 PCEP_ERRV_LSP_INSTANTIATION_P2MP_NOT_ADVERTISED):
491 return "LSP_INSTANTIATION_P2MP_NOT_ADVERTISE";
492 case TUP(PCEP_ERRT_INVALID_OPERATION,
493 PCEP_ERRV_AUTO_BW_CAP_NOT_ADVERTISED):
494 return "AUTO_BW_CAP_NOT_ADVERTISE";
495
496 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
497 PCEP_ERRV_PCE_CANT_PROCESS_LSP_REPORT):
498 return "PCE_CANT_PROCESS_LSP_REPORT";
499 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
500 PCEP_ERRV_LSP_DB_VERSION_MISMATCH):
501 return "LSP_DB_VERSION_MISMATCH";
502 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
503 PCEP_ERRV_TRIGGER_ATTEMPT_BEFORE_PCE_TRIGGER):
504 return "TRIGGER_ATTEMPT_BEFORE_PCE_TRIGGER";
505 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
506 PCEP_ERRV_TRIGGER_ATTEMPT_NO_PCE_TRIGGER_CAP):
507 return "TRIGGER_ATTEMPT_NO_PCE_TRIGGER_CAP";
508 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
509 PCEP_ERRV_PCC_CANT_COMPLETE_STATE_SYNC):
510 return "PCC_CANT_COMPLETE_STATE_SYNC";
511 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
512 PCEP_ERRV_INVALID_LSP_DB_VERSION_NUMBER):
513 return "INVALID_LSP_DB_VERSION_NUMBER";
514 case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
515 PCEP_ERRV_INVALID_SPEAKER_ENTITY_ID):
516 return "INVALID_SPEAKER_ENTITY_ID";
517
518 case TUP(PCEP_ERRT_INVALID_TE_PATH_SETUP_TYPE,
519 PCEP_ERRV_UNSUPPORTED_PATH_SETUP_TYPE):
520 return "UNSUPPORTED_PATH_SETUP_TYPE";
521 case TUP(PCEP_ERRT_INVALID_TE_PATH_SETUP_TYPE,
522 PCEP_ERRV_MISMATCHED_PATH_SETUP_TYPE):
523 return "MISMATCHED_PATH_SETUP_TYPE";
524
525 case TUP(PCEP_ERRT_BAD_PARAMETER_VALUE,
526 PCEP_ERRV_SYMBOLIC_PATH_NAME_IN_USE):
527 return "SYMBOLIC_PATH_NAME_IN_USE";
528 case TUP(PCEP_ERRT_BAD_PARAMETER_VALUE,
529 PCEP_ERRV_LSP_SPEAKER_ID_NOT_PCE_INITIATED):
530 return "LSP_SPEAKER_ID_NOT_PCE_INITIATED";
531
532 case TUP(PCEP_ERRT_LSP_INSTANTIATE_ERROR,
533 PCEP_ERRV_UNACCEPTABLE_INSTANTIATE_ERROR):
534 return "UNACCEPTABLE_INSTANTIATE_ERROR";
535 case TUP(PCEP_ERRT_LSP_INSTANTIATE_ERROR, PCEP_ERRV_INTERNAL_ERROR):
536 return "INTERNAL_ERROR";
537 case TUP(PCEP_ERRT_LSP_INSTANTIATE_ERROR, PCEP_ERRV_SIGNALLING_ERROR):
538 return "SIGNALLING_ERROR";
539
540 case TUP(PCEP_ERRT_START_TLS_FAILURE,
541 PCEP_ERRV_START_TLS_AFTER_PCEP_EXCHANGE):
542 return "START_TLS_AFTER_PCEP_EXCHANGE";
543 case TUP(PCEP_ERRT_START_TLS_FAILURE,
544 PCEP_ERRV_MSG_NOT_START_TLS_OPEN_ERROR):
545 return "MSG_NOT_START_TLS_OPEN_ERROR";
546 case TUP(PCEP_ERRT_START_TLS_FAILURE,
547 PCEP_ERRV_CONNECTION_WO_TLS_NOT_POSSIBLE):
548 return "CONNECTION_WO_TLS_NOT_POSSIBLE";
549 case TUP(PCEP_ERRT_START_TLS_FAILURE,
550 PCEP_ERRV_CONNECTION_WO_TLS_IS_POSSIBLE):
551 return "CONNECTION_WO_TLS_IS_POSSIBLE";
552 case TUP(PCEP_ERRT_START_TLS_FAILURE,
553 PCEP_ERRV_NO_START_TLS_BEFORE_START_TLS_WAIT_TIMER):
554 return "NO_START_TLS_BEFORE_START_TLS_WAIT_TIMER";
555
556 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
557 PCEP_ERRV_ASSOC_TYPE_NOT_SUPPORTED):
558 return "ASSOC_TYPE_NOT_SUPPORTED";
559 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
560 PCEP_ERRV_TOO_MANY_LSPS_IN_ASSOC_GRP):
561 return "TOO_MANY_LSPS_IN_ASSOC_GRP";
562 case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_TOO_MANY_ASSOC_GROUPS):
563 return "TOO_MANY_ASSOC_GROUPS";
564 case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_ASSOCIATION_UNKNOWN):
565 return "ASSOCIATION_UNKNOWN";
566 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
567 PCEP_ERRV_OP_CONF_ASSOC_INFO_MISMATCH):
568 return "OP_CONF_ASSOC_INFO_MISMATCH";
569 case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_ASSOC_INFO_MISMATCH):
570 return "ASSOC_INFO_MISMATCH";
571 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
572 PCEP_ERRV_CANNOT_JOIN_ASSOC_GROUP):
573 return "CANNOT_JOIN_ASSOC_GROUP";
574 case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_ASSOC_ID_NOT_IN_RANGE):
575 return "ASSOC_ID_NOT_IN_RANGE";
576 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
577 PCEP_ERRV_TUNNEL_EP_MISMATCH_PATH_PROT_ASSOC):
578 return "TUNNEL_EP_MISMATCH_PATH_PROT_ASSOC";
579 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
580 PCEP_ERRV_ATTEMPTED_ADD_LSP_PATH_PROT_ASSOC):
581 return "ATTEMPTED_ADD_LSP_PATH_PROT_ASSOC";
582 case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
583 PCEP_ERRV_PROTECTION_TYPE_NOT_SUPPORTED):
584 return "PROTECTION_TYPE_NOT_SUPPORTED";
585
586 case TUP(PCEP_ERRT_WSON_RWA_ERROR, PCEP_ERRV_RWA_INSUFFICIENT_MEMORY):
587 return "RWA_INSUFFICIENT_MEMORY";
588 case TUP(PCEP_ERRT_WSON_RWA_ERROR, PCEP_ERRV_RWA_COMP_NOT_SUPPORTED):
589 return "RWA_COMP_NOT_SUPPORTED";
590 case TUP(PCEP_ERRT_WSON_RWA_ERROR, PCEP_ERRV_SYNTAX_ENC_ERROR):
591 return "SYNTAX_ENC_ERROR";
592
593 case TUP(PCEP_ERRT_H_PCE_ERROR, PCEP_ERRV_H_PCE_CAP_NOT_ADVERTISED):
594 return "H_PCE_CAP_NOT_ADVERTISED";
595 case TUP(PCEP_ERRT_H_PCE_ERROR,
596 PCEP_ERRV_PARENT_PCE_CAP_CANT_BE_PROVIDED):
597 return "PARENT_PCE_CAP_CANT_BE_PROVIDED";
598
599 case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
600 PCEP_ERRV_UNACCEPTABLE_REQUEST_MSG):
601 return "UNACCEPTABLE_REQUEST_MSG";
602 case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
603 PCEP_ERRV_GENERALIZED_BW_VAL_NOT_SUPPORTED):
604 return "GENERALIZED_BW_VAL_NOT_SUPPORTED";
605 case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
606 PCEP_ERRV_LABEL_SET_CONSTRAINT_COULD_NOT_BE_MET):
607 return "LABEL_SET_CONSTRAINT_COULD_NOT_BE_MET";
608 case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
609 PCEP_ERRV_LABEL_CONSTRAINT_COULD_NOT_BE_MET):
610 return "LABEL_CONSTRAINT_COULD_NOT_BE_MET";
611
612 default:
613 return "UNKNOWN";
614 }
615 }
616
617 const char *pcep_message_type_name(enum pcep_message_types pcep_message_type)
618 {
619 switch (pcep_message_type) {
620
621 case PCEP_TYPE_OPEN:
622 return "OPEN";
623 case PCEP_TYPE_KEEPALIVE:
624 return "KEEPALIVE";
625 case PCEP_TYPE_PCREQ:
626 return "PCREQ";
627 case PCEP_TYPE_PCREP:
628 return "PCREP";
629 case PCEP_TYPE_PCNOTF:
630 return "PCNOTF";
631 case PCEP_TYPE_ERROR:
632 return "ERROR";
633 case PCEP_TYPE_CLOSE:
634 return "CLOSE";
635 case PCEP_TYPE_REPORT:
636 return "REPORT";
637 case PCEP_TYPE_UPDATE:
638 return "UPDATE";
639 case PCEP_TYPE_INITIATE:
640 return "INITIATE";
641 case PCEP_TYPE_START_TLS:
642 return "START_TLS";
643 default:
644 return "UNKNOWN";
645 }
646 }
647
648 const char *pcep_object_class_name(enum pcep_object_classes obj_class)
649 {
650 switch (obj_class) {
651 case PCEP_OBJ_CLASS_OPEN:
652 return "OPEN";
653 case PCEP_OBJ_CLASS_RP:
654 return "RP";
655 case PCEP_OBJ_CLASS_NOPATH:
656 return "NOPATH";
657 case PCEP_OBJ_CLASS_ENDPOINTS:
658 return "ENDPOINTS";
659 case PCEP_OBJ_CLASS_BANDWIDTH:
660 return "BANDWIDTH";
661 case PCEP_OBJ_CLASS_METRIC:
662 return "METRIC";
663 case PCEP_OBJ_CLASS_ERO:
664 return "ERO";
665 case PCEP_OBJ_CLASS_RRO:
666 return "RRO";
667 case PCEP_OBJ_CLASS_LSPA:
668 return "LSPA";
669 case PCEP_OBJ_CLASS_IRO:
670 return "IRO";
671 case PCEP_OBJ_CLASS_SVEC:
672 return "SVEC";
673 case PCEP_OBJ_CLASS_NOTF:
674 return "NOTF";
675 case PCEP_OBJ_CLASS_ERROR:
676 return "ERROR";
677 case PCEP_OBJ_CLASS_CLOSE:
678 return "CLOSE";
679 case PCEP_OBJ_CLASS_OF:
680 return "OF";
681 case PCEP_OBJ_CLASS_LSP:
682 return "LSP";
683 case PCEP_OBJ_CLASS_SRP:
684 return "SRP";
685 case PCEP_OBJ_CLASS_VENDOR_INFO:
686 return "VENDOR_INFO";
687 case PCEP_OBJ_CLASS_INTER_LAYER:
688 return "INTER_LAYER";
689 case PCEP_OBJ_CLASS_SWITCH_LAYER:
690 return "SWITCH_LAYER";
691 case PCEP_OBJ_CLASS_REQ_ADAP_CAP:
692 return "REQ_ADAP_CAP";
693 case PCEP_OBJ_CLASS_SERVER_IND:
694 return "SERVER_IND";
695 case PCEP_OBJ_CLASS_ASSOCIATION:
696 return "ASSOCIATION";
697 default:
698 return "UNKNOWN";
699 }
700 }
701
702 const char *pcep_object_type_name(enum pcep_object_classes obj_class,
703 enum pcep_object_types obj_type)
704 {
705 switch (TUP(obj_class, obj_type)) {
706 case TUP(PCEP_OBJ_CLASS_OPEN, PCEP_OBJ_TYPE_OPEN):
707 return "OPEN";
708 case TUP(PCEP_OBJ_CLASS_RP, PCEP_OBJ_TYPE_RP):
709 return "RP";
710 case TUP(PCEP_OBJ_CLASS_NOPATH, PCEP_OBJ_TYPE_NOPATH):
711 return "NOPATH";
712 case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV4):
713 return "ENDPOINT_IPV4";
714 case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV6):
715 return "ENDPOINT_IPV6";
716 case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_REQ):
717 return "BANDWIDTH_REQ";
718 case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_TELSP):
719 return "BANDWIDTH_TELSP";
720 case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_CISCO):
721 return "BANDWIDTH_CISCO";
722 case TUP(PCEP_OBJ_CLASS_METRIC, PCEP_OBJ_TYPE_METRIC):
723 return "METRIC";
724 case TUP(PCEP_OBJ_CLASS_ERO, PCEP_OBJ_TYPE_ERO):
725 return "ERO";
726 case TUP(PCEP_OBJ_CLASS_RRO, PCEP_OBJ_TYPE_RRO):
727 return "RRO";
728 case TUP(PCEP_OBJ_CLASS_LSPA, PCEP_OBJ_TYPE_LSPA):
729 return "LSPA";
730 case TUP(PCEP_OBJ_CLASS_IRO, PCEP_OBJ_TYPE_IRO):
731 return "IRO";
732 case TUP(PCEP_OBJ_CLASS_SVEC, PCEP_OBJ_TYPE_SVEC):
733 return "SVEC";
734 case TUP(PCEP_OBJ_CLASS_NOTF, PCEP_OBJ_TYPE_NOTF):
735 return "NOTF";
736 case TUP(PCEP_OBJ_CLASS_ERROR, PCEP_OBJ_TYPE_ERROR):
737 return "ERROR";
738 case TUP(PCEP_OBJ_CLASS_CLOSE, PCEP_OBJ_TYPE_CLOSE):
739 return "CLOSE";
740 case TUP(PCEP_OBJ_CLASS_INTER_LAYER, PCEP_OBJ_TYPE_INTER_LAYER):
741 return "INTER_LAYER";
742 case TUP(PCEP_OBJ_CLASS_SWITCH_LAYER, PCEP_OBJ_TYPE_SWITCH_LAYER):
743 return "SWITCH_LAYER";
744 case TUP(PCEP_OBJ_CLASS_REQ_ADAP_CAP, PCEP_OBJ_TYPE_REQ_ADAP_CAP):
745 return "REQ_ADAP_CAP";
746 case TUP(PCEP_OBJ_CLASS_SERVER_IND, PCEP_OBJ_TYPE_SERVER_IND):
747 return "SERVER_IND";
748 case TUP(PCEP_OBJ_CLASS_ASSOCIATION, PCEP_OBJ_TYPE_ASSOCIATION_IPV4):
749 return "ASSOCIATION_IPV4";
750 case TUP(PCEP_OBJ_CLASS_ASSOCIATION, PCEP_OBJ_TYPE_ASSOCIATION_IPV6):
751 return "ASSOCIATION_IPV6";
752 case TUP(PCEP_OBJ_CLASS_OF, PCEP_OBJ_TYPE_OF):
753 return "OF";
754 default:
755 return "UNKNOWN";
756 }
757 }
758
759 const char *pcep_lsp_status_name(enum pcep_lsp_operational_status status)
760 {
761 switch (status) {
762 case PCEP_LSP_OPERATIONAL_DOWN:
763 return "DOWN";
764 case PCEP_LSP_OPERATIONAL_UP:
765 return "UP";
766 case PCEP_LSP_OPERATIONAL_ACTIVE:
767 return "ACTIVE";
768 case PCEP_LSP_OPERATIONAL_GOING_DOWN:
769 return "GOING_DOWN";
770 case PCEP_LSP_OPERATIONAL_GOING_UP:
771 return "GOING_UP";
772 default:
773 return "UNKNOWN";
774 }
775 }
776
777
778 const char *pcep_tlv_type_name(enum pcep_object_tlv_types tlv_type)
779 {
780 switch (tlv_type) {
781 case PCEP_OBJ_TLV_TYPE_NO_PATH_VECTOR:
782 return "NO_PATH_VECTOR";
783 case PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY:
784 return "STATEFUL_PCE_CAPABILITY";
785 case PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME:
786 return "SYMBOLIC_PATH_NAME";
787 case PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS:
788 return "IPV4_LSP_IDENTIFIERS";
789 case PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS:
790 return "IPV6_LSP_IDENTIFIERS";
791 case PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE:
792 return "LSP_ERROR_CODE";
793 case PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC:
794 return "RSVP_ERROR_SPEC";
795 case PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION:
796 return "LSP_DB_VERSION";
797 case PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID:
798 return "SPEAKER_ENTITY_ID";
799 case PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY:
800 return "SR_PCE_CAPABILITY";
801 case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
802 return "PATH_SETUP_TYPE";
803 case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE_CAPABILITY:
804 return "PATH_SETUP_TYPE_CAPABILITY";
805 default:
806 return "UNKNOWN";
807 }
808 }
809
810 const char *pcep_ro_type_name(enum pcep_ro_subobj_types ro_type)
811 {
812 switch (ro_type) {
813
814 case RO_SUBOBJ_TYPE_IPV4:
815 return "IPV4";
816 case RO_SUBOBJ_TYPE_IPV6:
817 return "IPV6";
818 case RO_SUBOBJ_TYPE_LABEL:
819 return "LABEL";
820 case RO_SUBOBJ_TYPE_UNNUM:
821 return "UNNUM";
822 case RO_SUBOBJ_TYPE_ASN:
823 return "ASN";
824 case RO_SUBOBJ_TYPE_SR:
825 return "SR";
826 default:
827 return "UNKNOWN";
828 }
829 }
830
831 const char *pcep_nai_type_name(enum pcep_sr_subobj_nai nai_type)
832 {
833 switch (nai_type) {
834 case PCEP_SR_SUBOBJ_NAI_ABSENT:
835 return "ABSENT";
836 case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
837 return "IPV4_NODE";
838 case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
839 return "IPV6_NODE";
840 case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
841 return "IPV4_ADJACENCY";
842 case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
843 return "IPV6_ADJACENCY";
844 case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
845 return "UNNUMBERED_IPV4_ADJACENCY";
846 case PCEP_SR_SUBOBJ_NAI_LINK_LOCAL_IPV6_ADJACENCY:
847 return "LINK_LOCAL_IPV6_ADJACENCY";
848 default:
849 return "UNKNOWN";
850 }
851 }
852
853 const char *pcep_metric_type_name(enum pcep_metric_types type)
854 {
855 switch (type) {
856 case PCEP_METRIC_IGP:
857 return "IGP";
858 case PCEP_METRIC_TE:
859 return "TE";
860 case PCEP_METRIC_HOP_COUNT:
861 return "HOP_COUNT";
862 case PCEP_METRIC_AGGREGATE_BW:
863 return "AGGREGATE_BW";
864 case PCEP_METRIC_MOST_LOADED_LINK:
865 return "MOST_LOADED_LINK";
866 case PCEP_METRIC_CUMULATIVE_IGP:
867 return "CUMULATIVE_IGP";
868 case PCEP_METRIC_CUMULATIVE_TE:
869 return "CUMULATIVE_TE";
870 case PCEP_METRIC_P2MP_IGP:
871 return "P2MP_IGP";
872 case PCEP_METRIC_P2MP_TE:
873 return "P2MP_TE";
874 case PCEP_METRIC_P2MP_HOP_COUNT:
875 return "P2MP_HOP_COUNT";
876 case PCEP_METRIC_SEGMENT_ID_DEPTH:
877 return "SEGMENT_ID_DEPTH";
878 case PCEP_METRIC_PATH_DELAY:
879 return "PATH_DELAY";
880 case PCEP_METRIC_PATH_DELAY_VARIATION:
881 return "PATH_DELAY_VARIATION";
882 case PCEP_METRIC_PATH_LOSS:
883 return "PATH_LOSS";
884 case PCEP_METRIC_P2MP_PATH_DELAY:
885 return "P2MP_PATH_DELAY";
886 case PCEP_METRIC_P2MP_PATH_DELAY_VARIATION:
887 return "P2MP_PATH_DELAY_VARIATION";
888 case PCEP_METRIC_P2MP_PATH_LOSS:
889 return "P2MP_PATH_LOSS";
890 case PCEP_METRIC_NUM_PATH_ADAPTATIONS:
891 return "NUM_PATH_ADAPTATIONS";
892 case PCEP_METRIC_NUM_PATH_LAYERS:
893 return "NUM_PATH_LAYERS";
894 case PCEP_METRIC_DOMAIN_COUNT:
895 return "DOMAIN_COUNT";
896 case PCEP_METRIC_BORDER_NODE_COUNT:
897 return "BORDER_NODE_COUNT";
898 default:
899 return "UNKNOWN";
900 }
901 }
902
903 const char *pcep_nopath_tlv_err_code_name(enum pcep_nopath_tlv_err_codes type)
904 {
905 switch (type) {
906 case PCEP_NOPATH_TLV_ERR_NO_TLV:
907 return "NO_TLV";
908 case PCEP_NOPATH_TLV_ERR_PCE_UNAVAILABLE:
909 return "PCE_UNAVAILABLE";
910 case PCEP_NOPATH_TLV_ERR_UNKNOWN_DST:
911 return "UNKNOWN_DST";
912 case PCEP_NOPATH_TLV_ERR_UNKNOWN_SRC:
913 return "UNKNOWN_SRC";
914 default:
915 return "UNKNOWN";
916 }
917 }
918
919 const char *format_objfun_set(uint32_t flags)
920 {
921 int i, c;
922 PATHD_FORMAT_INIT();
923 for (i = 1, c = 0; i <= MAX_OBJFUN_TYPE; i++) {
924 if (CHECK_FLAG(flags, i)) {
925 if (c > 0)
926 PATHD_FORMAT(", %s", objfun_type_name(i));
927 else
928 PATHD_FORMAT("%s", objfun_type_name(i));
929 c++;
930 }
931 }
932 return PATHD_FORMAT_FINI();
933 }
934
935
936 const char *format_pcc_opts(struct pcc_opts *opts)
937 {
938 PATHD_FORMAT_INIT();
939 _format_pcc_opts(0, opts);
940 return PATHD_FORMAT_FINI();
941 }
942
943 const char *format_pcc_state(struct pcc_state *state)
944 {
945 PATHD_FORMAT_INIT();
946 _format_pcc_state(0, state);
947 return PATHD_FORMAT_FINI();
948 }
949
950 const char *format_ctrl_state(struct ctrl_state *state)
951 {
952 PATHD_FORMAT_INIT();
953 _format_ctrl_state(0, state);
954 return PATHD_FORMAT_FINI();
955 }
956
957 const char *format_path(struct path *path)
958 {
959 PATHD_FORMAT_INIT();
960 _format_path(0, path);
961 return PATHD_FORMAT_FINI();
962 }
963
964 const char *format_pcep_event(pcep_event *event)
965 {
966 PATHD_FORMAT_INIT();
967 _format_pcep_event(0, event);
968 return PATHD_FORMAT_FINI();
969 }
970
971 const char *format_pcep_message(struct pcep_message *msg)
972 {
973 PATHD_FORMAT_INIT();
974 _format_pcep_message(0, msg);
975 return PATHD_FORMAT_FINI();
976 }
977
978 const char *format_yang_dnode(struct lyd_node *dnode)
979 {
980 char *buff;
981 int len;
982
983 lyd_print_mem(&buff, dnode, LYD_JSON, LYP_FORMAT);
984 len = strlen(buff);
985 memcpy(_debug_buff, buff, len);
986 free(buff);
987 return _debug_buff;
988 }
989
990 void _format_pcc_opts(int ps, struct pcc_opts *opts)
991 {
992 if (opts == NULL) {
993 PATHD_FORMAT("NULL\n");
994 } else {
995 int ps2 = ps + DEBUG_IDENT_SIZE;
996 PATHD_FORMAT("\n");
997 if (IS_IPADDR_V4(&opts->addr)) {
998 PATHD_FORMAT("%*saddr_v4: %pI4\n", ps2, "",
999 &opts->addr.ipaddr_v4);
1000 } else {
1001 PATHD_FORMAT("%*saddr_v4: undefined", ps2, "");
1002 }
1003 if (IS_IPADDR_V6(&opts->addr)) {
1004 PATHD_FORMAT("%*saddr_v6: %pI6\n", ps2, "",
1005 &opts->addr.ipaddr_v6);
1006 } else {
1007 PATHD_FORMAT("%*saddr_v6: undefined", ps2, "");
1008 }
1009 PATHD_FORMAT("%*sport: %i\n", ps2, "", opts->port);
1010 PATHD_FORMAT("%*smsd: %i\n", ps2, "", opts->msd);
1011 }
1012 }
1013
1014 void _format_pce_opts(int ps, struct pce_opts *opts)
1015 {
1016 if (opts == NULL) {
1017 PATHD_FORMAT("NULL\n");
1018 } else {
1019 int ps2 = ps + DEBUG_IDENT_SIZE;
1020 PATHD_FORMAT("\n");
1021 if (IS_IPADDR_V6(&opts->addr)) {
1022 PATHD_FORMAT("%*saddr: %pI6\n", ps2, "",
1023 &opts->addr.ipaddr_v6);
1024 } else {
1025 PATHD_FORMAT("%*saddr: %pI4\n", ps2, "",
1026 &opts->addr.ipaddr_v4);
1027 }
1028 PATHD_FORMAT("%*sport: %i\n", ps2, "", opts->port);
1029 }
1030 }
1031
1032 void _format_pcc_caps(int ps, struct pcep_caps *caps)
1033 {
1034 int ps2 = ps + DEBUG_IDENT_SIZE;
1035 PATHD_FORMAT("\n");
1036 PATHD_FORMAT("%*sis_stateful: %d\n", ps2, "", caps->is_stateful);
1037 }
1038
1039 void _format_pcc_state(int ps, struct pcc_state *state)
1040 {
1041 if (state == NULL) {
1042 PATHD_FORMAT("NULL\n");
1043 } else {
1044 int ps2 = ps + DEBUG_IDENT_SIZE;
1045 PATHD_FORMAT("\n");
1046 PATHD_FORMAT("%*sstatus: %s\n", ps2, "",
1047 pcc_status_name(state->status));
1048 PATHD_FORMAT("%*spcc_opts: ", ps2, "");
1049 _format_pcc_opts(ps2, state->pcc_opts);
1050 PATHD_FORMAT("%*spce_opts: ", ps2, "");
1051 _format_pce_opts(ps2, state->pce_opts);
1052 if (state->sess == NULL) {
1053 PATHD_FORMAT("%*ssess: NULL\n", ps2, "");
1054 } else {
1055 PATHD_FORMAT("%*ssess: <PCC SESSION %p>\n", ps2, "",
1056 state->sess);
1057 }
1058 PATHD_FORMAT("%*scaps: ", ps2, "");
1059 _format_pcc_caps(ps2, &state->caps);
1060 }
1061 }
1062
1063 void _format_ctrl_state(int ps, struct ctrl_state *state)
1064 {
1065 if (state == NULL) {
1066 PATHD_FORMAT("NULL\n");
1067 } else {
1068 int i;
1069 int ps2 = ps + DEBUG_IDENT_SIZE;
1070 int ps3 = ps2 + DEBUG_IDENT_SIZE;
1071 PATHD_FORMAT("\n");
1072 if (state->main == NULL) {
1073 PATHD_FORMAT("%*smain: NULL\n", ps2, "");
1074 } else {
1075 PATHD_FORMAT("%*smain: <THREAD MASTER %p>\n", ps2, "",
1076 state->main);
1077 }
1078 if (state->self == NULL) {
1079 PATHD_FORMAT("%*sself: NULL\n", ps2, "");
1080 } else {
1081 PATHD_FORMAT("%*sself: <THREAD MASTER %p>\n", ps2, "",
1082 state->self);
1083 }
1084 PATHD_FORMAT("%*spcc_count: %d\n", ps2, "", state->pcc_count);
1085 PATHD_FORMAT("%*spcc:\n", ps2, "");
1086 for (i = 0; i < MAX_PCC; i++) {
1087 if (state->pcc[i]) {
1088 PATHD_FORMAT("%*s- ", ps3 - 2, "");
1089 _format_pcc_state(ps3, state->pcc[i]);
1090 }
1091 }
1092 }
1093 }
1094
1095 void _format_path(int ps, struct path *path)
1096 {
1097 if (path == NULL) {
1098 PATHD_FORMAT("NULL\n");
1099 } else {
1100 int ps2 = ps + DEBUG_IDENT_SIZE;
1101 int ps3 = ps2 + DEBUG_IDENT_SIZE;
1102 PATHD_FORMAT("\n");
1103 PATHD_FORMAT("%*snbkey: \n", ps2, "");
1104 PATHD_FORMAT("%*scolor: %u\n", ps3, "", path->nbkey.color);
1105 switch (path->nbkey.endpoint.ipa_type) {
1106 case IPADDR_V4:
1107 PATHD_FORMAT("%*sendpoint: %pI4\n", ps3, "",
1108 &path->nbkey.endpoint.ipaddr_v4);
1109 break;
1110 case IPADDR_V6:
1111 PATHD_FORMAT("%*sendpoint: %pI6\n", ps3, "",
1112 &path->nbkey.endpoint.ipaddr_v6);
1113 break;
1114 default:
1115 PATHD_FORMAT("%*sendpoint: NONE\n", ps3, "");
1116 break;
1117 }
1118 PATHD_FORMAT("%*spreference: %u\n", ps3, "",
1119 path->nbkey.preference);
1120
1121 if (path->sender.ipa_type == IPADDR_V4) {
1122 PATHD_FORMAT("%*ssender: %pI4\n", ps2, "",
1123 &path->sender.ipaddr_v4);
1124 } else if (path->sender.ipa_type == IPADDR_V6) {
1125 PATHD_FORMAT("%*ssender: %pI6\n", ps2, "",
1126 &path->sender.ipaddr_v6);
1127 } else {
1128 PATHD_FORMAT("%*ssender: UNDEFINED\n", ps2, "");
1129 }
1130 if (path->pcc_addr.ipa_type == IPADDR_V4) {
1131 PATHD_FORMAT("%*spcc_addr: %pI4\n", ps2, "",
1132 &path->pcc_addr.ipaddr_v4);
1133 } else if (path->pcc_addr.ipa_type == IPADDR_V6) {
1134 PATHD_FORMAT("%*spcc_addr: %pI6\n", ps2, "",
1135 &path->pcc_addr.ipaddr_v6);
1136 } else {
1137 PATHD_FORMAT("%*spcc_addr: UNDEFINED\n", ps2, "");
1138 }
1139 PATHD_FORMAT("%*spcc_id: %u\n", ps2, "", path->pcc_id);
1140 PATHD_FORMAT("%*screate_origin: %s (%u)\n", ps2, "",
1141 srte_protocol_origin_name(path->create_origin),
1142 path->create_origin);
1143 PATHD_FORMAT("%*supdate_origin: %s (%u)\n", ps2, "",
1144 srte_protocol_origin_name(path->update_origin),
1145 path->update_origin);
1146 if (path->originator != NULL) {
1147 PATHD_FORMAT("%*soriginator: %s\n", ps2, "",
1148 path->originator);
1149 } else {
1150 PATHD_FORMAT("%*soriginator: UNDEFINED\n", ps2, "");
1151 }
1152 PATHD_FORMAT("%*stype: %s (%u)\n", ps2, "",
1153 srte_candidate_type_name(path->type), path->type);
1154 PATHD_FORMAT("%*splsp_id: %u\n", ps2, "", path->plsp_id);
1155 if (path->name == NULL) {
1156 PATHD_FORMAT("%*sname: NULL\n", ps2, "");
1157 } else {
1158 PATHD_FORMAT("%*sname: %s\n", ps2, "", path->name);
1159 }
1160 PATHD_FORMAT("%*ssrp_id: %u\n", ps2, "", path->srp_id);
1161 PATHD_FORMAT("%*sreq_id: %u\n", ps2, "", path->req_id);
1162 PATHD_FORMAT("%*sstatus: %s (%u)\n", ps2, "",
1163 pcep_lsp_status_name(path->status), path->status);
1164 PATHD_FORMAT("%*sdo_remove: %u\n", ps2, "", path->do_remove);
1165 PATHD_FORMAT("%*sgo_active: %u\n", ps2, "", path->go_active);
1166 PATHD_FORMAT("%*swas_created: %u\n", ps2, "",
1167 path->was_created);
1168 PATHD_FORMAT("%*swas_removed: %u\n", ps2, "",
1169 path->was_removed);
1170 PATHD_FORMAT("%*sis_synching: %u\n", ps2, "",
1171 path->is_synching);
1172 PATHD_FORMAT("%*sis_delegated: %u\n", ps2, "",
1173 path->is_delegated);
1174 PATHD_FORMAT("%*shas_bandwidth: %u\n", ps2, "",
1175 path->has_bandwidth);
1176 if (path->has_bandwidth) {
1177 PATHD_FORMAT("%*senforce_bandwidth: %u\n", ps2, "",
1178 path->enforce_bandwidth);
1179 PATHD_FORMAT("%*sbandwidth: %f\n", ps2, "",
1180 path->bandwidth);
1181 }
1182 PATHD_FORMAT("%*shas_pcc_objfun: %u\n", ps2, "",
1183 path->has_pcc_objfun);
1184 if (path->has_pcc_objfun) {
1185 PATHD_FORMAT("%*senforce_pcc_objfun: %d\n", ps2, "",
1186 path->enforce_pcc_objfun);
1187 PATHD_FORMAT("%*spcc_objfun: %s (%u)\n", ps2, "",
1188 objfun_type_name(path->pcc_objfun),
1189 path->pcc_objfun);
1190 }
1191 PATHD_FORMAT("%*shas_pce_objfun: %u\n", ps2, "",
1192 path->has_pce_objfun);
1193 if (path->has_pce_objfun)
1194 PATHD_FORMAT("%*spce_objfun: %s (%u)\n", ps2, "",
1195 objfun_type_name(path->pce_objfun),
1196 path->pce_objfun);
1197 PATHD_FORMAT("%*shas_affinity_filters: %u\n", ps2, "",
1198 path->has_affinity_filters);
1199 if (path->has_affinity_filters) {
1200 PATHD_FORMAT("%*sexclude_any: 0x%08x\n", ps2, "",
1201 path->affinity_filters
1202 [AFFINITY_FILTER_EXCLUDE_ANY - 1]);
1203 PATHD_FORMAT("%*sinclude_any: 0x%08x\n", ps2, "",
1204 path->affinity_filters
1205 [AFFINITY_FILTER_INCLUDE_ANY - 1]);
1206 PATHD_FORMAT("%*sinclude_all: 0x%08x\n", ps2, "",
1207 path->affinity_filters
1208 [AFFINITY_FILTER_INCLUDE_ALL - 1]);
1209 }
1210
1211 if (path->first_hop == NULL) {
1212 PATHD_FORMAT("%*shops: []\n", ps2, "");
1213 } else {
1214 PATHD_FORMAT("%*shops: \n", ps2, "");
1215 for (struct path_hop *hop = path->first_hop;
1216 hop != NULL; hop = hop->next) {
1217 PATHD_FORMAT("%*s- ", ps3 - 2, "");
1218 _format_path_hop(ps3, hop);
1219 }
1220 }
1221 if (path->first_metric == NULL) {
1222 PATHD_FORMAT("%*smetrics: []\n", ps2, "");
1223 } else {
1224 PATHD_FORMAT("%*smetrics: \n", ps2, "");
1225 for (struct path_metric *metric = path->first_metric;
1226 NULL != metric; metric = metric->next) {
1227 PATHD_FORMAT("%*s- ", ps3 - 2, "");
1228 _format_path_metric(ps3, metric);
1229 }
1230 }
1231 }
1232 }
1233
1234 void _format_path_metric(int ps, struct path_metric *metric)
1235 {
1236 PATHD_FORMAT("type: %s (%u)\n", pcep_metric_type_name(metric->type),
1237 metric->type);
1238 PATHD_FORMAT("%*senforce: %u\n", ps, "", metric->enforce);
1239 PATHD_FORMAT("%*sis_bound: %u\n", ps, "", metric->is_bound);
1240 PATHD_FORMAT("%*sis_computed: %u\n", ps, "", metric->is_computed);
1241 PATHD_FORMAT("%*svalue: %f\n", ps, "", metric->value);
1242 }
1243
1244 void _format_path_hop(int ps, struct path_hop *hop)
1245 {
1246 PATHD_FORMAT("is_loose: %u\n", hop->is_loose);
1247 PATHD_FORMAT("%*shas_sid: %u\n", ps, "", hop->has_sid);
1248
1249 if (hop->has_sid) {
1250 PATHD_FORMAT("%*sis_mpls: %u\n", ps, "", hop->is_mpls);
1251 if (hop->is_mpls) {
1252 PATHD_FORMAT("%*shas_attribs: %u\n", ps, "",
1253 hop->has_attribs);
1254 PATHD_FORMAT("%*slabel: %u\n", ps, "",
1255 hop->sid.mpls.label);
1256 if (hop->has_attribs) {
1257 PATHD_FORMAT("%*straffic_class: %u\n", ps, "",
1258 hop->sid.mpls.traffic_class);
1259 PATHD_FORMAT("%*sis_bottom: %u\n", ps, "",
1260 hop->sid.mpls.is_bottom);
1261 PATHD_FORMAT("%*sttl: %u\n", ps, "",
1262 hop->sid.mpls.ttl);
1263 }
1264 } else {
1265 PATHD_FORMAT("%*sSID: %u\n", ps, "", hop->sid.value);
1266 }
1267 }
1268
1269 PATHD_FORMAT("%*shas_nai: %u\n", ps, "", hop->has_nai);
1270 if (hop->has_nai) {
1271 PATHD_FORMAT("%*snai_type: %s (%u)\n", ps, "",
1272 pcep_nai_type_name(hop->nai.type), hop->nai.type);
1273 switch (hop->nai.type) {
1274 case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
1275 PATHD_FORMAT("%*sNAI: %pI4\n", ps, "",
1276 &hop->nai.local_addr.ipaddr_v4);
1277 break;
1278 case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
1279 PATHD_FORMAT("%*sNAI: %pI6\n", ps, "",
1280 &hop->nai.local_addr.ipaddr_v6);
1281 break;
1282 case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
1283 PATHD_FORMAT("%*sNAI: %pI4/%pI4\n", ps, "",
1284 &hop->nai.local_addr.ipaddr_v4,
1285 &hop->nai.remote_addr.ipaddr_v4);
1286 break;
1287 case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
1288 PATHD_FORMAT("%*sNAI: %pI6/%pI6\n", ps, "",
1289 &hop->nai.local_addr.ipaddr_v6,
1290 &hop->nai.remote_addr.ipaddr_v6);
1291 break;
1292 case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
1293 PATHD_FORMAT("%*sNAI: %pI6(%u)/%pI6(%u)\n", ps, "",
1294 &hop->nai.local_addr.ipaddr_v6,
1295 hop->nai.local_iface,
1296 &hop->nai.remote_addr.ipaddr_v6,
1297 hop->nai.remote_iface);
1298 break;
1299 default:
1300 PATHD_FORMAT("%*sNAI: UNSUPPORTED\n", ps, "");
1301 break;
1302 }
1303 }
1304 }
1305
1306 void _format_pcep_event(int ps, pcep_event *event)
1307 {
1308 if (event == NULL) {
1309 PATHD_FORMAT("NULL\n");
1310 } else {
1311 int ps2 = ps + DEBUG_IDENT_SIZE;
1312 PATHD_FORMAT("\n");
1313 PATHD_FORMAT("%*sevent_type: %s\n", ps2, "",
1314 pcep_event_type_name(event->event_type));
1315 PATHD_FORMAT("%*sevent_time: %s", ps2, "",
1316 ctime(&event->event_time));
1317 if (event->session == NULL) {
1318 PATHD_FORMAT("%*ssession: NULL\n", ps2, "");
1319 } else {
1320 PATHD_FORMAT("%*ssession: <PCC SESSION %p>\n", ps2, "",
1321 event->session);
1322 }
1323 PATHD_FORMAT("%*smessage: ", ps2, "");
1324 _format_pcep_message(ps2, event->message);
1325 }
1326 }
1327
1328 void _format_pcep_message(int ps, struct pcep_message *msg)
1329 {
1330 if (msg == NULL) {
1331 PATHD_FORMAT("NULL\n");
1332 } else {
1333 int ps2 = ps + DEBUG_IDENT_SIZE;
1334 PATHD_FORMAT("\n");
1335 PATHD_FORMAT("%*spcep_version: %u\n", ps2, "",
1336 msg->msg_header->pcep_version);
1337 PATHD_FORMAT("%*stype: %s (%u)\n", ps2, "",
1338 pcep_message_type_name(msg->msg_header->type),
1339 msg->msg_header->type);
1340 PATHD_FORMAT("%*sobjects: ", ps2, "");
1341 _format_pcep_objects(ps2, msg->obj_list);
1342 }
1343 }
1344
1345 void _format_pcep_objects(int ps, double_linked_list *objs)
1346 {
1347 if (objs == NULL) {
1348 PATHD_FORMAT("NULL\n");
1349 } else {
1350 double_linked_list_node *node;
1351 int ps2 = ps + DEBUG_IDENT_SIZE;
1352 int i;
1353
1354 if (objs->num_entries == 0) {
1355 PATHD_FORMAT("[]\n");
1356 return;
1357 }
1358
1359 PATHD_FORMAT("\n");
1360 for (node = objs->head, i = 0; node != NULL;
1361 node = node->next_node, i++) {
1362 struct pcep_object_header *obj =
1363 (struct pcep_object_header *)node->data;
1364 PATHD_FORMAT("%*s- ", ps2 - 2, "");
1365 _format_pcep_object(ps2, obj);
1366 }
1367 }
1368 }
1369
1370 void _format_pcep_object(int ps, struct pcep_object_header *obj)
1371 {
1372 if (obj == NULL) {
1373 PATHD_FORMAT("NULL\n");
1374 } else {
1375 PATHD_FORMAT("object_class: %s (%u)\n",
1376 pcep_object_class_name(obj->object_class),
1377 obj->object_class);
1378 PATHD_FORMAT("%*sobject_type: %s (%u)\n", ps, "",
1379 pcep_object_type_name(obj->object_class,
1380 obj->object_type),
1381 obj->object_type);
1382 PATHD_FORMAT("%*sflag_p: %u\n", ps, "", obj->flag_p);
1383 PATHD_FORMAT("%*sflag_i: %u\n", ps, "", obj->flag_i);
1384 _format_pcep_object_details(ps, obj);
1385 _format_pcep_object_tlvs(ps, obj);
1386 }
1387 }
1388
1389 void _format_pcep_object_details(int ps, struct pcep_object_header *obj)
1390 {
1391 switch (TUP(obj->object_class, obj->object_type)) {
1392 case TUP(PCEP_OBJ_CLASS_ERROR, PCEP_OBJ_TYPE_ERROR):
1393 _format_pcep_object_error(ps, (struct pcep_object_error *)obj);
1394 break;
1395 case TUP(PCEP_OBJ_CLASS_OPEN, PCEP_OBJ_TYPE_OPEN):
1396 _format_pcep_object_open(ps, (struct pcep_object_open *)obj);
1397 break;
1398 case TUP(PCEP_OBJ_CLASS_RP, PCEP_OBJ_TYPE_RP):
1399 _format_pcep_object_rp(ps, (struct pcep_object_rp *)obj);
1400 break;
1401 case TUP(PCEP_OBJ_CLASS_SRP, PCEP_OBJ_TYPE_SRP):
1402 _format_pcep_object_srp(ps, (struct pcep_object_srp *)obj);
1403 break;
1404 case TUP(PCEP_OBJ_CLASS_LSP, PCEP_OBJ_TYPE_LSP):
1405 _format_pcep_object_lsp(ps, (struct pcep_object_lsp *)obj);
1406 break;
1407 case TUP(PCEP_OBJ_CLASS_LSPA, PCEP_OBJ_TYPE_LSPA):
1408 _format_pcep_object_lspa(ps, (struct pcep_object_lspa *)obj);
1409 break;
1410 case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV4):
1411 _format_pcep_object_ipv4_endpoint(
1412 ps, (struct pcep_object_endpoints_ipv4 *)obj);
1413 break;
1414 case TUP(PCEP_OBJ_CLASS_ERO, PCEP_OBJ_TYPE_ERO):
1415 _format_pcep_object_ro(ps, (struct pcep_object_ro *)obj);
1416 break;
1417 case TUP(PCEP_OBJ_CLASS_METRIC, PCEP_OBJ_TYPE_METRIC):
1418 _format_pcep_object_metric(ps,
1419 (struct pcep_object_metric *)obj);
1420 break;
1421 case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_REQ):
1422 case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_CISCO):
1423 _format_pcep_object_bandwidth(
1424 ps, (struct pcep_object_bandwidth *)obj);
1425 break;
1426 case TUP(PCEP_OBJ_CLASS_NOPATH, PCEP_OBJ_TYPE_NOPATH):
1427 _format_pcep_object_nopath(ps,
1428 (struct pcep_object_nopath *)obj);
1429 break;
1430 case TUP(PCEP_OBJ_CLASS_OF, PCEP_OBJ_TYPE_OF):
1431 _format_pcep_object_objfun(
1432 ps, (struct pcep_object_objective_function *)obj);
1433 break;
1434 default:
1435 PATHD_FORMAT("%*s...\n", ps, "");
1436 break;
1437 }
1438 }
1439
1440 void _format_pcep_object_error(int ps, struct pcep_object_error *obj)
1441 {
1442 PATHD_FORMAT("%*serror_type: %s (%u)\n", ps, "",
1443 pcep_error_type_name(obj->error_type), obj->error_type);
1444 PATHD_FORMAT("%*serror_value: %s (%u)\n", ps, "",
1445 pcep_error_value_name(obj->error_type, obj->error_value),
1446 obj->error_value);
1447 }
1448
1449
1450 void _format_pcep_object_open(int ps, struct pcep_object_open *obj)
1451 {
1452 PATHD_FORMAT("%*sopen_version: %u\n", ps, "", obj->open_version);
1453 PATHD_FORMAT("%*sopen_keepalive: %u\n", ps, "", obj->open_keepalive);
1454 PATHD_FORMAT("%*sopen_deadtimer: %u\n", ps, "", obj->open_deadtimer);
1455 PATHD_FORMAT("%*sopen_sid: %u\n", ps, "", obj->open_sid);
1456 }
1457
1458 void _format_pcep_object_rp(int ps, struct pcep_object_rp *obj)
1459 {
1460 PATHD_FORMAT("%*spriority: %u\n", ps, "", obj->priority);
1461 PATHD_FORMAT("%*sflag_reoptimization: %u\n", ps, "",
1462 obj->flag_reoptimization);
1463 PATHD_FORMAT("%*sflag_bidirectional: %u\n", ps, "",
1464 obj->flag_bidirectional);
1465 PATHD_FORMAT("%*sflag_strict: %u\n", ps, "", obj->flag_strict);
1466 PATHD_FORMAT("%*sflag_of: %u\n", ps, "", obj->flag_of);
1467 PATHD_FORMAT("%*srequest_id: %u\n", ps, "", obj->request_id);
1468 }
1469
1470
1471 void _format_pcep_object_srp(int ps, struct pcep_object_srp *obj)
1472 {
1473 PATHD_FORMAT("%*sflag_lsp_remove: %u\n", ps, "", obj->flag_lsp_remove);
1474 PATHD_FORMAT("%*ssrp_id_number: %u\n", ps, "", obj->srp_id_number);
1475 }
1476
1477 void _format_pcep_object_lsp(int ps, struct pcep_object_lsp *obj)
1478 {
1479 PATHD_FORMAT("%*splsp_id: %u\n", ps, "", obj->plsp_id);
1480 PATHD_FORMAT("%*sstatus: %s\n", ps, "",
1481 pcep_lsp_status_name(obj->operational_status));
1482 PATHD_FORMAT("%*sflag_d: %u\n", ps, "", obj->flag_d);
1483 PATHD_FORMAT("%*sflag_s: %u\n", ps, "", obj->flag_s);
1484 PATHD_FORMAT("%*sflag_r: %u\n", ps, "", obj->flag_r);
1485 PATHD_FORMAT("%*sflag_a: %u\n", ps, "", obj->flag_a);
1486 PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1487 }
1488
1489 void _format_pcep_object_lspa(int ps, struct pcep_object_lspa *obj)
1490 {
1491 PATHD_FORMAT("%*slspa_exclude_any: 0x%08x\n", ps, "",
1492 obj->lspa_exclude_any);
1493 PATHD_FORMAT("%*slspa_include_any: 0x%08x\n", ps, "",
1494 obj->lspa_include_any);
1495 PATHD_FORMAT("%*slspa_include_all: 0x%08x\n", ps, "",
1496 obj->lspa_include_all);
1497 PATHD_FORMAT("%*ssetup_priority: %u\n", ps, "", obj->setup_priority);
1498 PATHD_FORMAT("%*sholding_priority: %u\n", ps, "",
1499 obj->holding_priority);
1500 PATHD_FORMAT("%*sflag_local_protection: %u\n", ps, "",
1501 obj->flag_local_protection);
1502 }
1503
1504 void _format_pcep_object_ipv4_endpoint(int ps,
1505 struct pcep_object_endpoints_ipv4 *obj)
1506 {
1507 PATHD_FORMAT("%*ssrc_ipv4: %pI4\n", ps, "", &obj->src_ipv4);
1508 PATHD_FORMAT("%*sdst_ipv4: %pI4\n", ps, "", &obj->dst_ipv4);
1509 }
1510
1511 void _format_pcep_object_metric(int ps, struct pcep_object_metric *obj)
1512 {
1513 PATHD_FORMAT("%*stype: %s (%u)\n", ps, "",
1514 pcep_metric_type_name(obj->type), obj->type);
1515 PATHD_FORMAT("%*sflag_b: %u\n", ps, "", obj->flag_b);
1516 PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1517 PATHD_FORMAT("%*svalue: %f\n", ps, "", obj->value);
1518 }
1519
1520 void _format_pcep_object_bandwidth(int ps, struct pcep_object_bandwidth *obj)
1521 {
1522 PATHD_FORMAT("%*sbandwidth: %f\n", ps, "", obj->bandwidth);
1523 }
1524
1525 void _format_pcep_object_nopath(int ps, struct pcep_object_nopath *obj)
1526 {
1527 PATHD_FORMAT("%*sni: %u\n", ps, "", obj->ni);
1528 PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1529 PATHD_FORMAT("%*serr_code: %s (%u)\n", ps, "",
1530 pcep_nopath_tlv_err_code_name(obj->err_code),
1531 obj->err_code);
1532 }
1533
1534 void _format_pcep_object_objfun(int ps,
1535 struct pcep_object_objective_function *obj)
1536 {
1537 PATHD_FORMAT("%*sof_code: %s (%u)\n", ps, "",
1538 objfun_type_name(obj->of_code), obj->of_code);
1539 }
1540
1541 void _format_pcep_object_ro(int ps, struct pcep_object_ro *obj)
1542 {
1543 double_linked_list *obj_list = obj->sub_objects;
1544 double_linked_list_node *node;
1545 struct pcep_object_ro_subobj *sub_obj;
1546
1547 int ps2 = ps + DEBUG_IDENT_SIZE;
1548 int i;
1549
1550 if ((obj_list == NULL) || (obj_list->num_entries == 0)) {
1551 PATHD_FORMAT("%*ssub_objects: []\n", ps, "");
1552 return;
1553 }
1554
1555 PATHD_FORMAT("%*ssub_objects:\n", ps, "");
1556
1557 for (node = obj_list->head, i = 0; node != NULL;
1558 node = node->next_node, i++) {
1559 sub_obj = (struct pcep_object_ro_subobj *)node->data;
1560 PATHD_FORMAT("%*s- flag_subobj_loose_hop: %u\n", ps2 - 2, "",
1561 sub_obj->flag_subobj_loose_hop);
1562 PATHD_FORMAT("%*sro_subobj_type: %s (%u)\n", ps2, "",
1563 pcep_ro_type_name(sub_obj->ro_subobj_type),
1564 sub_obj->ro_subobj_type);
1565 _format_pcep_object_ro_details(ps2, sub_obj);
1566 }
1567 }
1568
1569 void _format_pcep_object_ro_details(int ps, struct pcep_object_ro_subobj *ro)
1570 {
1571 switch (ro->ro_subobj_type) {
1572 case RO_SUBOBJ_TYPE_IPV4:
1573 _format_pcep_object_ro_ipv4(ps,
1574 (struct pcep_ro_subobj_ipv4 *)ro);
1575 break;
1576 case RO_SUBOBJ_TYPE_SR:
1577 _format_pcep_object_ro_sr(ps, (struct pcep_ro_subobj_sr *)ro);
1578 break;
1579 default:
1580 PATHD_FORMAT("%*s...\n", ps, "");
1581 break;
1582 }
1583 }
1584
1585 void _format_pcep_object_ro_ipv4(int ps, struct pcep_ro_subobj_ipv4 *obj)
1586 {
1587 PATHD_FORMAT("%*sip_addr: %pI4\n", ps, "", &obj->ip_addr);
1588 PATHD_FORMAT("%*sprefix_length: %u\n", ps, "", obj->prefix_length);
1589 PATHD_FORMAT("%*sflag_local_protection: %u\n", ps, "",
1590 obj->flag_local_protection);
1591 }
1592
1593 void _format_pcep_object_ro_sr(int ps, struct pcep_ro_subobj_sr *obj)
1594 {
1595 PATHD_FORMAT("%*snai_type = %s (%u)\n", ps, "",
1596 pcep_nai_type_name(obj->nai_type), obj->nai_type);
1597 PATHD_FORMAT("%*sflag_f: %u\n", ps, "", obj->flag_f);
1598 PATHD_FORMAT("%*sflag_s: %u\n", ps, "", obj->flag_s);
1599 PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1600 PATHD_FORMAT("%*sflag_m: %u\n", ps, "", obj->flag_m);
1601
1602 if (!obj->flag_s) {
1603 PATHD_FORMAT("%*sSID: %u\n", ps, "", obj->sid);
1604 if (obj->flag_m) {
1605 PATHD_FORMAT("%*slabel: %u\n", ps, "",
1606 GET_SR_ERO_SID_LABEL(obj->sid));
1607 if (obj->flag_c) {
1608 PATHD_FORMAT("%*sTC: %u\n", ps, "",
1609 GET_SR_ERO_SID_TC(obj->sid));
1610 PATHD_FORMAT("%*sS: %u\n", ps, "",
1611 GET_SR_ERO_SID_S(obj->sid));
1612 PATHD_FORMAT("%*sTTL: %u\n", ps, "",
1613 GET_SR_ERO_SID_TTL(obj->sid));
1614 }
1615 }
1616 }
1617
1618 if (!obj->flag_f) {
1619 struct in_addr *laddr4, *raddr4;
1620 struct in6_addr *laddr6, *raddr6;
1621 uint32_t *liface, *riface;
1622 assert(obj->nai_list != NULL);
1623 double_linked_list_node *n = obj->nai_list->head;
1624 assert(n != NULL);
1625 assert(n->data != NULL);
1626 switch (obj->nai_type) {
1627 case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
1628 laddr4 = (struct in_addr *)n->data;
1629 PATHD_FORMAT("%*sNAI: %pI4\n", ps, "", laddr4);
1630 break;
1631 case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
1632 laddr6 = (struct in6_addr *)n->data;
1633 PATHD_FORMAT("%*sNAI: %pI6\n", ps, "", laddr6);
1634 break;
1635 case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
1636 assert(n->next_node != NULL);
1637 assert(n->next_node->data != NULL);
1638 laddr4 = (struct in_addr *)n->data;
1639 raddr4 = (struct in_addr *)n->next_node->data;
1640 PATHD_FORMAT("%*sNAI: %pI4/%pI4\n", ps, "", laddr4,
1641 raddr4);
1642 break;
1643 case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
1644 assert(n->next_node != NULL);
1645 assert(n->next_node->data != NULL);
1646 laddr6 = (struct in6_addr *)n->data;
1647 raddr6 = (struct in6_addr *)n->next_node->data;
1648 PATHD_FORMAT("%*sNAI: %pI6/%pI6\n", ps, "", laddr6,
1649 raddr6);
1650 break;
1651 case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
1652 laddr4 = (struct in_addr *)n->data;
1653 n = n->next_node;
1654 assert(n != NULL);
1655 assert(n->data != NULL);
1656 liface = (uint32_t *)n->data;
1657 n = n->next_node;
1658 assert(n != NULL);
1659 assert(n->data != NULL);
1660 raddr4 = (struct in_addr *)n->data;
1661 assert(n != NULL);
1662 assert(n->data != NULL);
1663 riface = (uint32_t *)n->data;
1664 PATHD_FORMAT("%*sNAI: %pI4(%u)/%pI4(%u)\n", ps, "",
1665 laddr4, *liface, raddr4, *riface);
1666 break;
1667 default:
1668 PATHD_FORMAT("%*sNAI: UNSUPPORTED\n", ps, "");
1669 break;
1670 }
1671 }
1672 }
1673
1674 void _format_pcep_object_tlvs(int ps, struct pcep_object_header *obj)
1675 {
1676 double_linked_list *tlv_list = obj->tlv_list;
1677 struct pcep_object_tlv_header *tlv;
1678 double_linked_list_node *node;
1679 int ps2 = ps + DEBUG_IDENT_SIZE;
1680 int i = 0;
1681
1682 if (tlv_list == NULL)
1683 return;
1684 if (tlv_list->num_entries == 0) {
1685 PATHD_FORMAT("%*stlvs: []\n", ps, "");
1686 return;
1687 }
1688
1689 PATHD_FORMAT("%*stlvs:\n", ps, "");
1690
1691 for (node = tlv_list->head, i = 0; node != NULL;
1692 node = node->next_node, i++) {
1693 tlv = (struct pcep_object_tlv_header *)node->data;
1694 PATHD_FORMAT("%*s- ", ps2 - 2, "");
1695 _format_pcep_object_tlv(ps2, tlv);
1696 }
1697 }
1698
1699 void _format_pcep_object_tlv(int ps, struct pcep_object_tlv_header *tlv_header)
1700 {
1701 PATHD_FORMAT("type: %s (%u)\n", pcep_tlv_type_name(tlv_header->type),
1702 tlv_header->type);
1703 _format_pcep_object_tlv_details(ps, tlv_header);
1704 }
1705
1706 void _format_pcep_object_tlv_details(int ps,
1707 struct pcep_object_tlv_header *tlv_header)
1708 {
1709 switch (tlv_header->type) {
1710 case PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME:
1711 _format_pcep_object_tlv_symbolic_path_name(
1712 ps, (struct pcep_object_tlv_symbolic_path_name *)
1713 tlv_header);
1714 break;
1715 case PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY:
1716 _format_pcep_object_tlv_stateful_pce_capability(
1717 ps, (struct pcep_object_tlv_stateful_pce_capability *)
1718 tlv_header);
1719 break;
1720 case PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY:
1721 _format_pcep_object_tlv_sr_pce_capability(
1722 ps,
1723 (struct pcep_object_tlv_sr_pce_capability *)tlv_header);
1724 break;
1725 case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
1726 _format_pcep_object_tlv_path_setup_type(
1727 ps,
1728 (struct pcep_object_tlv_path_setup_type *)tlv_header);
1729 break;
1730 default:
1731 PATHD_FORMAT("%*s...\n", ps, "");
1732 break;
1733 }
1734 }
1735
1736 void _format_pcep_object_tlv_symbolic_path_name(
1737 int ps, struct pcep_object_tlv_symbolic_path_name *tlv)
1738 {
1739 PATHD_FORMAT("%*ssymbolic_path_name: %.*s\n", ps, "",
1740 tlv->symbolic_path_name_length, tlv->symbolic_path_name);
1741 }
1742
1743 void _format_pcep_object_tlv_stateful_pce_capability(
1744 int ps, struct pcep_object_tlv_stateful_pce_capability *tlv)
1745 {
1746 PATHD_FORMAT("%*sflag_u_lsp_update_capability: %u\n", ps, "",
1747 tlv->flag_u_lsp_update_capability);
1748 PATHD_FORMAT("%*sflag_s_include_db_version: %u\n", ps, "",
1749 tlv->flag_s_include_db_version);
1750 PATHD_FORMAT("%*sflag_i_lsp_instantiation_capability: %u\n", ps, "",
1751 tlv->flag_i_lsp_instantiation_capability);
1752 PATHD_FORMAT("%*sflag_t_triggered_resync: %u\n", ps, "",
1753 tlv->flag_t_triggered_resync);
1754 PATHD_FORMAT("%*sflag_d_delta_lsp_sync: %u\n", ps, "",
1755 tlv->flag_d_delta_lsp_sync);
1756 PATHD_FORMAT("%*sflag_f_triggered_initial_sync: %u\n", ps, "",
1757 tlv->flag_f_triggered_initial_sync);
1758 }
1759
1760 void _format_pcep_object_tlv_sr_pce_capability(
1761 int ps, struct pcep_object_tlv_sr_pce_capability *tlv)
1762 {
1763
1764 PATHD_FORMAT("%*sflag_n: %u\n", ps, "", tlv->flag_n);
1765 PATHD_FORMAT("%*sflag_x: %u\n", ps, "", tlv->flag_x);
1766 PATHD_FORMAT("%*smax_sid_depth: %u\n", ps, "", tlv->max_sid_depth);
1767 }
1768
1769 void _format_pcep_object_tlv_path_setup_type(
1770 int ps, struct pcep_object_tlv_path_setup_type *tlv)
1771 {
1772 PATHD_FORMAT("%*spath_setup_type: %u\n", ps, "", tlv->path_setup_type);
1773 }
FRRouting mirror