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