From 1f153089e75a262d3119c2a72036ec3d67a278f9 Mon Sep 17 00:00:00 2001 From: Ojas Gupta Date: Sun, 19 Nov 2017 01:25:28 -0800 Subject: [PATCH 1/2] Added BGPLS parsing feature in the library --- lib/bgp/parsebgp_bgp_update.c | 20 +- lib/bgp/parsebgp_bgp_update.h | 4 + lib/bgp/parsebgp_bgp_update_bgp_ls.c | 754 +++++++++++++++++++++++++++ lib/bgp/parsebgp_bgp_update_bgp_ls.h | 409 +++++++++++++++ 4 files changed, 1178 insertions(+), 9 deletions(-) create mode 100644 lib/bgp/parsebgp_bgp_update_bgp_ls.c create mode 100644 lib/bgp/parsebgp_bgp_update_bgp_ls.h diff --git a/lib/bgp/parsebgp_bgp_update.c b/lib/bgp/parsebgp_bgp_update.c index d3190ef..168f388 100644 --- a/lib/bgp/parsebgp_bgp_update.c +++ b/lib/bgp/parsebgp_bgp_update.c @@ -796,12 +796,14 @@ parsebgp_error_t parsebgp_bgp_update_path_attrs_decode( // Type 29 case PARSEBGP_BGP_PATH_ATTR_TYPE_BGP_LS: - // TODO: add support for BGP-LS - PARSEBGP_SKIP_NOT_IMPLEMENTED( - opts, buf, nread, attr->len, - "BGP UPDATE Path Attribute %d (BGP-LS) is not yet implemented", - attr->type); - slen = attr->len; + PARSEBGP_MAYBE_MALLOC_ZERO(attr->data.bgp_ls); + if ((err = parsebgp_bgp_update_bgp_ls_decode( + opts, attr->data.bgp_ls, buf, &slen, attr->len)) != + PARSEBGP_OK) { + return err; + } + nread += slen; + buf += slen; break; // ... @@ -887,7 +889,7 @@ void parsebgp_bgp_update_path_attrs_destroy( break; case PARSEBGP_BGP_PATH_ATTR_TYPE_BGP_LS: - // TODO: add support for BGP-LS + parsebgp_bgp_update_bgp_ls_destroy(attr->data.bgp_ls); break; case PARSEBGP_BGP_PATH_ATTR_TYPE_LARGE_COMMUNITIES: @@ -955,7 +957,7 @@ void parsebgp_bgp_update_path_attrs_clear(parsebgp_bgp_update_path_attrs_t *msg) break; case PARSEBGP_BGP_PATH_ATTR_TYPE_BGP_LS: - // TODO: add support for BGP-LS + parsebgp_bgp_update_bgp_ls_clear(attr->data.bgp_ls); break; case PARSEBGP_BGP_PATH_ATTR_TYPE_LARGE_COMMUNITIES: @@ -1063,7 +1065,7 @@ void parsebgp_bgp_update_path_attrs_dump(parsebgp_bgp_update_path_attrs_t *msg, break; case PARSEBGP_BGP_PATH_ATTR_TYPE_BGP_LS: - PARSEBGP_DUMP_INFO(depth, "BGP-LS Support Not Implemented\n"); + parsebgp_bgp_update_bgp_ls_dump(attr->data.bgp_ls, depth); break; case PARSEBGP_BGP_PATH_ATTR_TYPE_LARGE_COMMUNITIES: diff --git a/lib/bgp/parsebgp_bgp_update.h b/lib/bgp/parsebgp_bgp_update.h index ca1788c..9188662 100644 --- a/lib/bgp/parsebgp_bgp_update.h +++ b/lib/bgp/parsebgp_bgp_update.h @@ -30,6 +30,7 @@ #include "parsebgp_bgp_common.h" #include "parsebgp_bgp_update_ext_communities.h" #include "parsebgp_bgp_update_mp_reach.h" +#include "parsebgp_bgp_update_bgp_ls.h" #include "parsebgp_error.h" #include "parsebgp_opts.h" #include @@ -377,6 +378,9 @@ typedef struct parsebgp_bgp_update_path_attr { /** LARGE COMMUNITIES */ parsebgp_bgp_update_large_communities_t *large_communities; + /** BGP LINK STATE */ + parsebgp_bgp_update_bgp_ls_t *bgp_ls; + } data; } parsebgp_bgp_update_path_attr_t; diff --git a/lib/bgp/parsebgp_bgp_update_bgp_ls.c b/lib/bgp/parsebgp_bgp_update_bgp_ls.c new file mode 100644 index 0000000..3b5b2ba --- /dev/null +++ b/lib/bgp/parsebgp_bgp_update_bgp_ls.c @@ -0,0 +1,754 @@ +#include "parsebgp_bgp_update_bgp_ls.h" +#include "parsebgp_error.h" +#include "parsebgp_utils.h" +#include +#include + +#define PARSE_SIMPLE_ATTR(attr)\ + do { \ + if (ls_attr->len != sizeof(attr)) {\ + PARSEBGP_RETURN_INVALID_MSG_ERR;\ + }\ + PARSEBGP_DESERIALIZE_VAL(buf, len, nread, (attr));\ + } while (0) + +static parsebgp_error_t +parsebgp_bgp_update_bgp_ls_tlv_decode(parsebgp_opts_t *opts, + parsebgp_bgp_update_bgp_ls_attr_t *ls_attr, + uint8_t *buf, size_t *lenp) { + + int i; + size_t nread = 0, len = *lenp; + + if (ls_attr->len > len) { + return PARSEBGP_PARTIAL_MSG; + } + + switch (ls_attr->type) { + + /** NODE ATTRIBUTES */ + // type 263 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_MT_ID: + if ((ls_attr->len % sizeof(uint16_t)) != 0) { + PARSEBGP_RETURN_INVALID_MSG_ERR; + } + + ls_attr->attr.node.node_mt_id.ids_cnt = ls_attr->len / sizeof(uint16_t); + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.node.node_mt_id.ids, + sizeof(uint16_t), + ls_attr->attr.node.node_mt_id._ids_alloc_cnt, + ls_attr->attr.node.node_mt_id.ids_cnt); + + for (i = 0; i < ls_attr->attr.node.node_mt_id.ids_cnt; i++) { + + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_mt_id.ids[i]); + + ls_attr->attr.node.node_mt_id.ids[i] = + ntohs(ls_attr->attr.node.node_mt_id.ids[i]); + } + break; + + //type 1024 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_FLAG: + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_flag_bits); + break; + + //type 1025 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_OPAQUE: + ls_attr->attr.node.node_opaque.opaque_cnt = ls_attr->len; + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.node.node_opaque.opaque, + sizeof(uint8_t), + ls_attr->attr.node.node_opaque._opaque_alloc_cnt, + ls_attr->attr.node.node_opaque.opaque_cnt); + + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_opaque.opaque); + break; + + // type 1026 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_NAME: + memcpy(ls_attr->attr.node.node_name, buf, ls_attr->len); + ls_attr->attr.node.node_name[ls_attr->len] = '\0'; + buf += ls_attr->len; + nread += ls_attr->len; + break; + + // type 1027 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_ISIS_AREA_ID: + ls_attr->attr.node.node_isis_area_id.ids_cnt = ls_attr->len; + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.node.node_isis_area_id.ids, + sizeof(uint8_t), + ls_attr->attr.node.node_isis_area_id._ids_alloc_cnt, + ls_attr->attr.node.node_isis_area_id.ids_cnt); + + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_isis_area_id.ids); + break; + + // type 1028 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_IPV4_ROUTER_ID_LOCAL: + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_ipv4_router_id_local); + break; + + // type 1029 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_IPV6_ROUTER_ID_LOCAL: + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_ipv6_router_id_local); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_CAPABILITIES: + //TODO: Ask Alistair + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_ALGORITHM: + ls_attr->attr.node.node_sr_algo.algo_cnt = ls_attr->len; + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.node.node_sr_algo.algo, + sizeof(uint8_t), + ls_attr->attr.node.node_sr_algo._algo_alloc_cnt, + ls_attr->attr.node.node_sr_algo.algo_cnt); + + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_sr_algo.algo); + + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_LOCAL_BLOCK: + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_SRMS_PREF: + PARSE_SIMPLE_ATTR(ls_attr->attr.node.node_sr_srms_pref); + break; + + /** LINK ATTRIBUTES */ + + // type = 1030 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IPV4_ROUTER_ID_REMOTE: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_ipv4_router_id_remote); + break; + + // type = 1031 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IPV6_ROUTER_ID_REMOTE: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_ipv6_router_id_remote); + break; + + // type = 1088 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_ADMIN_GROUP: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_admin_group); + break; + + // type = 1089 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MAX_LINK_BW: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_max_link_bw); + break; + + // type 1090 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MAX_RESV_BW: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_max_resv_bw); + break; + + // type 1091 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_UNRESV_BW: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_unresv_bw); + break; + + // type 1092 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_TE_DEF_METRIC: + if (ls_attr->len == 0) { + ls_attr->attr.link.link_te_def_metric = 0; + break; + } + + if (ls_attr->len > 4) { + PARSEBGP_RETURN_INVALID_MSG_ERR; + } + + memcpy(&ls_attr->attr.link.link_te_def_metric, buf, ls_attr->len); + ls_attr->attr.link.link_te_def_metric = + ntohl(ls_attr->attr.link.link_te_def_metric); + buf += ls_attr->len; + nread += ls_attr->len; + + break; + + // type 1093 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_PROTECTION_TYPE: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_protective_type); + break; + + // type 1094 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MPLS_PROTO_MASK: + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_mpls_protocal_mask); + break; + + // type 1095 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IGP_METRIC: + if (ls_attr->len > 3) { + PARSEBGP_RETURN_INVALID_MSG_ERR; + } + + memcpy(&ls_attr->attr.link.link_igp_metric, buf, ls_attr->len); + buf += ls_attr->len; + nread += ls_attr->len; + + ls_attr->attr.link.link_igp_metric = + ntohl(ls_attr->attr.link.link_igp_metric); + break; + + // type 1096 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_SRLG: + if ((ls_attr->len % sizeof(uint32_t)) != 0) { + PARSEBGP_RETURN_INVALID_MSG_ERR; + } + + ls_attr->attr.link.link_srlg.srlg_cnt = ls_attr->len / sizeof(uint32_t); + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.link.link_srlg.srlg, + sizeof(uint16_t), + ls_attr->attr.link.link_srlg._srlg_alloc_cnt, + ls_attr->attr.link.link_srlg.srlg_cnt); + + for (i = 0; i < ls_attr->attr.link.link_srlg.srlg_cnt; i++) { + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_srlg.srlg[i]); + + ls_attr->attr.link.link_srlg.srlg[i] = + ntohs(ls_attr->attr.link.link_srlg.srlg[i]); + } + + break; + + // type 1097 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_OPAQUE: + ls_attr->attr.link.link_opaque.opaque_cnt = ls_attr->len; + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.link.link_opaque.opaque, + sizeof(uint8_t), + ls_attr->attr.link.link_opaque._opaque_alloc_cnt, + ls_attr->attr.link.link_opaque.opaque_cnt); + + PARSE_SIMPLE_ATTR(ls_attr->attr.link.link_opaque.opaque); + break; + + // type 1098 + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_NAME: + memcpy(ls_attr->attr.link.link_name, buf, ls_attr->len); + ls_attr->attr.link.link_name[ls_attr->len] = '\0'; + + buf += ls_attr->len; + nread += ls_attr->len; + break; + + /** PREFIX ATTRIBUTES */ + + // type 1152 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_IGP_FLAGS: + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_igp_flags); + break; + + // type 1153 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_ROUTE_TAG: + if ((ls_attr->len % sizeof(uint32_t)) != 0) { + PARSEBGP_RETURN_INVALID_MSG_ERR; + } + + ls_attr->attr.prefix.prefix_route_tag.tags_cnt = + ls_attr->len / sizeof(uint32_t); + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.prefix.prefix_route_tag.tags, + sizeof(uint32_t), + ls_attr->attr.prefix.prefix_route_tag._tags_alloc_cnt, + ls_attr->attr.prefix.prefix_route_tag.tags_cnt); + + for (i = 0; i < ls_attr->attr.prefix.prefix_route_tag.tags_cnt; i++) { + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_route_tag.tags[i]); + ls_attr->attr.prefix.prefix_route_tag.tags[i] = + ntohl(ls_attr->attr.prefix.prefix_route_tag.tags[i]); + } + break; + + // type 1154 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_EXTEND_ROUTE_TAG: + if ((ls_attr->len % sizeof(uint64_t)) != 0) { + PARSEBGP_RETURN_INVALID_MSG_ERR; + } + + ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags_cnt = + ls_attr->len / sizeof(uint64_t); + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags, + sizeof(uint64_t), + ls_attr->attr.prefix.prefix_extended_route_tag._ex_tags_alloc_cnt, + ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags_cnt); + + for (i = 0; i < ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags_cnt; + i++) { + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags[i]); + + ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags[i] = + ntohll(ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags[i]); + } + break; + + // type 1155 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_PREFIX_METRIC: + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_metric); + ls_attr->attr.prefix.prefix_metric = + ntohl(ls_attr->attr.prefix.prefix_metric); + break; + + // type 1156 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_OSPF_FWD_ADDR: + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_ospf_forwarding_address); + break; + + // type 1157 + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_OPAQUE_PREFIX: + ls_attr->attr.prefix.prefix_opaque.opaque_cnt = + ls_attr->len; + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.prefix.prefix_opaque.opaque, + sizeof(uint8_t), + ls_attr->attr.prefix.prefix_opaque._opaque_alloc_cnt, + ls_attr->attr.prefix.prefix_opaque.opaque_cnt); + + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_opaque.opaque); + break; + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_SID: + ls_attr->attr.prefix.prefix_sid.sid_count = ls_attr->len; + + PARSEBGP_MAYBE_REALLOC(ls_attr->attr.prefix.prefix_sid.sid, + sizeof(uint8_t), + ls_attr->attr.prefix.prefix_sid._sid_alloc_cnt, + ls_attr->attr.prefix.prefix_sid.sid_count); + + PARSE_SIMPLE_ATTR(ls_attr->attr.prefix.prefix_sid.sid); + break; + + default: + PARSEBGP_SKIP_NOT_IMPLEMENTED( + opts, buf, nread, ls_attr->len, + "BGP Link State Attribute %d is not yet implemented", ls_attr->type); + nread += ls_attr->len; + break; + } + *lenp = nread; + return PARSEBGP_OK; +} + +parsebgp_error_t +parsebgp_bgp_update_bgp_ls_decode(parsebgp_opts_t *opts, + parsebgp_bgp_update_bgp_ls_t *ls_msg, + uint8_t *buf, size_t *lenp, size_t remain) { + + parsebgp_error_t err; + size_t len = *lenp, nread = 0, slen; + parsebgp_bgp_update_bgp_ls_attr_t *ls_attr; + + ls_msg->attrs_cnt = 0; + + /** + * Loop through all TLV's for the attribute + */ + while (nread < remain) { + + PARSEBGP_MAYBE_REALLOC(ls_msg->attrs, + sizeof(parsebgp_bgp_update_bgp_ls_attr_t), + ls_msg->_attrs_alloc_cnt, + ls_msg->attrs_cnt + 1); + + ls_attr = &ls_msg->attrs[ls_msg->attrs_cnt]; + ls_msg->attrs_cnt++; + + // Read the attr type + PARSEBGP_DESERIALIZE_VAL(buf, len, nread, ls_attr->type); + ls_attr->type = ntohs(ls_attr->type); + + // Read the attr length + PARSEBGP_DESERIALIZE_VAL(buf, len, nread, ls_attr->len); + ls_attr->len = ntohs(ls_attr->len); + + slen = len - nread; + if ((err = parsebgp_bgp_update_bgp_ls_tlv_decode( + opts, ls_attr, buf, &slen)) != + PARSEBGP_OK) { + return err; + } + nread += slen; + buf += slen; + } + + *lenp = nread; + return PARSEBGP_OK; +} + +void parsebgp_bgp_update_bgp_ls_dump( + parsebgp_bgp_update_bgp_ls_t *ls_msg, int depth) { + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_t, depth); + + depth++; + int i, j; + parsebgp_bgp_update_bgp_ls_attr_t *ls_attr; + for (i = 0; i < ls_msg->attrs_cnt; i++) { + ls_attr = &ls_msg->attrs[i]; + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_t, depth); + + PARSEBGP_DUMP_INT(depth, "Type", ls_attr->type); + PARSEBGP_DUMP_INT(depth, "Length", ls_attr->len); + + depth++; + switch (ls_attr->type) { + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_MT_ID: + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + + for (j = 0; j < ls_attr->attr.node.node_mt_id.ids_cnt; j++) { + PARSEBGP_DUMP_INT(depth, "MT_ID", ls_attr->attr.node.node_mt_id.ids[j]); + } + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_FLAG: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, "NODE FLAG", ls_attr->attr.node.node_flag_bits); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_OPAQUE: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + + PARSEBGP_DUMP_DATA(depth, + "LINK OPAQUE", + ls_attr->attr.link.link_opaque.opaque, ls_attr->len); + + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_NAME: + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + PARSEBGP_DUMP_INFO(depth, "NODE NAME : %s", ls_attr->attr.node.node_name); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_ISIS_AREA_ID: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + for (j = 0; j < ls_attr->attr.node.node_isis_area_id.ids_cnt; j++) { + PARSEBGP_DUMP_INT(depth, + "PREFIX ROUTE TAG", + ls_attr->attr.node.node_isis_area_id.ids[j]); + } + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_IPV4_ROUTER_ID_LOCAL: // Includes + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + PARSEBGP_DUMP_IP(depth, + "IPV4 ROUTER ID LOCAL", + PARSEBGP_BGP_AFI_IPV4, + ls_attr->attr.node.node_ipv4_router_id_local); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_IPV6_ROUTER_ID_LOCAL: // Includes + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_node_attr_t, + depth); + PARSEBGP_DUMP_IP(depth, + "IPV6 ROUTER ID LOCAL", + PARSEBGP_BGP_AFI_IPV6, + ls_attr->attr.node.node_ipv6_router_id_local); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IPV4_ROUTER_ID_REMOTE: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_IP(depth, + "IPV4 ROUTER ID REMOTE", + PARSEBGP_BGP_AFI_IPV4, + ls_attr->attr.link.link_ipv4_router_id_remote); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IPV6_ROUTER_ID_REMOTE: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_IP(depth, + "IPV6 ROUTER ID REMOTE", + PARSEBGP_BGP_AFI_IPV6, + ls_attr->attr.link.link_ipv6_router_id_remote); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_ADMIN_GROUP: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "LINK ADMIN GROUP", + ls_attr->attr.link.link_admin_group); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MAX_LINK_BW: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_DATA(depth, + "LINK MAX LINK BW", + ls_attr->attr.link.link_max_link_bw, ls_attr->len); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MAX_RESV_BW: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_DATA(depth, + "LINK MAX RESV BW", + ls_attr->attr.link.link_max_resv_bw, ls_attr->len); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_UNRESV_BW: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_DATA(depth, + "LINK UNRESV BW", + ls_attr->attr.link.link_unresv_bw, ls_attr->len); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_TE_DEF_METRIC: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "LINK TE DEF METRIC", + ls_attr->attr.link.link_te_def_metric); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_PROTECTION_TYPE: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "LINK TE DEF METRIC", + ls_attr->attr.link.link_protective_type); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MPLS_PROTO_MASK: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "LINK PROTOCOL MASK", + ls_attr->attr.link.link_mpls_protocal_mask); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IGP_METRIC: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "LINK IGP METRIC", + ls_attr->attr.link.link_igp_metric); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_SRLG: + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + for (j = 0; j < ls_attr->attr.link.link_srlg.srlg_cnt; j++) { + PARSEBGP_DUMP_INT(depth, + "PREFIX ROUTE TAG", + ls_attr->attr.link.link_srlg.srlg[j]); + } + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_OPAQUE: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_DATA(depth, + "LINK OPAQUE", + ls_attr->attr.link.link_opaque.opaque, ls_attr->len); + break; + + case PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_NAME: { + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_link_attr_t, + depth); + PARSEBGP_DUMP_INFO(depth, "LINK NAME : %s", ls_attr->attr.link.link_name); + break; + } + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_IGP_FLAGS: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "PREFIX IGP FLAGS", + ls_attr->attr.prefix.prefix_igp_flags); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_ROUTE_TAG: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + for (j = 0; j < ls_attr->attr.prefix.prefix_route_tag.tags_cnt; j++) { + PARSEBGP_DUMP_INT(depth, + "PREFIX ROUTE TAG", + ls_attr->attr.prefix.prefix_route_tag.tags[j]); + } + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_EXTEND_ROUTE_TAG: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + for (j = 0; + j < ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags_cnt; + j++) { + if (j != 0) { + printf(" "); + } + printf("%" PRIu64, + ls_attr->attr.prefix.prefix_extended_route_tag.ex_tags[j]); + } + printf("\n"); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_PREFIX_METRIC: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + PARSEBGP_DUMP_INT(depth, + "PREFIX METRIC", + ls_attr->attr.prefix.prefix_metric); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_OSPF_FWD_ADDR: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + PARSEBGP_DUMP_IP(depth, + "PREFIX OSPF FWD ADDRESS", + PARSEBGP_BGP_AFI_IPV4, + ls_attr->attr.prefix.prefix_ospf_forwarding_address); + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_OPAQUE_PREFIX: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + PARSEBGP_DUMP_DATA(depth, + "PREFIX OPAQUE", + ls_attr->attr.prefix.prefix_opaque.opaque, + ls_attr->len); + + break; + + case PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_SID: + + PARSEBGP_DUMP_STRUCT_HDR(parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t, + depth); + PARSEBGP_DUMP_DATA(depth, + "PREFIX SID", + ls_attr->attr.prefix.prefix_sid.sid, + ls_attr->len); + + break; + } + --depth; + } +} + +void parsebgp_bgp_update_bgp_ls_destroy( + parsebgp_bgp_update_bgp_ls_t *ls_msg) { + + if (ls_msg == NULL || ls_msg->attrs == NULL) { + return; + } + + parsebgp_bgp_update_bgp_ls_attr_t *attr; + + int i; + for (i = 0; i < ls_msg->_attrs_alloc_cnt; i++) { + attr = &ls_msg->attrs[i]; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_MT_ID */ + free(attr->attr.node.node_mt_id.ids); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_OPAQUE */ + free(attr->attr.node.node_opaque.opaque); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_ISIS_AREA_ID */ + free(attr->attr.node.node_isis_area_id.ids); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_SR_ALGORITHM */ + free(attr->attr.node.node_sr_algo.algo); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_SRLG */ + free(attr->attr.link.link_srlg.srlg); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_OPAQUE */ + free(attr->attr.link.link_opaque.opaque); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_ROUTE_TAG */ + free(attr->attr.prefix.prefix_route_tag.tags); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_EXTEND_ROUTE_TAG */ + free(attr->attr.prefix.prefix_extended_route_tag.ex_tags); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_OPAQUE_PREFIX */ + free(attr->attr.prefix.prefix_opaque.opaque); + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_SID */ + free(attr->attr.prefix.prefix_sid.sid); + + } + + free(ls_msg->attrs); + free(ls_msg); +} + +void parsebgp_bgp_update_bgp_ls_clear( + parsebgp_bgp_update_bgp_ls_t *ls_msg) { + + parsebgp_bgp_update_bgp_ls_attr_t *attr; + int i = 0; + for (i = 0; i < ls_msg->attrs_cnt; i++) { + attr = &ls_msg->attrs[i]; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_MT_ID */ + attr->attr.node.node_mt_id.ids_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_OPAQUE */ + attr->attr.node.node_opaque.opaque_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_ISIS_AREA_ID */ + attr->attr.node.node_isis_area_id.ids_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_NODE_SR_ALGORITHM */ + attr->attr.node.node_sr_algo.algo_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_SRLG */ + attr->attr.link.link_srlg.srlg_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_OPAQUE */ + attr->attr.link.link_opaque.opaque_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_ROUTE_TAG */ + attr->attr.prefix.prefix_route_tag.tags_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_EXTEND_ROUTE_TAG */ + attr->attr.prefix.prefix_extended_route_tag.ex_tags_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_OPAQUE_PREFIX */ + attr->attr.prefix.prefix_opaque.opaque_cnt = 0; + + /** PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_PREFIX_SID */ + attr->attr.prefix.prefix_sid.sid_count = 0; + } + + ls_msg->attrs_cnt = 0; +} \ No newline at end of file diff --git a/lib/bgp/parsebgp_bgp_update_bgp_ls.h b/lib/bgp/parsebgp_bgp_update_bgp_ls.h new file mode 100644 index 0000000..fe35987 --- /dev/null +++ b/lib/bgp/parsebgp_bgp_update_bgp_ls.h @@ -0,0 +1,409 @@ +#ifndef __PARSEBGP_BGP_UPDATE_LINK_STATE_H +#define __PARSEBGP_BGP_UPDATE_LINK_STATE_H + +#include "parsebgp_bgp_common.h" +#include "parsebgp_error.h" +#include "parsebgp_opts.h" +#include +#include + + +/** + * Node Attribute types + */ +typedef enum { + +/** Node Attr: Multi-Topology ID (len=variable) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_MT_ID = 263, + + /** Node Attr: Flag bits (len=1) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_FLAG = 1024, + + /** Node Attr: Opaque Node (len=variable) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_OPAQUE = 1025, + + /** Node Attr: Node Name (len=variable) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_NAME = 1026, + + /** Node Attr: IS-IS Area Identifier (len=variable) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_ISIS_AREA_ID = 1027, + + /** Node Attr: Local NODE IPv4 Router ID (len=4) [RFC5305] */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_IPV4_ROUTER_ID_LOCAL = 1028, + + /** Node Attr: Local NODE IPv6 Router ID (len=16) [RFC6119] */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_IPV6_ROUTER_ID_LOCAL = 1029, + + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_CAPABILITIES = 1034, + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_ALGORITHM = 1035, + + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_LOCAL_BLOCK = 1036, + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_NODE_SR_SRMS_PREF = 1037, + +} parsebgp_bgp_update_bgp_ls_attr_node_type_t; + +/** + * Link Attribute types + */ +typedef enum { + + /** Link Attr: IPv4 Router ID of Remote Node 134/- (rfc5305/4.3) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IPV4_ROUTER_ID_REMOTE = 1030, + + /** Link Attr: IPv6 Router ID of Remote Node 140/- (rfc6119/4.1) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IPV6_ROUTER_ID_REMOTE = 1031, + + /** Link Attr: Administrative group (color) 22/3 (rfc5305/3.1) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_ADMIN_GROUP = 1088, + + /** Link Attr: Maximum link bandwidth 22/9 (rfc5305/3.3) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MAX_LINK_BW = 1089, + + /** Link Attr: Maximum reservable link bandwidth 22/10 (rfc5305/3.5) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MAX_RESV_BW = 1090, + + /** Link Attr: Unreserved bandwidth 22/11 (RFC5305/3.6) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_UNRESV_BW = 1091, + + /** Link Attr: TE default metric 22/18 */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_TE_DEF_METRIC = 1092, + + /** Link Attr: Link protection type 22/20 (rfc5307/1.2) */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_PROTECTION_TYPE = 1093, + + /** Link Attr: MPLS protocol mask */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_MPLS_PROTO_MASK = 1094, + + /** Link Attr: IGP link metric */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_IGP_METRIC = 1095, + + /** Link Attr: Shared risk link group */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_SRLG = 1096, + + /** Link Attr: Opaque link attribute */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_OPAQUE = 1097, + + /** Link Attr: Link name */ + PARSEBGP_BGP_UPDATE_LINK_STATE_ATTR_LINK_NAME = 1098 + +} parsebgp_bgp_update_bgp_ls_attr_link_type_t; + +/** + * Prefix Attribute types + */ +typedef enum ATTR_PREFIX_TYPES { + + /** Prefix Attr: IGP Flags (len=1) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_IGP_FLAGS = 1152, + + /** Prefix Attr: Route Tag (len=4*n) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_ROUTE_TAG = 1153, + + /** Prefix Attr: Extended Tag (len=8*n) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_EXTEND_ROUTE_TAG = 1154, + + /** Prefix Attr: Prefix Metric (len=4) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_PREFIX_METRIC = 1155, + + /** Prefix Attr: OSPF Forwarding Address */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_OSPF_FWD_ADDR = 1156, + + /** Prefix Attr: Opaque prefix attribute (len=variable) */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_OPAQUE_PREFIX = 1157, + + /** Prefix Attr: Prefix SID attribute */ + PARSEBGP_BGP_UPDATE_BGP_LS_ATTR_PREFIX_SID = 1158 + +} parsebgp_bgp_update_bgp_ls_attr_prefix_type_t; + +/** + * Node attributes + */ +typedef struct parsebgp_bgp_update_bgp_ls_attr_node_attr { + + /** Node Attr: Multi-Topology ID (len=variable) */ + struct { + + /** Array of mt_ids */ + uint16_t *ids; + + /** Allocated length of ids */ + int _ids_alloc_cnt; + + /** Populated ids count */ + int ids_cnt; + + } node_mt_id; + + /** Node Attr: Flag bits (len=1) */ + uint8_t node_flag_bits; + + /** Node Attr: Opaque Node (len=variable) */ + struct { + + /** Array of opaque values */ + uint8_t *opaque; + + /** Allocated length of opaque */ + int _opaque_alloc_cnt; + + /** Populated opaque count */ + int opaque_cnt; + + } node_opaque; + + /** Node Attr: Node Name (len=variable) */ + char node_name[256]; + + /** Node Attr: IS-IS Area Identifier (len=variable) */ + struct { + + /** Array of area_ids */ + uint8_t *ids; + + /** Allocated length of ids */ + int _ids_alloc_cnt; + + /** Populated ids count */ + int ids_cnt; + + } node_isis_area_id; + + /** Node Attr: Local NODE IPv4 Router ID (len=4) [RFC5305] */ + uint8_t node_ipv4_router_id_local[4]; + + /** Node Attr: Local NODE IPv6 Router ID (len=16) [RFC6119] */ + uint8_t node_ipv6_router_id_local[16]; + + /** Node Attr: SR Algorithm (len=variable) */ + struct { + + /** Array of algo ids */ + uint8_t *algo; + + /** Allocated length of ids */ + int _algo_alloc_cnt; + + /** Populated ids count */ + int algo_cnt; + + } node_sr_algo; + + uint8_t node_sr_srms_pref; + +} parsebgp_bgp_update_bgp_ls_attr_node_attr_t; + +/** + * Link attributes + */ +typedef struct parsebgp_bgp_update_bgp_ls_attr_link_attr { + + /** These two fields ipv4_router_id_local and ipv6_router_id_local are populated in node attributes*/ + + /** Link Attr: IPv4 Router ID of Remote Node 134/- (rfc5305/4.3) */ + uint8_t link_ipv4_router_id_remote[4]; + + /** Link Attr: IPv6 Router ID of Remote Node 140/- (rfc6119/4.1) */ + uint8_t link_ipv6_router_id_remote[16]; + + /** Link Attr: Administrative group (color) 22/3 (rfc5305/3.1) */ + uint32_t link_admin_group; + + /** Link Attr: Maximum link bandwidth 22/9 (rfc5305/3.3) */ + uint8_t link_max_link_bw[4]; + + /** Link Attr: Maximum reservable link bandwidth 22/10 (rfc5305/3.5) */ + uint8_t link_max_resv_bw[4]; + + /** Link Attr: Unreserved bandwidth 22/11 (RFC5305/3.6) */ + uint8_t link_unresv_bw[32]; + + /** Link Attr: TE default metric 22/18 */ + uint32_t link_te_def_metric; + + /** Link Attr: Link protection type 22/20 (rfc5307/1.2) */ + uint16_t link_protective_type; + + /** Link Attr: MPLS protocol mask */ + uint8_t link_mpls_protocal_mask; + + /** Link Attr: IGP link metric */ + uint32_t link_igp_metric; + + /** Link Attr: Shared risk link group */ + struct { + + /** Array of opaque values */ + uint32_t *srlg; + + /** Allocated length of opaque */ + int _srlg_alloc_cnt; + + /** Populated opaque count */ + int srlg_cnt; + + } link_srlg; + + /** Link Attr: Opaque link attribute */ + struct { + + /** Array of opaque values */ + uint8_t *opaque; + + /** Allocated length of opaque */ + int _opaque_alloc_cnt; + + /** Populated opaque count */ + int opaque_cnt; + + } link_opaque; + + /** Link Attr: Link name */ + char link_name[256]; + +} parsebgp_bgp_update_bgp_ls_attr_link_attr_t; + +/** + * Prefix attributes + */ +typedef struct parsebgp_bgp_update_bgp_ls_attr_prefix_attr { + + /** Prefix Attr: IGP Flags (len=1) */ + uint8_t prefix_igp_flags; + + /** Prefix Attr: Route Tag (len=4*n) */ + struct { + + /** Array of route tags */ + uint32_t *tags; + + /** Allocated length of tags */ + int _tags_alloc_cnt; + + /** Populated tags count */ + int tags_cnt; + + } prefix_route_tag; + + /** Prefix Attr: Extended Tag (len=8*n) */ + struct { + + /** Array of route extended tags */ + uint64_t *ex_tags; + + /** Allocated length of extended tags */ + int _ex_tags_alloc_cnt; + + /** Populated extended tags count */ + int ex_tags_cnt; + + } prefix_extended_route_tag; + + /** Prefix Attr: Prefix Metric (len=4) */ + uint32_t prefix_metric; + + /** Prefix Attr: OSPF Forwarding Address */ + uint8_t prefix_ospf_forwarding_address[4]; + + /** Prefix Attr: Opaque prefix attribute (len=variable) */ + struct { + + /** Array of opaque values */ + uint8_t *opaque; + + /** Allocated length of opaque */ + int _opaque_alloc_cnt; + + /** Populated opaque count */ + int opaque_cnt; + + } prefix_opaque; + + /** Prefix Attr: Sid prefix attribute (len=variable) */ + struct { + + /** Array of data for prefic sid */ + uint8_t *sid; + + /** Allocated length of sid */ + int _sid_alloc_cnt; + + /** Populated sid value */ + int sid_count; + + } prefix_sid; + +} parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t; + +/** + * BGP LINK STATE + */ +typedef struct parsebgp_bgp_update_bgp_ls_attr { + + /** Type of link state attribute*/ + uint16_t type; + + /** Length of link state attribute*/ + uint16_t len; + + /** Union of node, link and prefix values*/ + struct { + + /** Node attribute value*/ + parsebgp_bgp_update_bgp_ls_attr_node_attr_t node; + + /** Link attribute value*/ + parsebgp_bgp_update_bgp_ls_attr_link_attr_t link; + + /** Prefix attribute value*/ + parsebgp_bgp_update_bgp_ls_attr_prefix_attr_t prefix; + + } attr; + +} parsebgp_bgp_update_bgp_ls_attr_t; + +/** + * BGP LINK STATE + */ +typedef struct parsebgp_bgp_update_bgp_ls { + + /** Array of (bgp_ls_attrs_cnt) BGP LINK STATE */ + parsebgp_bgp_update_bgp_ls_attr_t *attrs; + + /** Allocated length of the attrs_used array (INTERNAL) */ + int _attrs_alloc_cnt; + + /** Number of populated Link State Attributes in the attrs field */ + int attrs_cnt; + +} parsebgp_bgp_update_bgp_ls_t; + +/** Decode a BGP LS message */ +parsebgp_error_t +parsebgp_bgp_update_bgp_ls_decode(parsebgp_opts_t *opts, + parsebgp_bgp_update_bgp_ls_t *msg, + uint8_t *buf, size_t *lenp, size_t remain); + +/** + * Dump a human-readable version of the message to stdout + * + * @param msg Pointer to the parsed MP_REACH attribute to dump + * @param depth Depth of the message within the overall message + * + * The output from these functions is designed to help with debugging the + * library and also includes internal implementation information like the names + * and sizes of structures. It may be useful to potential users of the library + * to get a sense of their data. + */ +void parsebgp_bgp_update_bgp_ls_dump( + parsebgp_bgp_update_bgp_ls_t *msg, int depth); + +/** Destroy a BGP Link State message */ +void parsebgp_bgp_update_bgp_ls_destroy( + parsebgp_bgp_update_bgp_ls_t *msg); + +/** Clear a BGP Link State message */ +void parsebgp_bgp_update_bgp_ls_clear( + parsebgp_bgp_update_bgp_ls_t *msg); + +#endif /* __PARSEBGP_BGP_UPDATE_LINK_STATE_H */ From ec3123c7c551a9797e1e60cc9b40f6c412c8fde2 Mon Sep 17 00:00:00 2001 From: Ojas Gupta Date: Wed, 22 Nov 2017 12:39:14 -0800 Subject: [PATCH 2/2] Added BSD (2-clause) license --- lib/bgp/parsebgp_bgp_update_bgp_ls.c | 26 ++++++++++++++++++++++++++ lib/bgp/parsebgp_bgp_update_bgp_ls.h | 26 ++++++++++++++++++++++++++ 2 files changed, 52 insertions(+) diff --git a/lib/bgp/parsebgp_bgp_update_bgp_ls.c b/lib/bgp/parsebgp_bgp_update_bgp_ls.c index 3b5b2ba..0545efc 100644 --- a/lib/bgp/parsebgp_bgp_update_bgp_ls.c +++ b/lib/bgp/parsebgp_bgp_update_bgp_ls.c @@ -1,3 +1,29 @@ +/* + * Copyright (C) 2017 The Regents of the University of California. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + #include "parsebgp_bgp_update_bgp_ls.h" #include "parsebgp_error.h" #include "parsebgp_utils.h" diff --git a/lib/bgp/parsebgp_bgp_update_bgp_ls.h b/lib/bgp/parsebgp_bgp_update_bgp_ls.h index fe35987..f1fbc41 100644 --- a/lib/bgp/parsebgp_bgp_update_bgp_ls.h +++ b/lib/bgp/parsebgp_bgp_update_bgp_ls.h @@ -1,3 +1,29 @@ +/* + * Copyright (C) 2017 The Regents of the University of California. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + #ifndef __PARSEBGP_BGP_UPDATE_LINK_STATE_H #define __PARSEBGP_BGP_UPDATE_LINK_STATE_H