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 void _format_pcc_opts(int ps, struct pcc_opts *opts)
 979 {
 980         if (opts == NULL) {
 981                 PATHD_FORMAT("NULL\n");
 982         } else {
 983                 int ps2 = ps + DEBUG_IDENT_SIZE;
 984                 PATHD_FORMAT("\n");
 985                 if (IS_IPADDR_V4(&opts->addr)) {
 986                         PATHD_FORMAT("%*saddr_v4: %pI4\n", ps2, "",
 987                                      &opts->addr.ipaddr_v4);
 988                 } else {
 989                         PATHD_FORMAT("%*saddr_v4: undefined", ps2, "");
 990                 }
 991                 if (IS_IPADDR_V6(&opts->addr)) {
 992                         PATHD_FORMAT("%*saddr_v6: %pI6\n", ps2, "",
 993                                      &opts->addr.ipaddr_v6);
 994                 } else {
 995                         PATHD_FORMAT("%*saddr_v6: undefined", ps2, "");
 996                 }
 997                 PATHD_FORMAT("%*sport: %i\n", ps2, "", opts->port);
 998                 PATHD_FORMAT("%*smsd: %i\n", ps2, "", opts->msd);
 999         }
1000 }
1001
1002 void _format_pce_opts(int ps, struct pce_opts *opts)
1003 {
1004         if (opts == NULL) {
1005                 PATHD_FORMAT("NULL\n");
1006         } else {
1007                 int ps2 = ps + DEBUG_IDENT_SIZE;
1008                 PATHD_FORMAT("\n");
1009                 if (IS_IPADDR_V6(&opts->addr)) {
1010                         PATHD_FORMAT("%*saddr: %pI6\n", ps2, "",
1011                                      &opts->addr.ipaddr_v6);
1012                 } else {
1013                         PATHD_FORMAT("%*saddr: %pI4\n", ps2, "",
1014                                      &opts->addr.ipaddr_v4);
1015                 }
1016                 PATHD_FORMAT("%*sport: %i\n", ps2, "", opts->port);
1017         }
1018 }
1019
1020 void _format_pcc_caps(int ps, struct pcep_caps *caps)
1021 {
1022         int ps2 = ps + DEBUG_IDENT_SIZE;
1023         PATHD_FORMAT("\n");
1024         PATHD_FORMAT("%*sis_stateful: %d\n", ps2, "", caps->is_stateful);
1025 }
1026
1027 void _format_pcc_state(int ps, struct pcc_state *state)
1028 {
1029         if (state == NULL) {
1030                 PATHD_FORMAT("NULL\n");
1031         } else {
1032                 int ps2 = ps + DEBUG_IDENT_SIZE;
1033                 PATHD_FORMAT("\n");
1034                 PATHD_FORMAT("%*sstatus: %s\n", ps2, "",
1035                              pcc_status_name(state->status));
1036                 PATHD_FORMAT("%*spcc_opts: ", ps2, "");
1037                 _format_pcc_opts(ps2, state->pcc_opts);
1038                 PATHD_FORMAT("%*spce_opts: ", ps2, "");
1039                 _format_pce_opts(ps2, state->pce_opts);
1040                 if (state->sess == NULL) {
1041                         PATHD_FORMAT("%*ssess: NULL\n", ps2, "");
1042                 } else {
1043                         PATHD_FORMAT("%*ssess: <PCC SESSION %p>\n", ps2, "",
1044                                      state->sess);
1045                 }
1046                 PATHD_FORMAT("%*scaps: ", ps2, "");
1047                 _format_pcc_caps(ps2, &state->caps);
1048         }
1049 }
1050
1051 void _format_ctrl_state(int ps, struct ctrl_state *state)
1052 {
1053         if (state == NULL) {
1054                 PATHD_FORMAT("NULL\n");
1055         } else {
1056                 int i;
1057                 int ps2 = ps + DEBUG_IDENT_SIZE;
1058                 int ps3 = ps2 + DEBUG_IDENT_SIZE;
1059                 PATHD_FORMAT("\n");
1060                 if (state->main == NULL) {
1061                         PATHD_FORMAT("%*smain: NULL\n", ps2, "");
1062                 } else {
1063                         PATHD_FORMAT("%*smain: <THREAD MASTER %p>\n", ps2, "",
1064                                      state->main);
1065                 }
1066                 if (state->self == NULL) {
1067                         PATHD_FORMAT("%*sself: NULL\n", ps2, "");
1068                 } else {
1069                         PATHD_FORMAT("%*sself: <THREAD MASTER %p>\n", ps2, "",
1070                                      state->self);
1071                 }
1072                 PATHD_FORMAT("%*spcc_count: %d\n", ps2, "", state->pcc_count);
1073                 PATHD_FORMAT("%*spcc:\n", ps2, "");
1074                 for (i = 0; i < MAX_PCC; i++) {
1075                         if (state->pcc[i]) {
1076                                 PATHD_FORMAT("%*s- ", ps3 - 2, "");
1077                                 _format_pcc_state(ps3, state->pcc[i]);
1078                         }
1079                 }
1080         }
1081 }
1082
1083 void _format_path(int ps, struct path *path)
1084 {
1085         if (path == NULL) {
1086                 PATHD_FORMAT("NULL\n");
1087         } else {
1088                 int ps2 = ps + DEBUG_IDENT_SIZE;
1089                 int ps3 = ps2 + DEBUG_IDENT_SIZE;
1090                 PATHD_FORMAT("\n");
1091                 PATHD_FORMAT("%*snbkey: \n", ps2, "");
1092                 PATHD_FORMAT("%*scolor: %u\n", ps3, "", path->nbkey.color);
1093                 switch (path->nbkey.endpoint.ipa_type) {
1094                 case IPADDR_V4:
1095                         PATHD_FORMAT("%*sendpoint: %pI4\n", ps3, "",
1096                                      &path->nbkey.endpoint.ipaddr_v4);
1097                         break;
1098                 case IPADDR_V6:
1099                         PATHD_FORMAT("%*sendpoint: %pI6\n", ps3, "",
1100                                      &path->nbkey.endpoint.ipaddr_v6);
1101                         break;
1102                 default:
1103                         PATHD_FORMAT("%*sendpoint: NONE\n", ps3, "");
1104                         break;
1105                 }
1106                 PATHD_FORMAT("%*spreference: %u\n", ps3, "",
1107                              path->nbkey.preference);
1108
1109                 if (path->sender.ipa_type == IPADDR_V4) {
1110                         PATHD_FORMAT("%*ssender: %pI4\n", ps2, "",
1111                                      &path->sender.ipaddr_v4);
1112                 } else if (path->sender.ipa_type == IPADDR_V6) {
1113                         PATHD_FORMAT("%*ssender: %pI6\n", ps2, "",
1114                                      &path->sender.ipaddr_v6);
1115                 } else {
1116                         PATHD_FORMAT("%*ssender: UNDEFINED\n", ps2, "");
1117                 }
1118                 if (path->pcc_addr.ipa_type == IPADDR_V4) {
1119                         PATHD_FORMAT("%*spcc_addr: %pI4\n", ps2, "",
1120                                      &path->pcc_addr.ipaddr_v4);
1121                 } else if (path->pcc_addr.ipa_type == IPADDR_V6) {
1122                         PATHD_FORMAT("%*spcc_addr: %pI6\n", ps2, "",
1123                                      &path->pcc_addr.ipaddr_v6);
1124                 } else {
1125                         PATHD_FORMAT("%*spcc_addr: UNDEFINED\n", ps2, "");
1126                 }
1127                 PATHD_FORMAT("%*spcc_id: %u\n", ps2, "", path->pcc_id);
1128                 PATHD_FORMAT("%*screate_origin: %s (%u)\n", ps2, "",
1129                              srte_protocol_origin_name(path->create_origin),
1130                              path->create_origin);
1131                 PATHD_FORMAT("%*supdate_origin: %s (%u)\n", ps2, "",
1132                              srte_protocol_origin_name(path->update_origin),
1133                              path->update_origin);
1134                 if (path->originator != NULL) {
1135                         PATHD_FORMAT("%*soriginator: %s\n", ps2, "",
1136                                      path->originator);
1137                 } else {
1138                         PATHD_FORMAT("%*soriginator: UNDEFINED\n", ps2, "");
1139                 }
1140                 PATHD_FORMAT("%*stype: %s (%u)\n", ps2, "",
1141                              srte_candidate_type_name(path->type), path->type);
1142                 PATHD_FORMAT("%*splsp_id: %u\n", ps2, "", path->plsp_id);
1143                 if (path->name == NULL) {
1144                         PATHD_FORMAT("%*sname: NULL\n", ps2, "");
1145                 } else {
1146                         PATHD_FORMAT("%*sname: %s\n", ps2, "", path->name);
1147                 }
1148                 PATHD_FORMAT("%*ssrp_id: %u\n", ps2, "", path->srp_id);
1149                 PATHD_FORMAT("%*sreq_id: %u\n", ps2, "", path->req_id);
1150                 PATHD_FORMAT("%*sstatus: %s (%u)\n", ps2, "",
1151                              pcep_lsp_status_name(path->status), path->status);
1152                 PATHD_FORMAT("%*sdo_remove: %u\n", ps2, "", path->do_remove);
1153                 PATHD_FORMAT("%*sgo_active: %u\n", ps2, "", path->go_active);
1154                 PATHD_FORMAT("%*swas_created: %u\n", ps2, "",
1155                              path->was_created);
1156                 PATHD_FORMAT("%*swas_removed: %u\n", ps2, "",
1157                              path->was_removed);
1158                 PATHD_FORMAT("%*sis_synching: %u\n", ps2, "",
1159                              path->is_synching);
1160                 PATHD_FORMAT("%*sis_delegated: %u\n", ps2, "",
1161                              path->is_delegated);
1162                 PATHD_FORMAT("%*shas_bandwidth: %u\n", ps2, "",
1163                              path->has_bandwidth);
1164                 if (path->has_bandwidth) {
1165                         PATHD_FORMAT("%*senforce_bandwidth: %u\n", ps2, "",
1166                                      path->enforce_bandwidth);
1167                         PATHD_FORMAT("%*sbandwidth: %f\n", ps2, "",
1168                                      path->bandwidth);
1169                 }
1170                 PATHD_FORMAT("%*shas_pcc_objfun: %u\n", ps2, "",
1171                              path->has_pcc_objfun);
1172                 if (path->has_pcc_objfun) {
1173                         PATHD_FORMAT("%*senforce_pcc_objfun: %d\n", ps2, "",
1174                                      path->enforce_pcc_objfun);
1175                         PATHD_FORMAT("%*spcc_objfun: %s (%u)\n", ps2, "",
1176                                      objfun_type_name(path->pcc_objfun),
1177                                      path->pcc_objfun);
1178                 }
1179                 PATHD_FORMAT("%*shas_pce_objfun: %u\n", ps2, "",
1180                              path->has_pce_objfun);
1181                 if (path->has_pce_objfun)
1182                         PATHD_FORMAT("%*spce_objfun: %s (%u)\n", ps2, "",
1183                                      objfun_type_name(path->pce_objfun),
1184                                      path->pce_objfun);
1185                 PATHD_FORMAT("%*shas_affinity_filters: %u\n", ps2, "",
1186                              path->has_affinity_filters);
1187                 if (path->has_affinity_filters) {
1188                         PATHD_FORMAT("%*sexclude_any: 0x%08x\n", ps2, "",
1189                                      path->affinity_filters
1190                                              [AFFINITY_FILTER_EXCLUDE_ANY - 1]);
1191                         PATHD_FORMAT("%*sinclude_any: 0x%08x\n", ps2, "",
1192                                      path->affinity_filters
1193                                              [AFFINITY_FILTER_INCLUDE_ANY - 1]);
1194                         PATHD_FORMAT("%*sinclude_all: 0x%08x\n", ps2, "",
1195                                      path->affinity_filters
1196                                              [AFFINITY_FILTER_INCLUDE_ALL - 1]);
1197                 }
1198
1199                 if (path->first_hop == NULL) {
1200                         PATHD_FORMAT("%*shops: []\n", ps2, "");
1201                 } else {
1202                         PATHD_FORMAT("%*shops: \n", ps2, "");
1203                         for (struct path_hop *hop = path->first_hop;
1204                              hop != NULL; hop = hop->next) {
1205                                 PATHD_FORMAT("%*s- ", ps3 - 2, "");
1206                                 _format_path_hop(ps3, hop);
1207                         }
1208                 }
1209                 if (path->first_metric == NULL) {
1210                         PATHD_FORMAT("%*smetrics: []\n", ps2, "");
1211                 } else {
1212                         PATHD_FORMAT("%*smetrics: \n", ps2, "");
1213                         for (struct path_metric *metric = path->first_metric;
1214                              NULL != metric; metric = metric->next) {
1215                                 PATHD_FORMAT("%*s- ", ps3 - 2, "");
1216                                 _format_path_metric(ps3, metric);
1217                         }
1218                 }
1219         }
1220 }
1221
1222 void _format_path_metric(int ps, struct path_metric *metric)
1223 {
1224         PATHD_FORMAT("type: %s (%u)\n", pcep_metric_type_name(metric->type),
1225                      metric->type);
1226         PATHD_FORMAT("%*senforce: %u\n", ps, "", metric->enforce);
1227         PATHD_FORMAT("%*sis_bound: %u\n", ps, "", metric->is_bound);
1228         PATHD_FORMAT("%*sis_computed: %u\n", ps, "", metric->is_computed);
1229         PATHD_FORMAT("%*svalue: %f\n", ps, "", metric->value);
1230 }
1231
1232 void _format_path_hop(int ps, struct path_hop *hop)
1233 {
1234         PATHD_FORMAT("is_loose: %u\n", hop->is_loose);
1235         PATHD_FORMAT("%*shas_sid: %u\n", ps, "", hop->has_sid);
1236
1237         if (hop->has_sid) {
1238                 PATHD_FORMAT("%*sis_mpls: %u\n", ps, "", hop->is_mpls);
1239                 if (hop->is_mpls) {
1240                         PATHD_FORMAT("%*shas_attribs: %u\n", ps, "",
1241                                      hop->has_attribs);
1242                         PATHD_FORMAT("%*slabel: %u\n", ps, "",
1243                                      hop->sid.mpls.label);
1244                         if (hop->has_attribs) {
1245                                 PATHD_FORMAT("%*straffic_class: %u\n", ps, "",
1246                                              hop->sid.mpls.traffic_class);
1247                                 PATHD_FORMAT("%*sis_bottom: %u\n", ps, "",
1248                                              hop->sid.mpls.is_bottom);
1249                                 PATHD_FORMAT("%*sttl: %u\n", ps, "",
1250                                              hop->sid.mpls.ttl);
1251                         }
1252                 } else {
1253                         PATHD_FORMAT("%*sSID: %u\n", ps, "", hop->sid.value);
1254                 }
1255         }
1256
1257         PATHD_FORMAT("%*shas_nai: %u\n", ps, "", hop->has_nai);
1258         if (hop->has_nai) {
1259                 PATHD_FORMAT("%*snai_type: %s (%u)\n", ps, "",
1260                              pcep_nai_type_name(hop->nai.type), hop->nai.type);
1261                 switch (hop->nai.type) {
1262                 case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
1263                         PATHD_FORMAT("%*sNAI: %pI4\n", ps, "",
1264                                      &hop->nai.local_addr.ipaddr_v4);
1265                         break;
1266                 case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
1267                         PATHD_FORMAT("%*sNAI: %pI6\n", ps, "",
1268                                      &hop->nai.local_addr.ipaddr_v6);
1269                         break;
1270                 case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
1271                         PATHD_FORMAT("%*sNAI: %pI4/%pI4\n", ps, "",
1272                                      &hop->nai.local_addr.ipaddr_v4,
1273                                      &hop->nai.remote_addr.ipaddr_v4);
1274                         break;
1275                 case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
1276                         PATHD_FORMAT("%*sNAI: %pI6/%pI6\n", ps, "",
1277                                      &hop->nai.local_addr.ipaddr_v6,
1278                                      &hop->nai.remote_addr.ipaddr_v6);
1279                         break;
1280                 case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
1281                         PATHD_FORMAT("%*sNAI: %pI6(%u)/%pI6(%u)\n", ps, "",
1282                                      &hop->nai.local_addr.ipaddr_v6,
1283                                      hop->nai.local_iface,
1284                                      &hop->nai.remote_addr.ipaddr_v6,
1285                                      hop->nai.remote_iface);
1286                         break;
1287                 default:
1288                         PATHD_FORMAT("%*sNAI: UNSUPPORTED\n", ps, "");
1289                         break;
1290                 }
1291         }
1292 }
1293
1294 void _format_pcep_event(int ps, pcep_event *event)
1295 {
1296         if (event == NULL) {
1297                 PATHD_FORMAT("NULL\n");
1298         } else {
1299                 int ps2 = ps + DEBUG_IDENT_SIZE;
1300                 PATHD_FORMAT("\n");
1301                 PATHD_FORMAT("%*sevent_type: %s\n", ps2, "",
1302                              pcep_event_type_name(event->event_type));
1303                 PATHD_FORMAT("%*sevent_time: %s", ps2, "",
1304                              ctime(&event->event_time));
1305                 if (event->session == NULL) {
1306                         PATHD_FORMAT("%*ssession: NULL\n", ps2, "");
1307                 } else {
1308                         PATHD_FORMAT("%*ssession: <PCC SESSION %p>\n", ps2, "",
1309                                      event->session);
1310                 }
1311                 PATHD_FORMAT("%*smessage: ", ps2, "");
1312                 _format_pcep_message(ps2, event->message);
1313         }
1314 }
1315
1316 void _format_pcep_message(int ps, struct pcep_message *msg)
1317 {
1318         if (msg == NULL) {
1319                 PATHD_FORMAT("NULL\n");
1320         } else {
1321                 int ps2 = ps + DEBUG_IDENT_SIZE;
1322                 PATHD_FORMAT("\n");
1323                 PATHD_FORMAT("%*spcep_version: %u\n", ps2, "",
1324                              msg->msg_header->pcep_version);
1325                 PATHD_FORMAT("%*stype: %s (%u)\n", ps2, "",
1326                              pcep_message_type_name(msg->msg_header->type),
1327                              msg->msg_header->type);
1328                 PATHD_FORMAT("%*sobjects: ", ps2, "");
1329                 _format_pcep_objects(ps2, msg->obj_list);
1330         }
1331 }
1332
1333 void _format_pcep_objects(int ps, double_linked_list *objs)
1334 {
1335         if (objs == NULL) {
1336                 PATHD_FORMAT("NULL\n");
1337         } else {
1338                 double_linked_list_node *node;
1339                 int ps2 = ps + DEBUG_IDENT_SIZE;
1340                 int i;
1341
1342                 if (objs->num_entries == 0) {
1343                         PATHD_FORMAT("[]\n");
1344                         return;
1345                 }
1346
1347                 PATHD_FORMAT("\n");
1348                 for (node = objs->head, i = 0; node != NULL;
1349                      node = node->next_node, i++) {
1350                         struct pcep_object_header *obj =
1351                                 (struct pcep_object_header *)node->data;
1352                         PATHD_FORMAT("%*s- ", ps2 - 2, "");
1353                         _format_pcep_object(ps2, obj);
1354                 }
1355         }
1356 }
1357
1358 void _format_pcep_object(int ps, struct pcep_object_header *obj)
1359 {
1360         if (obj == NULL) {
1361                 PATHD_FORMAT("NULL\n");
1362         } else {
1363                 PATHD_FORMAT("object_class: %s (%u)\n",
1364                              pcep_object_class_name(obj->object_class),
1365                              obj->object_class);
1366                 PATHD_FORMAT("%*sobject_type: %s (%u)\n", ps, "",
1367                              pcep_object_type_name(obj->object_class,
1368                                                    obj->object_type),
1369                              obj->object_type);
1370                 PATHD_FORMAT("%*sflag_p: %u\n", ps, "", obj->flag_p);
1371                 PATHD_FORMAT("%*sflag_i: %u\n", ps, "", obj->flag_i);
1372                 _format_pcep_object_details(ps, obj);
1373                 _format_pcep_object_tlvs(ps, obj);
1374         }
1375 }
1376
1377 void _format_pcep_object_details(int ps, struct pcep_object_header *obj)
1378 {
1379         switch (TUP(obj->object_class, obj->object_type)) {
1380         case TUP(PCEP_OBJ_CLASS_ERROR, PCEP_OBJ_TYPE_ERROR):
1381                 _format_pcep_object_error(ps, (struct pcep_object_error *)obj);
1382                 break;
1383         case TUP(PCEP_OBJ_CLASS_OPEN, PCEP_OBJ_TYPE_OPEN):
1384                 _format_pcep_object_open(ps, (struct pcep_object_open *)obj);
1385                 break;
1386         case TUP(PCEP_OBJ_CLASS_RP, PCEP_OBJ_TYPE_RP):
1387                 _format_pcep_object_rp(ps, (struct pcep_object_rp *)obj);
1388                 break;
1389         case TUP(PCEP_OBJ_CLASS_SRP, PCEP_OBJ_TYPE_SRP):
1390                 _format_pcep_object_srp(ps, (struct pcep_object_srp *)obj);
1391                 break;
1392         case TUP(PCEP_OBJ_CLASS_LSP, PCEP_OBJ_TYPE_LSP):
1393                 _format_pcep_object_lsp(ps, (struct pcep_object_lsp *)obj);
1394                 break;
1395         case TUP(PCEP_OBJ_CLASS_LSPA, PCEP_OBJ_TYPE_LSPA):
1396                 _format_pcep_object_lspa(ps, (struct pcep_object_lspa *)obj);
1397                 break;
1398         case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV4):
1399                 _format_pcep_object_ipv4_endpoint(
1400                         ps, (struct pcep_object_endpoints_ipv4 *)obj);
1401                 break;
1402         case TUP(PCEP_OBJ_CLASS_ERO, PCEP_OBJ_TYPE_ERO):
1403                 _format_pcep_object_ro(ps, (struct pcep_object_ro *)obj);
1404                 break;
1405         case TUP(PCEP_OBJ_CLASS_METRIC, PCEP_OBJ_TYPE_METRIC):
1406                 _format_pcep_object_metric(ps,
1407                                            (struct pcep_object_metric *)obj);
1408                 break;
1409         case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_REQ):
1410         case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_CISCO):
1411                 _format_pcep_object_bandwidth(
1412                         ps, (struct pcep_object_bandwidth *)obj);
1413                 break;
1414         case TUP(PCEP_OBJ_CLASS_NOPATH, PCEP_OBJ_TYPE_NOPATH):
1415                 _format_pcep_object_nopath(ps,
1416                                            (struct pcep_object_nopath *)obj);
1417                 break;
1418         case TUP(PCEP_OBJ_CLASS_OF, PCEP_OBJ_TYPE_OF):
1419                 _format_pcep_object_objfun(
1420                         ps, (struct pcep_object_objective_function *)obj);
1421                 break;
1422         default:
1423                 PATHD_FORMAT("%*s...\n", ps, "");
1424                 break;
1425         }
1426 }
1427
1428 void _format_pcep_object_error(int ps, struct pcep_object_error *obj)
1429 {
1430         PATHD_FORMAT("%*serror_type: %s (%u)\n", ps, "",
1431                      pcep_error_type_name(obj->error_type), obj->error_type);
1432         PATHD_FORMAT("%*serror_value: %s (%u)\n", ps, "",
1433                      pcep_error_value_name(obj->error_type, obj->error_value),
1434                      obj->error_value);
1435 }
1436
1437
1438 void _format_pcep_object_open(int ps, struct pcep_object_open *obj)
1439 {
1440         PATHD_FORMAT("%*sopen_version: %u\n", ps, "", obj->open_version);
1441         PATHD_FORMAT("%*sopen_keepalive: %u\n", ps, "", obj->open_keepalive);
1442         PATHD_FORMAT("%*sopen_deadtimer: %u\n", ps, "", obj->open_deadtimer);
1443         PATHD_FORMAT("%*sopen_sid: %u\n", ps, "", obj->open_sid);
1444 }
1445
1446 void _format_pcep_object_rp(int ps, struct pcep_object_rp *obj)
1447 {
1448         PATHD_FORMAT("%*spriority: %u\n", ps, "", obj->priority);
1449         PATHD_FORMAT("%*sflag_reoptimization: %u\n", ps, "",
1450                      obj->flag_reoptimization);
1451         PATHD_FORMAT("%*sflag_bidirectional: %u\n", ps, "",
1452                      obj->flag_bidirectional);
1453         PATHD_FORMAT("%*sflag_strict: %u\n", ps, "", obj->flag_strict);
1454         PATHD_FORMAT("%*sflag_of: %u\n", ps, "", obj->flag_of);
1455         PATHD_FORMAT("%*srequest_id: %u\n", ps, "", obj->request_id);
1456 }
1457
1458
1459 void _format_pcep_object_srp(int ps, struct pcep_object_srp *obj)
1460 {
1461         PATHD_FORMAT("%*sflag_lsp_remove: %u\n", ps, "", obj->flag_lsp_remove);
1462         PATHD_FORMAT("%*ssrp_id_number: %u\n", ps, "", obj->srp_id_number);
1463 }
1464
1465 void _format_pcep_object_lsp(int ps, struct pcep_object_lsp *obj)
1466 {
1467         PATHD_FORMAT("%*splsp_id: %u\n", ps, "", obj->plsp_id);
1468         PATHD_FORMAT("%*sstatus: %s\n", ps, "",
1469                      pcep_lsp_status_name(obj->operational_status));
1470         PATHD_FORMAT("%*sflag_d: %u\n", ps, "", obj->flag_d);
1471         PATHD_FORMAT("%*sflag_s: %u\n", ps, "", obj->flag_s);
1472         PATHD_FORMAT("%*sflag_r: %u\n", ps, "", obj->flag_r);
1473         PATHD_FORMAT("%*sflag_a: %u\n", ps, "", obj->flag_a);
1474         PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1475 }
1476
1477 void _format_pcep_object_lspa(int ps, struct pcep_object_lspa *obj)
1478 {
1479         PATHD_FORMAT("%*slspa_exclude_any: 0x%08x\n", ps, "",
1480                      obj->lspa_exclude_any);
1481         PATHD_FORMAT("%*slspa_include_any: 0x%08x\n", ps, "",
1482                      obj->lspa_include_any);
1483         PATHD_FORMAT("%*slspa_include_all: 0x%08x\n", ps, "",
1484                      obj->lspa_include_all);
1485         PATHD_FORMAT("%*ssetup_priority: %u\n", ps, "", obj->setup_priority);
1486         PATHD_FORMAT("%*sholding_priority: %u\n", ps, "",
1487                      obj->holding_priority);
1488         PATHD_FORMAT("%*sflag_local_protection: %u\n", ps, "",
1489                      obj->flag_local_protection);
1490 }
1491
1492 void _format_pcep_object_ipv4_endpoint(int ps,
1493                                        struct pcep_object_endpoints_ipv4 *obj)
1494 {
1495         PATHD_FORMAT("%*ssrc_ipv4: %pI4\n", ps, "", &obj->src_ipv4);
1496         PATHD_FORMAT("%*sdst_ipv4: %pI4\n", ps, "", &obj->dst_ipv4);
1497 }
1498
1499 void _format_pcep_object_metric(int ps, struct pcep_object_metric *obj)
1500 {
1501         PATHD_FORMAT("%*stype: %s (%u)\n", ps, "",
1502                      pcep_metric_type_name(obj->type), obj->type);
1503         PATHD_FORMAT("%*sflag_b: %u\n", ps, "", obj->flag_b);
1504         PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1505         PATHD_FORMAT("%*svalue: %f\n", ps, "", obj->value);
1506 }
1507
1508 void _format_pcep_object_bandwidth(int ps, struct pcep_object_bandwidth *obj)
1509 {
1510         PATHD_FORMAT("%*sbandwidth: %f\n", ps, "", obj->bandwidth);
1511 }
1512
1513 void _format_pcep_object_nopath(int ps, struct pcep_object_nopath *obj)
1514 {
1515         PATHD_FORMAT("%*sni: %u\n", ps, "", obj->ni);
1516         PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1517         PATHD_FORMAT("%*serr_code: %s (%u)\n", ps, "",
1518                      pcep_nopath_tlv_err_code_name(obj->err_code),
1519                      obj->err_code);
1520 }
1521
1522 void _format_pcep_object_objfun(int ps,
1523                                 struct pcep_object_objective_function *obj)
1524 {
1525         PATHD_FORMAT("%*sof_code: %s (%u)\n", ps, "",
1526                      objfun_type_name(obj->of_code), obj->of_code);
1527 }
1528
1529 void _format_pcep_object_ro(int ps, struct pcep_object_ro *obj)
1530 {
1531         double_linked_list *obj_list = obj->sub_objects;
1532         double_linked_list_node *node;
1533         struct pcep_object_ro_subobj *sub_obj;
1534
1535         int ps2 = ps + DEBUG_IDENT_SIZE;
1536         int i;
1537
1538         if ((obj_list == NULL) || (obj_list->num_entries == 0)) {
1539                 PATHD_FORMAT("%*ssub_objects: []\n", ps, "");
1540                 return;
1541         }
1542
1543         PATHD_FORMAT("%*ssub_objects:\n", ps, "");
1544
1545         for (node = obj_list->head, i = 0; node != NULL;
1546              node = node->next_node, i++) {
1547                 sub_obj = (struct pcep_object_ro_subobj *)node->data;
1548                 PATHD_FORMAT("%*s- flag_subobj_loose_hop: %u\n", ps2 - 2, "",
1549                              sub_obj->flag_subobj_loose_hop);
1550                 PATHD_FORMAT("%*sro_subobj_type: %s (%u)\n", ps2, "",
1551                              pcep_ro_type_name(sub_obj->ro_subobj_type),
1552                              sub_obj->ro_subobj_type);
1553                 _format_pcep_object_ro_details(ps2, sub_obj);
1554         }
1555 }
1556
1557 void _format_pcep_object_ro_details(int ps, struct pcep_object_ro_subobj *ro)
1558 {
1559         switch (ro->ro_subobj_type) {
1560         case RO_SUBOBJ_TYPE_IPV4:
1561                 _format_pcep_object_ro_ipv4(ps,
1562                                             (struct pcep_ro_subobj_ipv4 *)ro);
1563                 break;
1564         case RO_SUBOBJ_TYPE_SR:
1565                 _format_pcep_object_ro_sr(ps, (struct pcep_ro_subobj_sr *)ro);
1566                 break;
1567         default:
1568                 PATHD_FORMAT("%*s...\n", ps, "");
1569                 break;
1570         }
1571 }
1572
1573 void _format_pcep_object_ro_ipv4(int ps, struct pcep_ro_subobj_ipv4 *obj)
1574 {
1575         PATHD_FORMAT("%*sip_addr: %pI4\n", ps, "", &obj->ip_addr);
1576         PATHD_FORMAT("%*sprefix_length: %u\n", ps, "", obj->prefix_length);
1577         PATHD_FORMAT("%*sflag_local_protection: %u\n", ps, "",
1578                      obj->flag_local_protection);
1579 }
1580
1581 void _format_pcep_object_ro_sr(int ps, struct pcep_ro_subobj_sr *obj)
1582 {
1583         PATHD_FORMAT("%*snai_type = %s (%u)\n", ps, "",
1584                      pcep_nai_type_name(obj->nai_type), obj->nai_type);
1585         PATHD_FORMAT("%*sflag_f: %u\n", ps, "", obj->flag_f);
1586         PATHD_FORMAT("%*sflag_s: %u\n", ps, "", obj->flag_s);
1587         PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
1588         PATHD_FORMAT("%*sflag_m: %u\n", ps, "", obj->flag_m);
1589
1590         if (!obj->flag_s) {
1591                 PATHD_FORMAT("%*sSID: %u\n", ps, "", obj->sid);
1592                 if (obj->flag_m) {
1593                         PATHD_FORMAT("%*slabel: %u\n", ps, "",
1594                                      GET_SR_ERO_SID_LABEL(obj->sid));
1595                         if (obj->flag_c) {
1596                                 PATHD_FORMAT("%*sTC: %u\n", ps, "",
1597                                              GET_SR_ERO_SID_TC(obj->sid));
1598                                 PATHD_FORMAT("%*sS: %u\n", ps, "",
1599                                              GET_SR_ERO_SID_S(obj->sid));
1600                                 PATHD_FORMAT("%*sTTL: %u\n", ps, "",
1601                                              GET_SR_ERO_SID_TTL(obj->sid));
1602                         }
1603                 }
1604         }
1605
1606         if (!obj->flag_f) {
1607                 struct in_addr *laddr4, *raddr4;
1608                 struct in6_addr *laddr6, *raddr6;
1609                 uint32_t *liface, *riface;
1610                 assert(obj->nai_list != NULL);
1611                 double_linked_list_node *n = obj->nai_list->head;
1612                 assert(n != NULL);
1613                 assert(n->data != NULL);
1614                 switch (obj->nai_type) {
1615                 case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
1616                         laddr4 = (struct in_addr *)n->data;
1617                         PATHD_FORMAT("%*sNAI: %pI4\n", ps, "", laddr4);
1618                         break;
1619                 case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
1620                         laddr6 = (struct in6_addr *)n->data;
1621                         PATHD_FORMAT("%*sNAI: %pI6\n", ps, "", laddr6);
1622                         break;
1623                 case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
1624                         assert(n->next_node != NULL);
1625                         assert(n->next_node->data != NULL);
1626                         laddr4 = (struct in_addr *)n->data;
1627                         raddr4 = (struct in_addr *)n->next_node->data;
1628                         PATHD_FORMAT("%*sNAI: %pI4/%pI4\n", ps, "", laddr4,
1629                                      raddr4);
1630                         break;
1631                 case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
1632                         assert(n->next_node != NULL);
1633                         assert(n->next_node->data != NULL);
1634                         laddr6 = (struct in6_addr *)n->data;
1635                         raddr6 = (struct in6_addr *)n->next_node->data;
1636                         PATHD_FORMAT("%*sNAI: %pI6/%pI6\n", ps, "", laddr6,
1637                                      raddr6);
1638                         break;
1639                 case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
1640                         laddr4 = (struct in_addr *)n->data;
1641                         n = n->next_node;
1642                         assert(n != NULL);
1643                         assert(n->data != NULL);
1644                         liface = (uint32_t *)n->data;
1645                         n = n->next_node;
1646                         assert(n != NULL);
1647                         assert(n->data != NULL);
1648                         raddr4 = (struct in_addr *)n->data;
1649                         assert(n != NULL);
1650                         assert(n->data != NULL);
1651                         riface = (uint32_t *)n->data;
1652                         PATHD_FORMAT("%*sNAI: %pI4(%u)/%pI4(%u)\n", ps, "",
1653                                      laddr4, *liface, raddr4, *riface);
1654                         break;
1655                 default:
1656                         PATHD_FORMAT("%*sNAI: UNSUPPORTED\n", ps, "");
1657                         break;
1658                 }
1659         }
1660 }
1661
1662 void _format_pcep_object_tlvs(int ps, struct pcep_object_header *obj)
1663 {
1664         double_linked_list *tlv_list = obj->tlv_list;
1665         struct pcep_object_tlv_header *tlv;
1666         double_linked_list_node *node;
1667         int ps2 = ps + DEBUG_IDENT_SIZE;
1668         int i = 0;
1669
1670         if (tlv_list == NULL)
1671                 return;
1672         if (tlv_list->num_entries == 0) {
1673                 PATHD_FORMAT("%*stlvs: []\n", ps, "");
1674                 return;
1675         }
1676
1677         PATHD_FORMAT("%*stlvs:\n", ps, "");
1678
1679         for (node = tlv_list->head, i = 0; node != NULL;
1680              node = node->next_node, i++) {
1681                 tlv = (struct pcep_object_tlv_header *)node->data;
1682                 PATHD_FORMAT("%*s- ", ps2 - 2, "");
1683                 _format_pcep_object_tlv(ps2, tlv);
1684         }
1685 }
1686
1687 void _format_pcep_object_tlv(int ps, struct pcep_object_tlv_header *tlv_header)
1688 {
1689         PATHD_FORMAT("type: %s (%u)\n", pcep_tlv_type_name(tlv_header->type),
1690                      tlv_header->type);
1691         _format_pcep_object_tlv_details(ps, tlv_header);
1692 }
1693
1694 void _format_pcep_object_tlv_details(int ps,
1695                                      struct pcep_object_tlv_header *tlv_header)
1696 {
1697         switch (tlv_header->type) {
1698         case PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME:
1699                 _format_pcep_object_tlv_symbolic_path_name(
1700                         ps, (struct pcep_object_tlv_symbolic_path_name *)
1701                                     tlv_header);
1702                 break;
1703         case PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY:
1704                 _format_pcep_object_tlv_stateful_pce_capability(
1705                         ps, (struct pcep_object_tlv_stateful_pce_capability *)
1706                                     tlv_header);
1707                 break;
1708         case PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY:
1709                 _format_pcep_object_tlv_sr_pce_capability(
1710                         ps,
1711                         (struct pcep_object_tlv_sr_pce_capability *)tlv_header);
1712                 break;
1713         case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
1714                 _format_pcep_object_tlv_path_setup_type(
1715                         ps,
1716                         (struct pcep_object_tlv_path_setup_type *)tlv_header);
1717                 break;
1718         default:
1719                 PATHD_FORMAT("%*s...\n", ps, "");
1720                 break;
1721         }
1722 }
1723
1724 void _format_pcep_object_tlv_symbolic_path_name(
1725         int ps, struct pcep_object_tlv_symbolic_path_name *tlv)
1726 {
1727         PATHD_FORMAT("%*ssymbolic_path_name: %.*s\n", ps, "",
1728                      tlv->symbolic_path_name_length, tlv->symbolic_path_name);
1729 }
1730
1731 void _format_pcep_object_tlv_stateful_pce_capability(
1732         int ps, struct pcep_object_tlv_stateful_pce_capability *tlv)
1733 {
1734         PATHD_FORMAT("%*sflag_u_lsp_update_capability: %u\n", ps, "",
1735                      tlv->flag_u_lsp_update_capability);
1736         PATHD_FORMAT("%*sflag_s_include_db_version: %u\n", ps, "",
1737                      tlv->flag_s_include_db_version);
1738         PATHD_FORMAT("%*sflag_i_lsp_instantiation_capability: %u\n", ps, "",
1739                      tlv->flag_i_lsp_instantiation_capability);
1740         PATHD_FORMAT("%*sflag_t_triggered_resync: %u\n", ps, "",
1741                      tlv->flag_t_triggered_resync);
1742         PATHD_FORMAT("%*sflag_d_delta_lsp_sync: %u\n", ps, "",
1743                      tlv->flag_d_delta_lsp_sync);
1744         PATHD_FORMAT("%*sflag_f_triggered_initial_sync: %u\n", ps, "",
1745                      tlv->flag_f_triggered_initial_sync);
1746 }
1747
1748 void _format_pcep_object_tlv_sr_pce_capability(
1749         int ps, struct pcep_object_tlv_sr_pce_capability *tlv)
1750 {
1751
1752         PATHD_FORMAT("%*sflag_n: %u\n", ps, "", tlv->flag_n);
1753         PATHD_FORMAT("%*sflag_x: %u\n", ps, "", tlv->flag_x);
1754         PATHD_FORMAT("%*smax_sid_depth: %u\n", ps, "", tlv->max_sid_depth);
1755 }
1756
1757 void _format_pcep_object_tlv_path_setup_type(
1758         int ps, struct pcep_object_tlv_path_setup_type *tlv)
1759 {
1760         PATHD_FORMAT("%*spath_setup_type: %u\n", ps, "", tlv->path_setup_type);
1761 }