summaryrefslogtreecommitdiffstats
path: root/pathd
diff options
context:
space:
mode:
Diffstat (limited to 'pathd')
-rw-r--r--pathd/.gitignore2
-rw-r--r--pathd/Makefile10
-rw-r--r--pathd/path_cli.c1344
-rw-r--r--pathd/path_debug.c123
-rw-r--r--pathd/path_debug.h44
-rw-r--r--pathd/path_errors.c140
-rw-r--r--pathd/path_errors.h46
-rw-r--r--pathd/path_main.c158
-rw-r--r--pathd/path_nb.c363
-rw-r--r--pathd/path_nb.h139
-rw-r--r--pathd/path_nb_config.c769
-rw-r--r--pathd/path_nb_state.c189
-rw-r--r--pathd/path_pcep.c387
-rw-r--r--pathd/path_pcep.h338
-rw-r--r--pathd/path_pcep_cli.c2064
-rw-r--r--pathd/path_pcep_cli.h27
-rw-r--r--pathd/path_pcep_config.c546
-rw-r--r--pathd/path_pcep_config.h46
-rw-r--r--pathd/path_pcep_controller.c1092
-rw-r--r--pathd/path_pcep_controller.h184
-rw-r--r--pathd/path_pcep_debug.c1777
-rw-r--r--pathd/path_pcep_debug.h55
-rw-r--r--pathd/path_pcep_lib.c1266
-rw-r--r--pathd/path_pcep_lib.h49
-rw-r--r--pathd/path_pcep_pcc.c2002
-rw-r--r--pathd/path_pcep_pcc.h149
-rw-r--r--pathd/path_ted.c721
-rw-r--r--pathd/path_ted.h178
-rw-r--r--pathd/path_zebra.c360
-rw-r--r--pathd/path_zebra.h35
-rw-r--r--pathd/pathd.c1419
-rw-r--r--pathd/pathd.h487
-rw-r--r--pathd/subdir.am85
33 files changed, 16594 insertions, 0 deletions
diff --git a/pathd/.gitignore b/pathd/.gitignore
new file mode 100644
index 0000000..95f4a99
--- /dev/null
+++ b/pathd/.gitignore
@@ -0,0 +1,2 @@
+libpath.a
+pathd
diff --git a/pathd/Makefile b/pathd/Makefile
new file mode 100644
index 0000000..b681a9a
--- /dev/null
+++ b/pathd/Makefile
@@ -0,0 +1,10 @@
+all: ALWAYS
+ @$(MAKE) -s -C .. pathd/pathd
+%: ALWAYS
+ @$(MAKE) -s -C .. pathd/$@
+
+Makefile:
+ #nothing
+ALWAYS:
+.PHONY: ALWAYS makefiles
+.SUFFIXES:
diff --git a/pathd/path_cli.c b/pathd/path_cli.c
new file mode 100644
index 0000000..4775aa3
--- /dev/null
+++ b/pathd/path_cli.c
@@ -0,0 +1,1344 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include <float.h>
+#include <math.h>
+#include <zebra.h>
+
+#include "memory.h"
+#include "log.h"
+#include "command.h"
+#include "mpls.h"
+#include "northbound_cli.h"
+#include "termtable.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_nb.h"
+#ifndef VTYSH_EXTRACT_PL
+#include "pathd/path_cli_clippy.c"
+#endif
+#include "pathd/path_ted.h"
+
+#define XPATH_MAXATTRSIZE 64
+#define XPATH_MAXKEYSIZE 42
+#define XPATH_POLICY_BASELEN 100
+#define XPATH_POLICY_MAXLEN (XPATH_POLICY_BASELEN + XPATH_MAXATTRSIZE)
+#define XPATH_CANDIDATE_BASELEN (XPATH_POLICY_BASELEN + XPATH_MAXKEYSIZE)
+#define XPATH_CANDIDATE_MAXLEN (XPATH_CANDIDATE_BASELEN + XPATH_MAXATTRSIZE)
+
+
+static int config_write_segment_routing(struct vty *vty);
+static int segment_list_has_src_dst(
+ struct vty *vty, char *xpath, long index, const char *index_str,
+ struct in_addr adj_src_ipv4, struct in_addr adj_dst_ipv4,
+ struct in6_addr adj_src_ipv6, struct in6_addr adj_dst_ipv6,
+ const char *adj_src_ipv4_str, const char *adj_dst_ipv4_str,
+ const char *adj_src_ipv6_str, const char *adj_dst_ipv6_str);
+static int segment_list_has_prefix(
+ struct vty *vty, char *xpath, long index, const char *index_str,
+ const struct prefix_ipv4 *prefix_ipv4, const char *prefix_ipv4_str,
+ const struct prefix_ipv6 *prefix_ipv6, const char *prefix_ipv6_str,
+ const char *has_algo, long algo, const char *algo_str,
+ const char *has_iface_id, long iface_id, const char *iface_id_str);
+
+DEFINE_MTYPE_STATIC(PATHD, PATH_CLI, "Client");
+
+DEFINE_HOOK(pathd_srte_config_write, (struct vty *vty), (vty));
+
+/* Vty node structures. */
+static struct cmd_node segment_routing_node = {
+ .name = "segment-routing",
+ .node = SEGMENT_ROUTING_NODE,
+ .parent_node = CONFIG_NODE,
+ .prompt = "%s(config-sr)# ",
+ .config_write = config_write_segment_routing,
+};
+
+static struct cmd_node sr_traffic_eng_node = {
+ .name = "sr traffic-eng",
+ .node = SR_TRAFFIC_ENG_NODE,
+ .parent_node = SEGMENT_ROUTING_NODE,
+ .prompt = "%s(config-sr-te)# ",
+};
+
+static struct cmd_node srte_segment_list_node = {
+ .name = "srte segment-list",
+ .node = SR_SEGMENT_LIST_NODE,
+ .parent_node = SR_TRAFFIC_ENG_NODE,
+ .prompt = "%s(config-sr-te-segment-list)# ",
+};
+
+static struct cmd_node srte_policy_node = {
+ .name = "srte policy",
+ .node = SR_POLICY_NODE,
+ .parent_node = SR_TRAFFIC_ENG_NODE,
+ .prompt = "%s(config-sr-te-policy)# ",
+};
+
+static struct cmd_node srte_candidate_dyn_node = {
+ .name = "srte candidate-dyn",
+ .node = SR_CANDIDATE_DYN_NODE,
+ .parent_node = SR_POLICY_NODE,
+ .prompt = "%s(config-sr-te-candidate)# ",
+};
+
+
+/*
+ * Show SR-TE info
+ */
+DEFPY(show_srte_policy,
+ show_srte_policy_cmd,
+ "show sr-te policy",
+ SHOW_STR
+ "SR-TE info\n"
+ "SR-TE Policy\n")
+{
+ struct ttable *tt;
+ struct srte_policy *policy;
+ char *table;
+
+ if (RB_EMPTY(srte_policy_head, &srte_policies)) {
+ vty_out(vty, "No SR Policies to display.\n\n");
+ return CMD_SUCCESS;
+ }
+
+ /* Prepare table. */
+ tt = ttable_new(&ttable_styles[TTSTYLE_BLANK]);
+ ttable_add_row(tt, "Endpoint|Color|Name|BSID|Status");
+ tt->style.cell.rpad = 2;
+ tt->style.corner = '+';
+ ttable_restyle(tt);
+ ttable_rowseps(tt, 0, BOTTOM, true, '-');
+
+ RB_FOREACH (policy, srte_policy_head, &srte_policies) {
+ char endpoint[46];
+ char binding_sid[16] = "-";
+
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ if (policy->binding_sid != MPLS_LABEL_NONE)
+ snprintf(binding_sid, sizeof(binding_sid), "%u",
+ policy->binding_sid);
+
+ ttable_add_row(tt, "%s|%u|%s|%s|%s", endpoint, policy->color,
+ policy->name, binding_sid,
+ policy->status == SRTE_POLICY_STATUS_UP
+ ? "Active"
+ : "Inactive");
+ }
+
+ /* Dump the generated table. */
+ table = ttable_dump(tt, "\n");
+ vty_out(vty, "%s\n", table);
+ XFREE(MTYPE_TMP, table);
+
+ ttable_del(tt);
+
+ return CMD_SUCCESS;
+}
+
+
+/*
+ * Show detailed SR-TE info
+ */
+DEFPY(show_srte_policy_detail,
+ show_srte_policy_detail_cmd,
+ "show sr-te policy detail",
+ SHOW_STR
+ "SR-TE info\n"
+ "SR-TE Policy\n"
+ "Show a detailed summary\n")
+{
+ struct srte_policy *policy;
+
+ if (RB_EMPTY(srte_policy_head, &srte_policies)) {
+ vty_out(vty, "No SR Policies to display.\n\n");
+ return CMD_SUCCESS;
+ }
+
+ vty_out(vty, "\n");
+ RB_FOREACH (policy, srte_policy_head, &srte_policies) {
+ struct srte_candidate *candidate;
+ char endpoint[46];
+ char binding_sid[16] = "-";
+ char *segment_list_info;
+ static char undefined_info[] = "(undefined)";
+ static char created_by_pce_info[] = "(created by PCE)";
+
+
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ if (policy->binding_sid != MPLS_LABEL_NONE)
+ snprintf(binding_sid, sizeof(binding_sid), "%u",
+ policy->binding_sid);
+ vty_out(vty,
+ "Endpoint: %s Color: %u Name: %s BSID: %s Status: %s\n",
+ endpoint, policy->color, policy->name, binding_sid,
+ policy->status == SRTE_POLICY_STATUS_UP ? "Active"
+ : "Inactive");
+
+ RB_FOREACH (candidate, srte_candidate_head,
+ &policy->candidate_paths) {
+ struct srte_segment_list *segment_list;
+
+ segment_list = candidate->lsp->segment_list;
+ if (segment_list == NULL)
+ segment_list_info = undefined_info;
+ else if (segment_list->protocol_origin
+ == SRTE_ORIGIN_PCEP)
+ segment_list_info = created_by_pce_info;
+ else
+ segment_list_info =
+ candidate->lsp->segment_list->name;
+
+ vty_out(vty,
+ " %s Preference: %d Name: %s Type: %s Segment-List: %s Protocol-Origin: %s\n",
+ CHECK_FLAG(candidate->flags, F_CANDIDATE_BEST)
+ ? "*"
+ : " ",
+ candidate->preference, candidate->name,
+ candidate->type == SRTE_CANDIDATE_TYPE_EXPLICIT
+ ? "explicit"
+ : "dynamic",
+ segment_list_info,
+ srte_origin2str(
+ candidate->lsp->protocol_origin));
+ }
+
+ vty_out(vty, "\n");
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFPY_NOSH(
+ segment_routing_list,
+ segment_routing_cmd,
+ "segment-routing",
+ "Configure segment routing\n")
+{
+ VTY_PUSH_CONTEXT_NULL(SEGMENT_ROUTING_NODE);
+ return CMD_SUCCESS;
+}
+
+DEFPY_NOSH(
+ sr_traffic_eng_list,
+ sr_traffic_eng_cmd,
+ "traffic-eng",
+ "Configure SR traffic engineering\n")
+{
+ VTY_PUSH_CONTEXT_NULL(SR_TRAFFIC_ENG_NODE);
+ return CMD_SUCCESS;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list
+ */
+DEFPY_NOSH(
+ srte_segment_list,
+ srte_segment_list_cmd,
+ "segment-list WORD$name",
+ "Segment List\n"
+ "Segment List Name\n")
+{
+ char xpath[XPATH_MAXLEN];
+ int ret;
+
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/segment-list[name='%s']", name);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
+
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/segment-list[name='%s']/protocol-origin",
+ name);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, "local");
+
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/segment-list[name='%s']/originator", name);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, "config");
+
+ ret = nb_cli_apply_changes(vty, NULL);
+ if (ret == CMD_SUCCESS) {
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/segment-list[name='%s']", name);
+ VTY_PUSH_XPATH(SR_SEGMENT_LIST_NODE, xpath);
+ }
+
+ return ret;
+}
+
+DEFPY(srte_no_segment_list,
+ srte_no_segment_list_cmd,
+ "no segment-list WORD$name",
+ NO_STR
+ "Segment List\n"
+ "Segment List Name\n")
+{
+ char xpath[XPATH_MAXLEN];
+
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/segment-list[name='%s']", name);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+void cli_show_srte_segment_list(struct vty *vty, const struct lyd_node *dnode,
+ bool show_defaults)
+{
+ vty_out(vty, " segment-list %s\n",
+ yang_dnode_get_string(dnode, "./name"));
+}
+
+void cli_show_srte_segment_list_end(struct vty *vty,
+ const struct lyd_node *dnode)
+{
+ vty_out(vty, " exit\n");
+}
+
+static int segment_list_has_src_dst(
+ struct vty *vty, char *xpath, long index, const char *index_str,
+ struct in_addr adj_src_ipv4, struct in_addr adj_dst_ipv4,
+ struct in6_addr adj_src_ipv6, struct in6_addr adj_dst_ipv6,
+ const char *adj_src_ipv4_str, const char *adj_dst_ipv4_str,
+ const char *adj_src_ipv6_str, const char *adj_dst_ipv6_str)
+{
+ const char *node_src_id;
+ uint32_t ted_sid = MPLS_LABEL_NONE;
+
+ struct ipaddr ip_src = {};
+ struct ipaddr ip_dst = {};
+ if (adj_src_ipv4_str != NULL) {
+ ip_src.ipa_type = IPADDR_V4;
+ ip_src.ip._v4_addr = adj_src_ipv4;
+ ip_dst.ipa_type = IPADDR_V4;
+ ip_dst.ip._v4_addr = adj_dst_ipv4;
+ } else if (adj_src_ipv6_str != NULL) {
+ ip_src.ipa_type = IPADDR_V6;
+ ip_src.ip._v6_addr = adj_src_ipv6;
+ ip_dst.ipa_type = IPADDR_V6;
+ ip_dst.ip._v6_addr = adj_dst_ipv6;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+ ted_sid = path_ted_query_type_f(&ip_src, &ip_dst);
+ if (ted_sid == MPLS_LABEL_NONE) {
+ zlog_warn(
+ "%s: [rcv ted] CLI NOT FOUND Continue query_type_f SRC (%pIA) DST (%pIA)!",
+ __func__, &ip_src, &ip_dst);
+ }
+ /* type */
+ snprintf(xpath, XPATH_MAXLEN, "./segment[index='%s']/nai/type",
+ index_str);
+ if (adj_src_ipv4_str != NULL) {
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ "ipv4_adjacency");
+ node_src_id = adj_src_ipv4_str;
+ } else if (adj_src_ipv6_str != NULL) {
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ "ipv6_adjacency");
+ node_src_id = adj_src_ipv6_str;
+ } else {
+ /*
+ * This is just to make the compiler happy about
+ * node_src_id not being initialized. This
+ * should never happen unless we change the cli
+ * function.
+ */
+ assert(!"We must have a adj_src_ipv4_str or a adj_src_ipv6_str");
+ }
+
+ /* addresses */
+ snprintf(xpath, XPATH_MAXLEN, "./segment[index='%s']/nai/local-address",
+ index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, node_src_id);
+ snprintf(xpath, XPATH_MAXLEN,
+ "./segment[index='%s']/nai/remote-address", index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ adj_dst_ipv4_str ? adj_dst_ipv4_str
+ : adj_dst_ipv6_str);
+ return CMD_SUCCESS;
+}
+int segment_list_has_prefix(
+ struct vty *vty, char *xpath, long index, const char *index_str,
+ const struct prefix_ipv4 *prefix_ipv4, const char *prefix_ipv4_str,
+ const struct prefix_ipv6 *prefix_ipv6, const char *prefix_ipv6_str,
+ const char *has_algo, long algo, const char *algo_str,
+ const char *has_iface_id, long iface_id, const char *iface_id_str)
+{
+ char buf_prefix[INET6_ADDRSTRLEN];
+
+ uint32_t ted_sid = MPLS_LABEL_NONE;
+ struct prefix prefix_cli = {};
+ struct ipaddr pre_ipaddr = {};
+ /* prefix with algorithm or local interface id */
+ /* Type */
+ snprintf(xpath, XPATH_MAXLEN, "./segment[index='%s']/nai/type",
+ index_str);
+ if (has_iface_id != NULL) {
+ if (prefix_ipv4_str != NULL) {
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ "ipv4_local_iface");
+ } else if (prefix_ipv6_str != NULL) {
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ "ipv6_local_iface");
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+ } else {
+ if (prefix_ipv4_str != NULL) {
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ "ipv4_algo");
+ } else if (prefix_ipv6_str != NULL) {
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ "ipv6_algo");
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+ }
+ /* Prefix */
+ if (prefix_ipv4_str != NULL) {
+ if (!str2prefix(prefix_ipv4_str, &prefix_cli)) {
+ vty_out(vty, "%% Malformed prefix\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+ inet_ntop(AF_INET, &prefix_cli.u.prefix4, buf_prefix,
+ sizeof(buf_prefix));
+ pre_ipaddr.ipa_type = IPADDR_V4;
+ pre_ipaddr.ip._v4_addr = prefix_cli.u.prefix4;
+ } else if (prefix_ipv6_str != NULL) {
+ if (!str2prefix(prefix_ipv6_str, &prefix_cli)) {
+ vty_out(vty, "%% Malformed prefix\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+ inet_ntop(AF_INET6, &prefix_cli.u.prefix6, buf_prefix,
+ sizeof(buf_prefix));
+ pre_ipaddr.ipa_type = IPADDR_V6;
+ pre_ipaddr.ip._v6_addr = prefix_cli.u.prefix6;
+ }
+ snprintf(xpath, XPATH_MAXLEN, "./segment[index='%s']/nai/local-address",
+ index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, buf_prefix);
+ snprintf(xpath, XPATH_MAXLEN,
+ "./segment[index='%s']/nai/local-prefix-len", index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ prefix_ipv4_str
+ ? strchr(prefix_ipv4_str, '/') + 1
+ : strchr(prefix_ipv6_str, '/') + 1);
+ /* Alg / Iface */
+ if (has_algo != NULL) {
+ snprintf(xpath, XPATH_MAXLEN,
+ "./segment[index='%s']/nai/algorithm", index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, algo_str);
+ } else {
+ if (has_iface_id != NULL) {
+ snprintf(xpath, XPATH_MAXLEN,
+ "./segment[index='%s']/nai/local-interface",
+ index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ iface_id_str);
+ }
+ }
+ if (has_algo != NULL) {
+ ted_sid = path_ted_query_type_c(&prefix_cli, algo);
+ if (ted_sid == MPLS_LABEL_NONE) {
+ zlog_err(
+ "%s: [rcv ted] CLI NOT FOUND Continue query_type_c PREFIX (%pIA/%d) ALGO (%ld) sid:(%d)!",
+ __func__, &pre_ipaddr, prefix_cli.prefixlen,
+ algo, ted_sid);
+ }
+ }
+ if (has_iface_id != NULL) {
+ ted_sid = path_ted_query_type_e(&prefix_cli, iface_id);
+ if (ted_sid == MPLS_LABEL_NONE) {
+ zlog_err(
+ "%s: [rcv ted] CLI NOT FOUND Continue query_type_e PREFIX (%pIA/%d) IFACE (%ld) sid:(%d)!",
+ __func__, &pre_ipaddr, prefix_cli.prefixlen,
+ iface_id, ted_sid);
+ }
+ }
+ return CMD_SUCCESS;
+}
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list/segment
+ */
+/* clang-format off */
+DEFPY(srte_segment_list_segment, srte_segment_list_segment_cmd,
+ "index (0-4294967295)$index <[mpls$has_mpls_label label (16-1048575)$label] "
+ "|"
+ "[nai$has_nai <"
+ "prefix <A.B.C.D/M$prefix_ipv4|X:X::X:X/M$prefix_ipv6>"
+ "<algorithm$has_algo (0-1)$algo| iface$has_iface_id (0-4294967295)$iface_id>"
+ "| adjacency$has_adj "
+ "<A.B.C.D$adj_src_ipv4 A.B.C.D$adj_dst_ipv4|X:X::X:X$adj_src_ipv6 X:X::X:X$adj_dst_ipv6>"
+ ">]"
+ ">",
+ "Index\n"
+ "Index Value\n"
+ "MPLS or IP Label\n"
+ "Label\n"
+ "Label Value\n"
+ "Segment NAI\n"
+ "NAI prefix identifier\n"
+ "NAI IPv4 prefix identifier\n"
+ "NAI IPv6 prefix identifier\n"
+ "IGP Algorithm\n"
+ "Algorithm Value SPF or Strict-SPF\n"
+ "Interface Id\n"
+ "Interface Value\n"
+ "ADJ identifier\n"
+ "ADJ IPv4 src identifier\n"
+ "ADJ IPv4 dst identifier\n"
+ "ADJ IPv6 src identifier\n"
+ "ADJ IPv6 dst identifier\n")
+/* clang-format on */
+{
+ char xpath[XPATH_MAXLEN];
+ int status = CMD_SUCCESS;
+
+
+ snprintf(xpath, sizeof(xpath), "./segment[index='%s']", index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
+
+ if (has_mpls_label != NULL) {
+ snprintf(xpath, sizeof(xpath),
+ "./segment[index='%s']/sid-value", index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, label_str);
+ return nb_cli_apply_changes(vty, NULL);
+ }
+
+ if (has_adj != NULL) {
+ status = segment_list_has_src_dst(vty, xpath, index, index_str,
+ adj_src_ipv4, adj_dst_ipv4,
+ adj_src_ipv6, adj_dst_ipv6,
+ adj_src_ipv4_str, adj_dst_ipv4_str,
+ adj_src_ipv6_str, adj_dst_ipv6_str);
+ if (status != CMD_SUCCESS)
+ return status;
+ } else {
+ status = segment_list_has_prefix(
+ vty, xpath, index, index_str, prefix_ipv4,
+ prefix_ipv4_str, prefix_ipv6, prefix_ipv6_str, has_algo,
+ algo, algo_str, has_iface_id, iface_id, iface_id_str);
+ if (status != CMD_SUCCESS)
+ return status;
+ }
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_segment_list_no_segment,
+ srte_segment_list_no_segment_cmd,
+ "no index (0-4294967295)$index",
+ NO_STR
+ "Index\n"
+ "Index Value\n")
+{
+ char xpath[XPATH_MAXLEN];
+
+ snprintf(xpath, sizeof(xpath), "./segment[index='%s']", index_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+void cli_show_srte_segment_list_segment(struct vty *vty,
+ const struct lyd_node *dnode,
+ bool show_defaults)
+{
+ vty_out(vty, " index %s", yang_dnode_get_string(dnode, "./index"));
+ if (yang_dnode_exists(dnode, "./sid-value")) {
+ vty_out(vty, " mpls label %s",
+ yang_dnode_get_string(dnode, "./sid-value"));
+ }
+ if (yang_dnode_exists(dnode, "./nai")) {
+ struct ipaddr addr;
+ struct ipaddr addr_rmt;
+
+ switch (yang_dnode_get_enum(dnode, "./nai/type")) {
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_NODE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM:
+ yang_dnode_get_ip(&addr, dnode, "./nai/local-address");
+ vty_out(vty, " nai prefix %pI4", &addr.ipaddr_v4);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_NODE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_LOCAL_IFACE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ALGORITHM:
+ yang_dnode_get_ip(&addr, dnode, "./nai/local-address");
+ vty_out(vty, " nai prefix %pI6", &addr.ipaddr_v6);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY:
+ yang_dnode_get_ip(&addr, dnode, "./nai/local-address");
+ yang_dnode_get_ip(&addr_rmt, dnode,
+ "./nai/remote-address");
+ vty_out(vty, " nai adjacency %pI4", &addr.ipaddr_v4);
+ vty_out(vty, " %pI4", &addr_rmt.ipaddr_v4);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY:
+ yang_dnode_get_ip(&addr, dnode, "./nai/local-address");
+ yang_dnode_get_ip(&addr_rmt, dnode,
+ "./nai/remote-address");
+ vty_out(vty, " nai adjacency %pI6", &addr.ipaddr_v6);
+ vty_out(vty, " %pI6", &addr_rmt.ipaddr_v6);
+ break;
+ default:
+ break;
+ }
+ if (yang_dnode_exists(dnode, "./nai/local-prefix-len")) {
+ vty_out(vty, "/%s",
+ yang_dnode_get_string(
+ dnode, "./nai/local-prefix-len"));
+ }
+ if (yang_dnode_exists(dnode, "./nai/local-interface")) {
+ vty_out(vty, " iface %s",
+ yang_dnode_get_string(dnode,
+ "./nai/local-interface"));
+ }
+ if (yang_dnode_exists(dnode, "./nai/algorithm")) {
+ vty_out(vty, " algorithm %s",
+ yang_dnode_get_string(dnode,
+ "./nai/algorithm"));
+ }
+ }
+ vty_out(vty, "\n");
+}
+
+/*
+ * XPath: /frr-pathd:pathd/policy
+ */
+DEFPY_NOSH(
+ srte_policy,
+ srte_policy_cmd,
+ "policy color (0-4294967295)$num endpoint <A.B.C.D|X:X::X:X>$endpoint",
+ "Segment Routing Policy\n"
+ "SR Policy color\n"
+ "SR Policy color value\n"
+ "SR Policy endpoint\n"
+ "SR Policy endpoint IPv4 address\n"
+ "SR Policy endpoint IPv6 address\n")
+{
+ char xpath[XPATH_POLICY_BASELEN];
+ int ret;
+
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/policy[color='%s'][endpoint='%s']",
+ num_str, endpoint_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
+
+ ret = nb_cli_apply_changes(vty, NULL);
+ if (ret == CMD_SUCCESS)
+ VTY_PUSH_XPATH(SR_POLICY_NODE, xpath);
+
+ return ret;
+}
+
+DEFPY(srte_no_policy,
+ srte_no_policy_cmd,
+ "no policy color (0-4294967295)$num endpoint <A.B.C.D|X:X::X:X>$endpoint",
+ NO_STR
+ "Segment Routing Policy\n"
+ "SR Policy color\n"
+ "SR Policy color value\n"
+ "SR Policy endpoint\n"
+ "SR Policy endpoint IPv4 address\n"
+ "SR Policy endpoint IPv6 address\n")
+{
+ char xpath[XPATH_POLICY_BASELEN];
+
+ snprintf(xpath, sizeof(xpath),
+ "/frr-pathd:pathd/srte/policy[color='%s'][endpoint='%s']",
+ num_str, endpoint_str);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+void cli_show_srte_policy(struct vty *vty, const struct lyd_node *dnode,
+ bool show_defaults)
+{
+ vty_out(vty, " policy color %s endpoint %s\n",
+ yang_dnode_get_string(dnode, "./color"),
+ yang_dnode_get_string(dnode, "./endpoint"));
+}
+
+void cli_show_srte_policy_end(struct vty *vty, const struct lyd_node *dnode)
+{
+ vty_out(vty, " exit\n");
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/name
+ */
+DEFPY(srte_policy_name,
+ srte_policy_name_cmd,
+ "name WORD$name",
+ "Segment Routing Policy name\n"
+ "SR Policy name value\n")
+{
+ nb_cli_enqueue_change(vty, "./name", NB_OP_CREATE, name);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_policy_no_name,
+ srte_policy_no_name_cmd,
+ "no name [WORD]",
+ NO_STR
+ "Segment Routing Policy name\n"
+ "SR Policy name value\n")
+{
+ nb_cli_enqueue_change(vty, "./name", NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+
+void cli_show_srte_policy_name(struct vty *vty, const struct lyd_node *dnode,
+ bool show_defaults)
+{
+ vty_out(vty, " name %s\n", yang_dnode_get_string(dnode, NULL));
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/binding-sid
+ */
+DEFPY(srte_policy_binding_sid,
+ srte_policy_binding_sid_cmd,
+ "binding-sid (16-1048575)$label",
+ "Segment Routing Policy Binding-SID\n"
+ "SR Policy Binding-SID label\n")
+{
+ nb_cli_enqueue_change(vty, "./binding-sid", NB_OP_CREATE, label_str);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_policy_no_binding_sid,
+ srte_policy_no_binding_sid_cmd,
+ "no binding-sid [(16-1048575)]",
+ NO_STR
+ "Segment Routing Policy Binding-SID\n"
+ "SR Policy Binding-SID label\n")
+{
+ nb_cli_enqueue_change(vty, "./binding-sid", NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+void cli_show_srte_policy_binding_sid(struct vty *vty,
+ const struct lyd_node *dnode,
+ bool show_defaults)
+{
+ vty_out(vty, " binding-sid %s\n", yang_dnode_get_string(dnode, NULL));
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path
+ */
+DEFPY(srte_policy_candidate_exp,
+ srte_policy_candidate_exp_cmd,
+ "candidate-path preference (0-4294967295)$preference name WORD$name \
+ explicit segment-list WORD$list_name",
+ "Segment Routing Policy Candidate Path\n"
+ "Segment Routing Policy Candidate Path Preference\n"
+ "Administrative Preference\n"
+ "Segment Routing Policy Candidate Path Name\n"
+ "Symbolic Name\n"
+ "Explicit Path\n"
+ "List of SIDs\n"
+ "Name of the Segment List\n")
+{
+ nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, preference_str);
+ nb_cli_enqueue_change(vty, "./name", NB_OP_MODIFY, name);
+ nb_cli_enqueue_change(vty, "./protocol-origin", NB_OP_MODIFY, "local");
+ nb_cli_enqueue_change(vty, "./originator", NB_OP_MODIFY, "config");
+ nb_cli_enqueue_change(vty, "./type", NB_OP_MODIFY, "explicit");
+ nb_cli_enqueue_change(vty, "./segment-list-name", NB_OP_MODIFY,
+ list_name);
+ return nb_cli_apply_changes(vty, "./candidate-path[preference='%s']",
+ preference_str);
+}
+
+DEFPY_NOSH(
+ srte_policy_candidate_dyn,
+ srte_policy_candidate_dyn_cmd,
+ "candidate-path preference (0-4294967295)$preference name WORD$name dynamic",
+ "Segment Routing Policy Candidate Path\n"
+ "Segment Routing Policy Candidate Path Preference\n"
+ "Administrative Preference\n"
+ "Segment Routing Policy Candidate Path Name\n"
+ "Symbolic Name\n"
+ "Dynamic Path\n")
+{
+ char xpath[XPATH_MAXLEN + XPATH_CANDIDATE_BASELEN];
+ int ret;
+
+ snprintf(xpath, sizeof(xpath), "%s/candidate-path[preference='%s']",
+ VTY_CURR_XPATH, preference_str);
+
+ nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, preference_str);
+ nb_cli_enqueue_change(vty, "./name", NB_OP_MODIFY, name);
+ nb_cli_enqueue_change(vty, "./protocol-origin", NB_OP_MODIFY, "local");
+ nb_cli_enqueue_change(vty, "./originator", NB_OP_MODIFY, "config");
+ nb_cli_enqueue_change(vty, "./type", NB_OP_MODIFY, "dynamic");
+ ret = nb_cli_apply_changes(vty, "./candidate-path[preference='%s']",
+ preference_str);
+
+ if (ret == CMD_SUCCESS)
+ VTY_PUSH_XPATH(SR_CANDIDATE_DYN_NODE, xpath);
+
+ return ret;
+}
+
+DEFPY(srte_candidate_bandwidth,
+ srte_candidate_bandwidth_cmd,
+ "bandwidth BANDWIDTH$value [required$required]",
+ "Define a bandwidth constraint\n"
+ "Bandwidth value\n"
+ "Required constraint\n")
+{
+ nb_cli_enqueue_change(vty, "./constraints/bandwidth/required",
+ NB_OP_MODIFY, required ? "true" : "false");
+ nb_cli_enqueue_change(vty, "./constraints/bandwidth/value",
+ NB_OP_MODIFY, value);
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_candidate_no_bandwidth,
+ srte_candidate_no_bandwidth_cmd,
+ "no bandwidth [BANDWIDTH$value] [required$required]",
+ NO_STR
+ "Remove a bandwidth constraint\n"
+ "Bandwidth value\n"
+ "Required constraint\n")
+{
+ nb_cli_enqueue_change(vty, "./constraints/bandwidth", NB_OP_DESTROY,
+ NULL);
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_candidate_affinity_filter, srte_candidate_affinity_filter_cmd,
+ "affinity <exclude-any|include-any|include-all>$type BITPATTERN$value",
+ "Affinity constraint\n"
+ "Exclude any matching link\n"
+ "Include any matching link\n"
+ "Include all matching links\n"
+ "Attribute filter bit pattern as an hexadecimal value from 0x00000000 to 0xFFFFFFFF\n")
+{
+ uint32_t filter;
+ char xpath[XPATH_CANDIDATE_MAXLEN];
+ char decimal_value[11];
+
+ if (sscanf(value, "0x%x", &filter) != 1) {
+ vty_out(vty, "affinity type: fscanf: %s\n",
+ safe_strerror(errno));
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+ snprintf(decimal_value, sizeof(decimal_value), "%u", filter);
+ snprintf(xpath, sizeof(xpath), "./constraints/affinity/%s", type);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, decimal_value);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_candidate_no_affinity_filter, srte_candidate_no_affinity_filter_cmd,
+ "no affinity <exclude-any|include-any|include-all>$type [BITPATTERN$value]",
+ NO_STR
+ "Affinity constraint\n"
+ "Exclude any matching link\n"
+ "Include any matching link\n"
+ "Include all matching links\n"
+ "Attribute filter bit pattern as an hexadecimal value from 0x00000000 to 0xFFFFFFFF\n")
+{
+ char xpath[XPATH_CANDIDATE_MAXLEN];
+
+ snprintf(xpath, sizeof(xpath), "./constraints/affinity/%s", type);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_candidate_metric,
+ srte_candidate_metric_cmd,
+ "metric [bound$bound] <igp|te|hc|abc|lmll|cigp|cte|pigp|pte|phc|msd|pd|pdv|pl|ppd|ppdv|ppl|nap|nlp|dc|bnc>$type METRIC$value [required$required]",
+ "Define a metric constraint\n"
+ "If the metric is bounded\n"
+ "IGP metric\n"
+ "TE metric\n"
+ "Hop Counts\n"
+ "Aggregate bandwidth consumption\n"
+ "Load of the most loaded link\n"
+ "Cumulative IGP cost\n"
+ "Cumulative TE cost\n"
+ "P2MP IGP metric\n"
+ "P2MP TE metric\n"
+ "P2MP hop count metric\n"
+ "Segment-ID (SID) Depth.\n"
+ "Path Delay metric\n"
+ "Path Delay Variation metric\n"
+ "Path Loss metric\n"
+ "P2MP Path Delay metric\n"
+ "P2MP Path Delay variation metric\n"
+ "P2MP Path Loss metric\n"
+ "Number of adaptations on a path\n"
+ "Number of layers on a path\n"
+ "Domain Count metric\n"
+ "Border Node Count metric\n"
+ "Metric value\n"
+ "Required constraint\n")
+{
+ char xpath[XPATH_CANDIDATE_MAXLEN];
+ snprintf(xpath, sizeof(xpath), "./constraints/metrics[type='%s']/value",
+ type);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, value);
+ snprintf(xpath, sizeof(xpath),
+ "./constraints/metrics[type='%s']/is-bound", type);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ (bound != NULL) ? "true" : "false");
+ snprintf(xpath, sizeof(xpath),
+ "./constraints/metrics[type='%s']/required", type);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ required ? "true" : "false");
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_candidate_no_metric,
+ srte_candidate_no_metric_cmd,
+ "no metric [bound] <igp|te|hc|abc|lmll|cigp|cte|pigp|pte|phc|msd|pd|pdv|pl|ppd|ppdv|ppl|nap|nlp|dc|bnc>$type [METRIC$value] [required$required]",
+ NO_STR
+ "Remove a metric constraint\n"
+ "If the metric is bounded\n"
+ "IGP metric\n"
+ "TE metric\n"
+ "Hop Counts\n"
+ "Aggregate bandwidth consumption\n"
+ "Load of the most loaded link\n"
+ "Cumulative IGP cost\n"
+ "Cumulative TE cost\n"
+ "P2MP IGP metric\n"
+ "P2MP TE metric\n"
+ "P2MP hop count metric\n"
+ "Segment-ID (SID) Depth.\n"
+ "Path Delay metric\n"
+ "Path Delay Variation metric\n"
+ "Path Loss metric\n"
+ "P2MP Path Delay metric\n"
+ "P2MP Path Delay variation metric\n"
+ "P2MP Path Loss metric\n"
+ "Number of adaptations on a path\n"
+ "Number of layers on a path\n"
+ "Domain Count metric\n"
+ "Border Node Count metric\n"
+ "Metric value\n"
+ "Required constraint\n")
+{
+ char xpath[XPATH_CANDIDATE_MAXLEN];
+ snprintf(xpath, sizeof(xpath), "./constraints/metrics[type='%s']",
+ type);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_policy_no_candidate,
+ srte_policy_no_candidate_cmd,
+ "no candidate-path\
+ preference (0-4294967295)$preference\
+ [name WORD\
+ <\
+ explicit segment-list WORD\
+ |dynamic\
+ >]",
+ NO_STR
+ "Segment Routing Policy Candidate Path\n"
+ "Segment Routing Policy Candidate Path Preference\n"
+ "Administrative Preference\n"
+ "Segment Routing Policy Candidate Path Name\n"
+ "Symbolic Name\n"
+ "Explicit Path\n"
+ "List of SIDs\n"
+ "Name of the Segment List\n"
+ "Dynamic Path\n")
+{
+ nb_cli_enqueue_change(vty, ".", NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, "./candidate-path[preference='%s']",
+ preference_str);
+}
+
+DEFPY(srte_candidate_objfun,
+ srte_candidate_objfun_cmd,
+ "objective-function <mcp|mlp|mbp|mbc|mll|mcc|spt|mct|mplp|mup|mrup|mtd|mbn|mctd|msl|mss|msn>$type [required$required]",
+ "Define an objective function constraint\n"
+ "Minimum Cost Path\n"
+ "Minimum Load Path\n"
+ "Maximum residual Bandwidth Path\n"
+ "Minimize aggregate Bandwidth Consumption\n"
+ "Minimize the Load of the most loaded Link\n"
+ "Minimize the Cumulative Cost of a set of paths\n"
+ "Shortest Path Tree\n"
+ "Minimum Cost Tree\n"
+ "Minimum Packet Loss Path\n"
+ "Maximum Under-Utilized Path\n"
+ "Maximum Reserved Under-Utilized Path\n"
+ "Minimize the number of Transit Domains\n"
+ "Minimize the number of Border Nodes\n"
+ "Minimize the number of Common Transit Domains\n"
+ "Minimize the number of Shared Links\n"
+ "Minimize the number of Shared SRLGs\n"
+ "Minimize the number of Shared Nodes\n"
+ "Required constraint\n")
+{
+ char xpath[XPATH_CANDIDATE_MAXLEN];
+ nb_cli_enqueue_change(vty, "./constraints/objective-function",
+ NB_OP_DESTROY, NULL);
+ snprintf(xpath, sizeof(xpath),
+ "./constraints/objective-function/required");
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY,
+ required ? "true" : "false");
+ nb_cli_enqueue_change(vty, "./constraints/objective-function/type",
+ NB_OP_MODIFY, type);
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFPY(srte_candidate_no_objfun,
+ srte_candidate_no_objfun_cmd,
+ "no objective-function [<mcp|mlp|mbp|mbc|mll|mcc|spt|mct|mplp|mup|mrup|mtd|mbn|mctd|msl|mss|msn>] [required$required]",
+ NO_STR
+ "Remove an objective function constraint\n"
+ "Minimum Cost Path\n"
+ "Minimum Load Path\n"
+ "Maximum residual Bandwidth Path\n"
+ "Minimize aggregate Bandwidth Consumption\n"
+ "Minimize the Load of the most loaded Link\n"
+ "Minimize the Cumulative Cost of a set of paths\n"
+ "Shortest Path Tree\n"
+ "Minimum Cost Tree\n"
+ "Minimum Packet Loss Path\n"
+ "Maximum Under-Utilized Path\n"
+ "Maximum Reserved Under-Utilized Path\n"
+ "Minimize the number of Transit Domains\n"
+ "Minimize the number of Border Nodes\n"
+ "Minimize the number of Common Transit Domains\n"
+ "Minimize the number of Shared Links\n"
+ "Minimize the number of Shared SRLGs\n"
+ "Minimize the number of Shared Nodes\n"
+ "Required constraint\n")
+{
+ nb_cli_enqueue_change(vty, "./constraints/objective-function",
+ NB_OP_DESTROY, NULL);
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+static const char *objfun_type_name(enum objfun_type type)
+{
+ switch (type) {
+ case OBJFUN_MCP:
+ return "mcp";
+ case OBJFUN_MLP:
+ return "mlp";
+ case OBJFUN_MBP:
+ return "mbp";
+ case OBJFUN_MBC:
+ return "mbc";
+ case OBJFUN_MLL:
+ return "mll";
+ case OBJFUN_MCC:
+ return "mcc";
+ case OBJFUN_SPT:
+ return "spt";
+ case OBJFUN_MCT:
+ return "mct";
+ case OBJFUN_MPLP:
+ return "mplp";
+ case OBJFUN_MUP:
+ return "mup";
+ case OBJFUN_MRUP:
+ return "mrup";
+ case OBJFUN_MTD:
+ return "mtd";
+ case OBJFUN_MBN:
+ return "mbn";
+ case OBJFUN_MCTD:
+ return "mctd";
+ case OBJFUN_MSL:
+ return "msl";
+ case OBJFUN_MSS:
+ return "mss";
+ case OBJFUN_MSN:
+ return "msn";
+ default:
+ return NULL;
+ }
+}
+
+DEFPY_NOSH(show_debugging_pathd, show_debugging_pathd_cmd,
+ "show debugging [pathd]",
+ SHOW_STR
+ "State of each debugging option\n"
+ "pathd module debugging\n")
+{
+ /* nothing to do here */
+ return CMD_SUCCESS;
+}
+
+static const char *metric_type_name(enum srte_candidate_metric_type type)
+{
+ switch (type) {
+ case SRTE_CANDIDATE_METRIC_TYPE_IGP:
+ return "igp";
+ case SRTE_CANDIDATE_METRIC_TYPE_TE:
+ return "te";
+ case SRTE_CANDIDATE_METRIC_TYPE_HC:
+ return "hc";
+ case SRTE_CANDIDATE_METRIC_TYPE_ABC:
+ return "abc";
+ case SRTE_CANDIDATE_METRIC_TYPE_LMLL:
+ return "lmll";
+ case SRTE_CANDIDATE_METRIC_TYPE_CIGP:
+ return "cigp";
+ case SRTE_CANDIDATE_METRIC_TYPE_CTE:
+ return "cte";
+ case SRTE_CANDIDATE_METRIC_TYPE_PIGP:
+ return "pigp";
+ case SRTE_CANDIDATE_METRIC_TYPE_PTE:
+ return "pte";
+ case SRTE_CANDIDATE_METRIC_TYPE_PHC:
+ return "phc";
+ case SRTE_CANDIDATE_METRIC_TYPE_MSD:
+ return "msd";
+ case SRTE_CANDIDATE_METRIC_TYPE_PD:
+ return "pd";
+ case SRTE_CANDIDATE_METRIC_TYPE_PDV:
+ return "pdv";
+ case SRTE_CANDIDATE_METRIC_TYPE_PL:
+ return "pl";
+ case SRTE_CANDIDATE_METRIC_TYPE_PPD:
+ return "ppd";
+ case SRTE_CANDIDATE_METRIC_TYPE_PPDV:
+ return "ppdv";
+ case SRTE_CANDIDATE_METRIC_TYPE_PPL:
+ return "ppl";
+ case SRTE_CANDIDATE_METRIC_TYPE_NAP:
+ return "nap";
+ case SRTE_CANDIDATE_METRIC_TYPE_NLP:
+ return "nlp";
+ case SRTE_CANDIDATE_METRIC_TYPE_DC:
+ return "dc";
+ case SRTE_CANDIDATE_METRIC_TYPE_BNC:
+ return "bnc";
+ default:
+ return NULL;
+ }
+}
+
+static void config_write_float(struct vty *vty, float value)
+{
+ if (fabs(truncf(value) - value) < FLT_EPSILON) {
+ vty_out(vty, " %d", (int)value);
+ return;
+ } else {
+ vty_out(vty, " %f", value);
+ }
+}
+
+static void config_write_metric(struct vty *vty,
+ enum srte_candidate_metric_type type,
+ float value, bool required, bool is_bound)
+{
+ const char *name = metric_type_name(type);
+ if (name == NULL)
+ return;
+ vty_out(vty, " metric %s%s", is_bound ? "bound " : "",
+ metric_type_name(type));
+ config_write_float(vty, value);
+ vty_out(vty, required ? " required" : "");
+ vty_out(vty, "\n");
+}
+
+static int config_write_metric_cb(const struct lyd_node *dnode, void *arg)
+{
+ struct vty *vty = arg;
+ enum srte_candidate_metric_type type;
+ bool required, is_bound = false;
+ float value;
+
+ type = yang_dnode_get_enum(dnode, "./type");
+ value = (float)yang_dnode_get_dec64(dnode, "./value");
+ required = yang_dnode_get_bool(dnode, "./required");
+ if (yang_dnode_exists(dnode, "./is-bound"))
+ is_bound = yang_dnode_get_bool(dnode, "./is-bound");
+
+ config_write_metric(vty, type, value, required, is_bound);
+ return YANG_ITER_CONTINUE;
+}
+
+void cli_show_srte_policy_candidate_path(struct vty *vty,
+ const struct lyd_node *dnode,
+ bool show_defaults)
+{
+ float bandwidth;
+ uint32_t affinity;
+ bool required;
+ enum objfun_type objfun_type;
+ const char *type = yang_dnode_get_string(dnode, "./type");
+
+ vty_out(vty, " candidate-path preference %s name %s %s",
+ yang_dnode_get_string(dnode, "./preference"),
+ yang_dnode_get_string(dnode, "./name"), type);
+ if (strmatch(type, "explicit"))
+ vty_out(vty, " segment-list %s",
+ yang_dnode_get_string(dnode, "./segment-list-name"));
+ vty_out(vty, "\n");
+
+ if (strmatch(type, "dynamic")) {
+ if (yang_dnode_exists(dnode, "./constraints/bandwidth")) {
+ bandwidth = (float)yang_dnode_get_dec64(
+ dnode, "./constraints/bandwidth/value");
+ required = yang_dnode_get_bool(
+ dnode, "./constraints/bandwidth/required");
+ vty_out(vty, " bandwidth");
+ config_write_float(vty, bandwidth);
+ if (required)
+ vty_out(vty, " required");
+ vty_out(vty, "\n");
+ }
+ if (yang_dnode_exists(dnode,
+ "./constraints/affinity/exclude-any")) {
+ affinity = yang_dnode_get_uint32(
+ dnode, "./constraints/affinity/exclude-any");
+ vty_out(vty, " affinity exclude-any 0x%08x\n",
+ affinity);
+ }
+ if (yang_dnode_exists(dnode,
+ "./constraints/affinity/include-any")) {
+ affinity = yang_dnode_get_uint32(
+ dnode, "./constraints/affinity/include-any");
+ vty_out(vty, " affinity include-any 0x%08x\n",
+ affinity);
+ }
+ if (yang_dnode_exists(dnode,
+ "./constraints/affinity/include-all")) {
+ affinity = yang_dnode_get_uint32(
+ dnode, "./constraints/affinity/include-all");
+ vty_out(vty, " affinity include-all 0x%08x\n",
+ affinity);
+ }
+ yang_dnode_iterate(config_write_metric_cb, vty, dnode,
+ "./constraints/metrics");
+ if (yang_dnode_exists(dnode,
+ "./constraints/objective-function")) {
+ objfun_type = yang_dnode_get_enum(dnode,
+ "./constraints/objective-function/type");
+ required = yang_dnode_get_bool(dnode,
+ "./constraints/objective-function/required");
+ vty_out(vty, " objective-function %s%s\n",
+ objfun_type_name(objfun_type),
+ required ? " required" : "");
+ }
+ }
+}
+
+void cli_show_srte_policy_candidate_path_end(struct vty *vty,
+ const struct lyd_node *dnode)
+{
+ const char *type = yang_dnode_get_string(dnode, "./type");
+
+ if (strmatch(type, "dynamic"))
+ vty_out(vty, " exit\n");
+}
+
+static int config_write_dnode(const struct lyd_node *dnode, void *arg)
+{
+ struct vty *vty = arg;
+
+ nb_cli_show_dnode_cmds(vty, dnode, false);
+
+ return YANG_ITER_CONTINUE;
+}
+
+int config_write_segment_routing(struct vty *vty)
+{
+ vty_out(vty, "segment-routing\n");
+ vty_out(vty, " traffic-eng\n");
+
+ path_ted_config_write(vty);
+
+ yang_dnode_iterate(config_write_dnode, vty, running_config->dnode,
+ "/frr-pathd:pathd/srte/segment-list");
+ yang_dnode_iterate(config_write_dnode, vty, running_config->dnode,
+ "/frr-pathd:pathd/srte/policy");
+
+ hook_call(pathd_srte_config_write, vty);
+
+ vty_out(vty, " exit\n");
+ vty_out(vty, "exit\n");
+
+ return 1;
+}
+
+void path_cli_init(void)
+{
+ install_node(&segment_routing_node);
+ install_node(&sr_traffic_eng_node);
+ install_node(&srte_segment_list_node);
+ install_node(&srte_policy_node);
+ install_node(&srte_candidate_dyn_node);
+ install_default(SEGMENT_ROUTING_NODE);
+ install_default(SR_TRAFFIC_ENG_NODE);
+ install_default(SR_SEGMENT_LIST_NODE);
+ install_default(SR_POLICY_NODE);
+ install_default(SR_CANDIDATE_DYN_NODE);
+
+ install_element(ENABLE_NODE, &show_debugging_pathd_cmd);
+ install_element(ENABLE_NODE, &show_srte_policy_cmd);
+ install_element(ENABLE_NODE, &show_srte_policy_detail_cmd);
+
+ install_element(CONFIG_NODE, &segment_routing_cmd);
+ install_element(SEGMENT_ROUTING_NODE, &sr_traffic_eng_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &srte_segment_list_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &srte_no_segment_list_cmd);
+ install_element(SR_SEGMENT_LIST_NODE,
+ &srte_segment_list_segment_cmd);
+ install_element(SR_SEGMENT_LIST_NODE,
+ &srte_segment_list_no_segment_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &srte_policy_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &srte_no_policy_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_name_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_no_name_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_binding_sid_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_no_binding_sid_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_candidate_exp_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_candidate_dyn_cmd);
+ install_element(SR_POLICY_NODE, &srte_policy_no_candidate_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_bandwidth_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_no_bandwidth_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_affinity_filter_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_no_affinity_filter_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_metric_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_no_metric_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_objfun_cmd);
+ install_element(SR_CANDIDATE_DYN_NODE,
+ &srte_candidate_no_objfun_cmd);
+}
diff --git a/pathd/path_debug.c b/pathd/path_debug.c
new file mode 100644
index 0000000..eec5707
--- /dev/null
+++ b/pathd/path_debug.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include <string.h>
+#include <stdbool.h>
+#include <time.h>
+#include <libyang/libyang.h>
+
+#include "printfrr.h"
+#include "ipaddr.h"
+
+#include "pathd/path_debug.h"
+
+THREAD_DATA char _debug_buff[DEBUG_BUFF_SIZE];
+
+/**
+ * Gives the string representation of an srte_protocol_origin enum value.
+ *
+ * @param origin The enum value to convert to string
+ * @return a constant string representation of the enum value
+ */
+const char *srte_protocol_origin_name(enum srte_protocol_origin origin)
+{
+ switch (origin) {
+ case SRTE_ORIGIN_UNDEFINED:
+ return "UNDEFINED";
+ case SRTE_ORIGIN_PCEP:
+ return "PCEP";
+ case SRTE_ORIGIN_BGP:
+ return "BGP";
+ case SRTE_ORIGIN_LOCAL:
+ return "LOCAL";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+/**
+ * Gives the string representation of an srte_candidate_type enum value.
+ *
+ * @param origin The enum value to convert to string
+ * @return a constant string representation of the enum value
+ */
+const char *srte_candidate_type_name(enum srte_candidate_type type)
+{
+ switch (type) {
+ case SRTE_CANDIDATE_TYPE_EXPLICIT:
+ return "EXPLICIT";
+ case SRTE_CANDIDATE_TYPE_DYNAMIC:
+ return "DYNAMIC";
+ case SRTE_CANDIDATE_TYPE_UNDEFINED:
+ return "UNDEFINED";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+/**
+ * Gives the string representation of an objfun_type enum value.
+ *
+ * @param origin The enum value to convert to string
+ * @return a constant string representation of the enum value
+ */
+const char *objfun_type_name(enum objfun_type type)
+{
+ switch (type) {
+ case OBJFUN_UNDEFINED:
+ return "UNDEFINED";
+ case OBJFUN_MCP:
+ return "MCP";
+ case OBJFUN_MLP:
+ return "MLP";
+ case OBJFUN_MBP:
+ return "MBP";
+ case OBJFUN_MBC:
+ return "MBC";
+ case OBJFUN_MLL:
+ return "MLL";
+ case OBJFUN_MCC:
+ return "MCC";
+ case OBJFUN_SPT:
+ return "SPT";
+ case OBJFUN_MCT:
+ return "MCT";
+ case OBJFUN_MPLP:
+ return "MPLP";
+ case OBJFUN_MUP:
+ return "MUP";
+ case OBJFUN_MRUP:
+ return "MRUP";
+ case OBJFUN_MTD:
+ return "MTD";
+ case OBJFUN_MBN:
+ return "MBN";
+ case OBJFUN_MCTD:
+ return "MCTD";
+ case OBJFUN_MSL:
+ return "MSL";
+ case OBJFUN_MSS:
+ return "MSS";
+ case OBJFUN_MSN:
+ return "MSN";
+ default:
+ return "UNKNOWN";
+ }
+}
diff --git a/pathd/path_debug.h b/pathd/path_debug.h
new file mode 100644
index 0000000..d9cfcb6
--- /dev/null
+++ b/pathd/path_debug.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_DEBUG_H_
+#define _PATH_DEBUG_H_
+
+#include "pathd/pathd.h"
+
+#ifdef __GNUC__
+#define THREAD_DATA __thread
+#else
+#define THREAD_DATA
+#endif
+
+#define DEBUG_IDENT_SIZE 4
+#define DEBUG_BUFF_SIZE 4096
+#define TUP(A, B) ((((uint32_t)(A)) << 16) | ((uint32_t)(B)))
+#define PATHD_FORMAT_INIT() _debug_buff[0] = 0
+#define PATHD_FORMAT(fmt, ...) \
+ csnprintfrr(_debug_buff, DEBUG_BUFF_SIZE, fmt, ##__VA_ARGS__)
+#define PATHD_FORMAT_FINI() _debug_buff
+
+extern THREAD_DATA char _debug_buff[DEBUG_BUFF_SIZE];
+
+const char *srte_protocol_origin_name(enum srte_protocol_origin origin);
+const char *srte_candidate_type_name(enum srte_candidate_type type);
+const char *objfun_type_name(enum objfun_type type);
+
+#endif // _PATH_DEBUG_H_ \ No newline at end of file
diff --git a/pathd/path_errors.c b/pathd/path_errors.c
new file mode 100644
index 0000000..68372c2
--- /dev/null
+++ b/pathd/path_errors.c
@@ -0,0 +1,140 @@
+/*
+ * pathd-specific error messages.
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "lib/ferr.h"
+#include "path_errors.h"
+
+/* clang-format off */
+static struct log_ref ferr_path_err[] = {
+ {
+ .code = EC_PATH_SYSTEM_CALL,
+ .title = "Thread setup error",
+ .description = "A system call for creating, or setting up PCEP module's pthread failed",
+ .suggestion = "Open an Issue with all relevant log files and restart FRR"
+ },
+ {
+ .code = EC_PATH_PCEP_PCC_INIT,
+ .title = "PCC initialization error",
+ .description = "pceplib PCC initialization call failed",
+ .suggestion = "Open an Issue with all relevant log files and restart FRR"
+ },
+ {
+ .code = EC_PATH_PCEP_PCC_FINI,
+ .title = "PCC finalization error",
+ .description = "pceplib PCC finalization call failed",
+ .suggestion = "Open an Issue with all relevant log files and restart FRR"
+ },
+ {
+ .code = EC_PATH_PCEP_PCC_CONF_UPDATE,
+ .title = "PCC configuration update error",
+ .description = "The update of the PCC configuration failed",
+ .suggestion = "Open an Issue with all relevant log files and restart FRR"
+ },
+ {
+ .code = END_FERR,
+ }
+};
+
+static struct log_ref ferr_path_warn[] = {
+ {
+ .code = EC_PATH_PCEP_LIB_CONNECT,
+ .title = "PCC connection error",
+ .description = "The PCEP module failed to connected to configured PCE",
+ .suggestion = "Check the connectivity between the PCC and the PCE"
+ },
+ {
+ .code = EC_PATH_PCEP_PROTOCOL_ERROR,
+ .title = "PCEP protocol error",
+ .description = "The PCE did not respect the PCEP protocol",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ .title = "PCC connection error",
+ .description = "The PCEP module did not try to connect because it is missing a source address",
+ .suggestion = "Wait for the router ID to be defined or set the PCC source address in the configuration"
+ },
+ {
+ .code = EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ .title = "Recoverable internal error",
+ .description = "Some recoverable internal error",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ .title = "Unsupported PCEP feature",
+ .description = "Received an unsupported PCEP message",
+ .suggestion = "The PCC and PCE are probably not compatible. Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNEXPECTED_PCEP_MESSAGE,
+ .title = "Unexpected PCEP message",
+ .description = "The PCEP module received an unexpected PCEP message",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNEXPECTED_PCEPLIB_EVENT,
+ .title = "Unexpected pceplib event",
+ .description = "The PCEP module received an unexpected event from pceplib",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNEXPECTED_PCEP_OBJECT,
+ .title = "Unexpected PCEP object",
+ .description = "The PCEP module received an unexpected PCEP object from a PCE",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ .title = "Unexpected PCEP TLV",
+ .description = "The PCEP module received an unexpected PCEP TLV from a PCE",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNEXPECTED_PCEP_ERO_SUBOBJ,
+ .title = "Unexpected PCEP ERO sub-object",
+ .description = "The PCEP module received an unexpected PCEP ERO sub-object from a PCE",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_UNEXPECTED_SR_NAI,
+ .title = "Unexpected PCEP SR segment NAI",
+ .description = "The PCEP module received an SR segment with an unsupported NAI specification from the PCE",
+ .suggestion = "Open an Issue with all relevant log files"
+ },
+ {
+ .code = EC_PATH_PCEP_COMPUTATION_REQUEST_TIMEOUT,
+ .title = "Computation request timeout",
+ .description = "The PCE did not respond in time to the PCC computation request",
+ .suggestion = "The PCE is overloaded or incompatible with the PCC, try with a different PCE"
+ },
+ {
+ .code = END_FERR,
+ }
+
+};
+/* clang-format on */
+
+void path_error_init(void)
+{
+ log_ref_add(ferr_path_err);
+ log_ref_add(ferr_path_warn);
+}
diff --git a/pathd/path_errors.h b/pathd/path_errors.h
new file mode 100644
index 0000000..5d05b66
--- /dev/null
+++ b/pathd/path_errors.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef __PATH_ERRORS_H__
+#define __PATH_ERRORS_H__
+
+#include "lib/ferr.h"
+
+enum path_log_refs {
+ EC_PATH_PCEP_INIT = PATH_FERR_START,
+ EC_PATH_SYSTEM_CALL,
+ EC_PATH_PCEP_PCC_INIT,
+ EC_PATH_PCEP_PCC_FINI,
+ EC_PATH_PCEP_PCC_CONF_UPDATE,
+ EC_PATH_PCEP_LIB_CONNECT,
+ EC_PATH_PCEP_PROTOCOL_ERROR,
+ EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ EC_PATH_PCEP_UNEXPECTED_PCEP_MESSAGE,
+ EC_PATH_PCEP_UNEXPECTED_PCEPLIB_EVENT,
+ EC_PATH_PCEP_UNEXPECTED_PCEP_OBJECT,
+ EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ EC_PATH_PCEP_UNEXPECTED_PCEP_ERO_SUBOBJ,
+ EC_PATH_PCEP_UNEXPECTED_SR_NAI,
+ EC_PATH_PCEP_COMPUTATION_REQUEST_TIMEOUT
+};
+
+extern void path_error_init(void);
+
+#endif
diff --git a/pathd/path_main.c b/pathd/path_main.c
new file mode 100644
index 0000000..0a71c80
--- /dev/null
+++ b/pathd/path_main.c
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <zebra.h>
+
+#include <lib/version.h>
+#include "getopt.h"
+#include "thread.h"
+#include "command.h"
+#include "log.h"
+#include "memory.h"
+#include "privs.h"
+#include "sigevent.h"
+#include "libfrr.h"
+#include "vrf.h"
+#include "filter.h"
+
+#include "pathd.h"
+#include "path_nb.h"
+#include "path_zebra.h"
+#include "path_errors.h"
+#include "path_ted.h"
+
+char backup_config_file[256];
+
+zebra_capabilities_t _caps_p[] = {};
+
+struct zebra_privs_t pathd_privs = {
+#if defined(FRR_USER) && defined(FRR_GROUP)
+ .user = FRR_USER,
+ .group = FRR_GROUP,
+#endif
+#if defined(VTY_GROUP)
+ .vty_group = VTY_GROUP,
+#endif
+ .caps_p = _caps_p,
+ .cap_num_p = array_size(_caps_p),
+ .cap_num_i = 0};
+
+struct option longopts[] = {{0}};
+
+/* Master of threads. */
+struct thread_master *master;
+
+static struct frr_daemon_info pathd_di;
+
+/* SIGHUP handler. */
+static void sighup(void)
+{
+ zlog_info("SIGHUP received");
+
+ /* Reload config file. */
+ vty_read_config(NULL, pathd_di.config_file, config_default);
+}
+
+/* SIGINT / SIGTERM handler. */
+static void sigint(void)
+{
+ zlog_notice("Terminating on signal");
+ zlog_notice("Unregisterfrom opaque,etc ");
+ pathd_shutdown();
+
+ exit(0);
+}
+
+/* SIGUSR1 handler. */
+static void sigusr1(void)
+{
+ zlog_rotate();
+}
+
+struct frr_signal_t path_signals[] = {
+ {
+ .signal = SIGHUP,
+ .handler = &sighup,
+ },
+ {
+ .signal = SIGUSR1,
+ .handler = &sigusr1,
+ },
+ {
+ .signal = SIGINT,
+ .handler = &sigint,
+ },
+ {
+ .signal = SIGTERM,
+ .handler = &sigint,
+ },
+};
+
+static const struct frr_yang_module_info *pathd_yang_modules[] = {
+ &frr_filter_info,
+ &frr_interface_info,
+ &frr_pathd_info,
+};
+
+#define PATH_VTY_PORT 2621
+
+FRR_DAEMON_INFO(pathd, PATH, .vty_port = PATH_VTY_PORT,
+
+ .proghelp = "Implementation of PATH.",
+
+ .signals = path_signals, .n_signals = array_size(path_signals),
+
+ .privs = &pathd_privs, .yang_modules = pathd_yang_modules,
+ .n_yang_modules = array_size(pathd_yang_modules),
+);
+
+int main(int argc, char **argv, char **envp)
+{
+ frr_preinit(&pathd_di, argc, argv);
+ frr_opt_add("", longopts, "");
+
+ while (1) {
+ int opt;
+
+ opt = frr_getopt(argc, argv, NULL);
+
+ if (opt == EOF)
+ break;
+
+ switch (opt) {
+ case 0:
+ break;
+ default:
+ frr_help_exit(1);
+ }
+ }
+
+ master = frr_init();
+
+ access_list_init();
+
+ path_error_init();
+ path_zebra_init(master);
+ path_cli_init();
+ path_ted_init(master);
+
+ frr_config_fork();
+ frr_run(master);
+
+ /* Not reached. */
+ return 0;
+}
diff --git a/pathd/path_nb.c b/pathd/path_nb.c
new file mode 100644
index 0000000..1ab8b7f
--- /dev/null
+++ b/pathd/path_nb.c
@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "northbound.h"
+#include "libfrr.h"
+
+#include "pathd/path_nb.h"
+
+static int iter_objfun_cb(const struct lyd_node *dnode, void *arg);
+static int dummy_create(struct nb_cb_create_args *args);
+static int dummy_modify(struct nb_cb_modify_args *args);
+static int dummy_destroy(struct nb_cb_destroy_args *args);
+
+struct of_cb_pref {
+ uint32_t index;
+ enum objfun_type type;
+ struct of_cb_pref *next;
+};
+
+struct of_cb_args {
+ struct of_cb_pref *first;
+ uint32_t free_slot;
+ struct of_cb_pref prefs[MAX_OBJFUN_TYPE];
+};
+
+/* clang-format off */
+const struct frr_yang_module_info frr_pathd_info = {
+ .name = "frr-pathd",
+ .nodes = {
+ {
+ .xpath = "/frr-pathd:pathd",
+ .cbs = {
+ .apply_finish = pathd_apply_finish,
+ },
+ .priority = NB_DFLT_PRIORITY + 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list",
+ .cbs = {
+ .create = pathd_srte_segment_list_create,
+ .cli_show = cli_show_srte_segment_list,
+ .cli_show_end = cli_show_srte_segment_list_end,
+ .destroy = pathd_srte_segment_list_destroy,
+ .get_next = pathd_srte_segment_list_get_next,
+ .get_keys = pathd_srte_segment_list_get_keys,
+ .lookup_entry = pathd_srte_segment_list_lookup_entry,
+ },
+ .priority = NB_DFLT_PRIORITY - 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/protocol-origin",
+ .cbs = {
+ .modify = pathd_srte_segment_list_protocol_origin_modify,
+ },
+ .priority = NB_DFLT_PRIORITY - 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/originator",
+ .cbs = {
+ .modify = pathd_srte_segment_list_originator_modify,
+ },
+ .priority = NB_DFLT_PRIORITY - 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment",
+ .cbs = {
+ .create = pathd_srte_segment_list_segment_create,
+ .cli_show = cli_show_srte_segment_list_segment,
+ .destroy = pathd_srte_segment_list_segment_destroy,
+ },
+ .priority = NB_DFLT_PRIORITY - 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/sid-value",
+ .cbs = {
+ .modify = pathd_srte_segment_list_segment_sid_value_modify,
+ .destroy = pathd_srte_segment_list_segment_sid_value_destroy,
+ },
+ .priority = NB_DFLT_PRIORITY - 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai",
+ .cbs = {
+ .create = dummy_create,
+ .destroy = pathd_srte_segment_list_segment_nai_destroy,
+ .apply_finish = pathd_srte_segment_list_segment_nai_apply_finish
+ },
+ .priority = NB_DFLT_PRIORITY - 1
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/type",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/local-address",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/local-interface",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/local-prefix-len",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/remote-address",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/remote-interface",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/segment-list/segment/nai/algorithm",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy",
+ .cbs = {
+ .create = pathd_srte_policy_create,
+ .cli_show = cli_show_srte_policy,
+ .cli_show_end = cli_show_srte_policy_end,
+ .destroy = pathd_srte_policy_destroy,
+ .get_next = pathd_srte_policy_get_next,
+ .get_keys = pathd_srte_policy_get_keys,
+ .lookup_entry = pathd_srte_policy_lookup_entry,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/name",
+ .cbs = {
+ .modify = pathd_srte_policy_name_modify,
+ .cli_show = cli_show_srte_policy_name,
+ .destroy = pathd_srte_policy_name_destroy,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/binding-sid",
+ .cbs = {
+ .modify = pathd_srte_policy_binding_sid_modify,
+ .cli_show = cli_show_srte_policy_binding_sid,
+ .destroy = pathd_srte_policy_binding_sid_destroy,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/is-operational",
+ .cbs = {
+ .get_elem = pathd_srte_policy_is_operational_get_elem
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path",
+ .cbs = {
+ .create = pathd_srte_policy_candidate_path_create,
+ .cli_show = cli_show_srte_policy_candidate_path,
+ .cli_show_end = cli_show_srte_policy_candidate_path_end,
+ .destroy = pathd_srte_policy_candidate_path_destroy,
+ .get_next = pathd_srte_policy_candidate_path_get_next,
+ .get_keys = pathd_srte_policy_candidate_path_get_keys,
+ .lookup_entry = pathd_srte_policy_candidate_path_lookup_entry,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/name",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_name_modify,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/is-best-candidate-path",
+ .cbs = {
+ .get_elem = pathd_srte_policy_candidate_path_is_best_candidate_path_get_elem,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/protocol-origin",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_protocol_origin_modify,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/originator",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_originator_modify,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/discriminator",
+ .cbs = {
+ .get_elem = pathd_srte_policy_candidate_path_discriminator_get_elem,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/type",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_type_modify,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/segment-list-name",
+ .cbs = {
+ .destroy = pathd_srte_policy_candidate_path_segment_list_name_destroy,
+ .modify = pathd_srte_policy_candidate_path_segment_list_name_modify,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/bandwidth",
+ .cbs = {
+ .create = dummy_create,
+ .destroy = pathd_srte_policy_candidate_path_bandwidth_destroy,
+ .apply_finish = pathd_srte_policy_candidate_path_bandwidth_apply_finish
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/bandwidth/required",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/bandwidth/value",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/affinity/exclude-any",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_exclude_any_modify,
+ .destroy = pathd_srte_policy_candidate_path_exclude_any_destroy,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/affinity/include-any",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_include_any_modify,
+ .destroy = pathd_srte_policy_candidate_path_include_any_destroy,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/affinity/include-all",
+ .cbs = {
+ .modify = pathd_srte_policy_candidate_path_include_all_modify,
+ .destroy = pathd_srte_policy_candidate_path_include_all_destroy,
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/metrics",
+ .cbs = {
+ .create = dummy_create,
+ .destroy = pathd_srte_policy_candidate_path_metrics_destroy,
+ .apply_finish = pathd_srte_policy_candidate_path_metrics_apply_finish
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/metrics/value",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/metrics/required",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/metrics/is-bound",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/metrics/is-computed",
+ .cbs = {.modify = dummy_modify, .destroy = dummy_destroy}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/objective-function",
+ .cbs = {
+ .create = dummy_create,
+ .destroy = pathd_srte_policy_candidate_path_objfun_destroy,
+ .apply_finish = pathd_srte_policy_candidate_path_objfun_apply_finish
+ }
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/objective-function/required",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = "/frr-pathd:pathd/srte/policy/candidate-path/constraints/objective-function/type",
+ .cbs = {.modify = dummy_modify}
+ },
+ {
+ .xpath = NULL,
+ },
+ }
+};
+
+void iter_objfun_prefs(const struct lyd_node *dnode, const char* path,
+ of_pref_cp_t fun, void *arg)
+{
+ struct of_cb_args args = {0};
+ struct of_cb_pref *p;
+
+ yang_dnode_iterate(iter_objfun_cb, &args, dnode, path);
+ for (p = args.first; p != NULL; p = p->next)
+ fun(p->type, arg);
+}
+
+int iter_objfun_cb(const struct lyd_node *dnode, void *arg)
+{
+ struct of_cb_args *of_arg = arg;
+ struct of_cb_pref *pref;
+ struct of_cb_pref **p;
+
+ if (of_arg->free_slot >= MAX_OBJFUN_TYPE)
+ return YANG_ITER_STOP;
+
+ pref = &of_arg->prefs[of_arg->free_slot++];
+
+ pref->index = yang_dnode_get_uint32(dnode, "./index");
+ pref->type = yang_dnode_get_enum(dnode, "./type");
+
+ /* Simplistic insertion sort */
+ p = &of_arg->first;
+ while (true) {
+ if (*p == NULL) {
+ *p = pref;
+ break;
+ }
+ if ((*p)->index >= pref->index) {
+ pref->next = *p;
+ *p = pref;
+ break;
+ }
+ p = &(*p)->next;
+ }
+
+ return YANG_ITER_CONTINUE;
+}
+
+int dummy_create(struct nb_cb_create_args *args)
+{
+ return NB_OK;
+}
+
+int dummy_modify(struct nb_cb_modify_args *args)
+{
+ return NB_OK;
+}
+
+int dummy_destroy(struct nb_cb_destroy_args *args)
+{
+ return NB_OK;
+}
diff --git a/pathd/path_nb.h b/pathd/path_nb.h
new file mode 100644
index 0000000..dacc5eb
--- /dev/null
+++ b/pathd/path_nb.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _FRR_PATH_NB_H_
+#define _FRR_PATH_NB_H_
+
+#include "pathd/pathd.h"
+
+extern const struct frr_yang_module_info frr_pathd_info;
+
+/* Mandatory callbacks. */
+int pathd_srte_segment_list_create(struct nb_cb_create_args *args);
+int pathd_srte_segment_list_destroy(struct nb_cb_destroy_args *args);
+
+const void *pathd_srte_segment_list_get_next(struct nb_cb_get_next_args *args);
+int pathd_srte_segment_list_get_keys(struct nb_cb_get_keys_args *args);
+const void *
+pathd_srte_segment_list_lookup_entry(struct nb_cb_lookup_entry_args *args);
+
+int pathd_srte_segment_list_segment_create(struct nb_cb_create_args *args);
+int pathd_srte_segment_list_segment_destroy(struct nb_cb_destroy_args *args);
+int pathd_srte_segment_list_protocol_origin_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_segment_list_originator_modify(struct nb_cb_modify_args *args);
+int pathd_srte_segment_list_segment_sid_value_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_segment_list_segment_nai_destroy(
+ struct nb_cb_destroy_args *args);
+void pathd_srte_segment_list_segment_nai_apply_finish(
+ struct nb_cb_apply_finish_args *args);
+int pathd_srte_segment_list_segment_sid_value_destroy(
+ struct nb_cb_destroy_args *args);
+int pathd_srte_policy_create(struct nb_cb_create_args *args);
+int pathd_srte_policy_destroy(struct nb_cb_destroy_args *args);
+const void *pathd_srte_policy_get_next(struct nb_cb_get_next_args *args);
+int pathd_srte_policy_get_keys(struct nb_cb_get_keys_args *args);
+const void *
+pathd_srte_policy_lookup_entry(struct nb_cb_lookup_entry_args *args);
+int pathd_srte_policy_name_modify(struct nb_cb_modify_args *args);
+int pathd_srte_policy_name_destroy(struct nb_cb_destroy_args *args);
+int pathd_srte_policy_binding_sid_modify(struct nb_cb_modify_args *args);
+int pathd_srte_policy_binding_sid_destroy(struct nb_cb_destroy_args *args);
+struct yang_data *
+pathd_srte_policy_is_operational_get_elem(struct nb_cb_get_elem_args *args);
+int pathd_srte_policy_candidate_path_create(struct nb_cb_create_args *args);
+int pathd_srte_policy_candidate_path_destroy(struct nb_cb_destroy_args *args);
+int pathd_srte_policy_candidate_path_name_modify(
+ struct nb_cb_modify_args *args);
+const void *
+pathd_srte_policy_candidate_path_get_next(struct nb_cb_get_next_args *args);
+int pathd_srte_policy_candidate_path_get_keys(struct nb_cb_get_keys_args *args);
+const void *pathd_srte_policy_candidate_path_lookup_entry(
+ struct nb_cb_lookup_entry_args *args);
+void pathd_srte_policy_candidate_path_bandwidth_apply_finish(
+ struct nb_cb_apply_finish_args *args);
+int pathd_srte_policy_candidate_path_bandwidth_destroy(
+ struct nb_cb_destroy_args *args);
+int pathd_srte_policy_candidate_path_exclude_any_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_policy_candidate_path_exclude_any_destroy(
+ struct nb_cb_destroy_args *args);
+int pathd_srte_policy_candidate_path_include_any_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_policy_candidate_path_include_any_destroy(
+ struct nb_cb_destroy_args *args);
+int pathd_srte_policy_candidate_path_include_all_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_policy_candidate_path_include_all_destroy(
+ struct nb_cb_destroy_args *args);
+int pathd_srte_policy_candidate_path_metrics_destroy(
+ struct nb_cb_destroy_args *args);
+void pathd_srte_policy_candidate_path_metrics_apply_finish(
+ struct nb_cb_apply_finish_args *args);
+int pathd_srte_policy_candidate_path_objfun_destroy(
+ struct nb_cb_destroy_args *args);
+void pathd_srte_policy_candidate_path_objfun_apply_finish(
+ struct nb_cb_apply_finish_args *args);
+struct yang_data *
+pathd_srte_policy_candidate_path_is_best_candidate_path_get_elem(
+ struct nb_cb_get_elem_args *args);
+int pathd_srte_policy_candidate_path_protocol_origin_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_policy_candidate_path_originator_modify(
+ struct nb_cb_modify_args *args);
+struct yang_data *pathd_srte_policy_candidate_path_discriminator_get_elem(
+ struct nb_cb_get_elem_args *args);
+int pathd_srte_policy_candidate_path_type_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_policy_candidate_path_segment_list_name_modify(
+ struct nb_cb_modify_args *args);
+int pathd_srte_policy_candidate_path_segment_list_name_destroy(
+ struct nb_cb_destroy_args *args);
+
+/* Optional 'apply_finish' callbacks. */
+void pathd_apply_finish(struct nb_cb_apply_finish_args *args);
+
+/* Optional 'cli_show' callbacks. */
+void cli_show_srte_segment_list(struct vty *vty, const struct lyd_node *dnode,
+ bool show_defaults);
+void cli_show_srte_segment_list_end(struct vty *vty,
+ const struct lyd_node *dnode);
+void cli_show_srte_segment_list_segment(struct vty *vty,
+ const struct lyd_node *dnode,
+ bool show_defaults);
+void cli_show_srte_policy(struct vty *vty, const struct lyd_node *dnode,
+ bool show_defaults);
+void cli_show_srte_policy_end(struct vty *vty, const struct lyd_node *dnode);
+void cli_show_srte_policy_name(struct vty *vty, const struct lyd_node *dnode,
+ bool show_defaults);
+void cli_show_srte_policy_binding_sid(struct vty *vty,
+ const struct lyd_node *dnode,
+ bool show_defaults);
+void cli_show_srte_policy_candidate_path(struct vty *vty,
+ const struct lyd_node *dnode,
+ bool show_defaults);
+void cli_show_srte_policy_candidate_path_end(struct vty *vty,
+ const struct lyd_node *dnode);
+
+/* Utility functions */
+typedef void (*of_pref_cp_t)(enum objfun_type type, void *arg);
+void iter_objfun_prefs(const struct lyd_node *dnode, const char *path,
+ of_pref_cp_t fun, void *arg);
+
+#endif /* _FRR_PATH_NB_H_ */
diff --git a/pathd/path_nb_config.c b/pathd/path_nb_config.c
new file mode 100644
index 0000000..e1fbb37
--- /dev/null
+++ b/pathd/path_nb_config.c
@@ -0,0 +1,769 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include <lib_errors.h>
+
+#include "northbound.h"
+#include "libfrr.h"
+
+#include "pathd/path_zebra.h"
+#include "pathd/path_nb.h"
+
+/*
+ * XPath: /frr-pathd:pathd
+ */
+void pathd_apply_finish(struct nb_cb_apply_finish_args *args)
+{
+ srte_apply_changes();
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list
+ */
+int pathd_srte_segment_list_create(struct nb_cb_create_args *args)
+{
+ struct srte_segment_list *segment_list;
+ const char *name;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ name = yang_dnode_get_string(args->dnode, "./name");
+ segment_list = srte_segment_list_add(name);
+ nb_running_set_entry(args->dnode, segment_list);
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_NEW);
+
+ return NB_OK;
+}
+
+int pathd_srte_segment_list_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_segment_list *segment_list;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment_list = nb_running_unset_entry(args->dnode);
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_DELETED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list/protocol-origin
+ */
+int pathd_srte_segment_list_protocol_origin_modify(
+ struct nb_cb_modify_args *args)
+{
+ struct srte_segment_list *segment_list;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment_list = nb_running_get_entry(args->dnode, NULL, true);
+ segment_list->protocol_origin = yang_dnode_get_enum(args->dnode, NULL);
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list/originator
+ */
+int pathd_srte_segment_list_originator_modify(struct nb_cb_modify_args *args)
+{
+ struct srte_segment_list *segment_list;
+ const char *originator;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment_list = nb_running_get_entry(args->dnode, NULL, true);
+ originator = yang_dnode_get_string(args->dnode, NULL);
+ strlcpy(segment_list->originator, originator,
+ sizeof(segment_list->originator));
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ return NB_OK;
+}
+
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list/segment
+ */
+int pathd_srte_segment_list_segment_create(struct nb_cb_create_args *args)
+{
+ struct srte_segment_list *segment_list;
+ struct srte_segment_entry *segment;
+ uint32_t index;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment_list = nb_running_get_entry(args->dnode, NULL, true);
+ index = yang_dnode_get_uint32(args->dnode, "./index");
+ segment = srte_segment_entry_add(segment_list, index);
+ nb_running_set_entry(args->dnode, segment);
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ return NB_OK;
+}
+
+int pathd_srte_segment_list_segment_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_segment_entry *segment;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment = nb_running_unset_entry(args->dnode);
+ SET_FLAG(segment->segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ srte_segment_entry_del(segment);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list/segment/sid-value
+ */
+int pathd_srte_segment_list_segment_sid_value_modify(
+ struct nb_cb_modify_args *args)
+{
+ mpls_label_t sid_value;
+ struct srte_segment_entry *segment;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment = nb_running_get_entry(args->dnode, NULL, true);
+ sid_value = yang_dnode_get_uint32(args->dnode, NULL);
+ segment->sid_value = sid_value;
+ SET_FLAG(segment->segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ return NB_OK;
+}
+
+int pathd_srte_segment_list_segment_sid_value_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ struct srte_segment_entry *segment;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment = nb_running_get_entry(args->dnode, NULL, true);
+ segment->sid_value = MPLS_LABEL_NONE;
+ SET_FLAG(segment->segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ return NB_OK;
+}
+
+
+int pathd_srte_segment_list_segment_nai_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_segment_entry *segment;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ segment = nb_running_get_entry(args->dnode, NULL, true);
+ segment->nai_type = SRTE_SEGMENT_NAI_TYPE_NONE;
+ segment->nai_local_addr.ipa_type = IPADDR_NONE;
+ segment->nai_local_iface = 0;
+ segment->nai_remote_addr.ipa_type = IPADDR_NONE;
+ segment->nai_remote_iface = 0;
+
+ return NB_OK;
+}
+
+void pathd_srte_segment_list_segment_nai_apply_finish(
+ struct nb_cb_apply_finish_args *args)
+{
+ struct srte_segment_entry *segment;
+ enum srte_segment_nai_type type;
+ struct ipaddr local_addr, remote_addr;
+ uint32_t local_iface = 0, remote_iface = 0;
+ uint8_t algo = 0, local_prefix_len = 0;
+ const char *algo_buf, *local_prefix_len_buf;
+
+ segment = nb_running_get_entry(args->dnode, NULL, true);
+ type = yang_dnode_get_enum(args->dnode, "./type");
+
+ yang_dnode_get_ip(&local_addr, args->dnode, "./local-address");
+
+ switch (type) {
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_NODE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_NODE:
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY:
+ yang_dnode_get_ip(&remote_addr, args->dnode,
+ "./remote-address");
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_UNNUMBERED_ADJACENCY:
+ yang_dnode_get_ip(&remote_addr, args->dnode,
+ "./remote-address");
+ local_iface =
+ yang_dnode_get_uint32(args->dnode, "./local-interface");
+ remote_iface = yang_dnode_get_uint32(args->dnode,
+ "./remote-interface");
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM:
+ algo_buf = yang_dnode_get_string(args->dnode, "./algorithm");
+ algo = atoi(algo_buf);
+ local_prefix_len_buf = yang_dnode_get_string(
+ args->dnode, "./local-prefix-len");
+ local_prefix_len = atoi(local_prefix_len_buf);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE:
+ local_iface =
+ yang_dnode_get_uint32(args->dnode, "./local-interface");
+ local_prefix_len_buf = yang_dnode_get_string(
+ args->dnode, "./local-prefix-len");
+ local_prefix_len = atoi(local_prefix_len_buf);
+ break;
+ default:
+ break;
+ }
+
+ zlog_debug(" Segment list name (%d) index (%s) ", segment->index,
+ segment->segment_list->name);
+ if (srte_segment_entry_set_nai(segment, type, &local_addr, local_iface,
+ &remote_addr, remote_iface, algo,
+ local_prefix_len))
+ SET_FLAG(segment->segment_list->flags,
+ F_SEGMENT_LIST_SID_CONFLICT);
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy
+ */
+int pathd_srte_policy_create(struct nb_cb_create_args *args)
+{
+ struct srte_policy *policy;
+ uint32_t color;
+ struct ipaddr endpoint;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ color = yang_dnode_get_uint32(args->dnode, "./color");
+ yang_dnode_get_ip(&endpoint, args->dnode, "./endpoint");
+ policy = srte_policy_add(color, &endpoint, SRTE_ORIGIN_LOCAL, NULL);
+
+ nb_running_set_entry(args->dnode, policy);
+ SET_FLAG(policy->flags, F_POLICY_NEW);
+
+ return NB_OK;
+}
+
+int pathd_srte_policy_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_policy *policy;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ policy = nb_running_unset_entry(args->dnode);
+ SET_FLAG(policy->flags, F_POLICY_DELETED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/name
+ */
+int pathd_srte_policy_name_modify(struct nb_cb_modify_args *args)
+{
+ struct srte_policy *policy;
+ const char *name;
+
+ if (args->event != NB_EV_APPLY && args->event != NB_EV_VALIDATE)
+ return NB_OK;
+
+ policy = nb_running_get_entry(args->dnode, NULL, true);
+
+ if (args->event == NB_EV_VALIDATE) {
+ /* the policy name is fixed after setting it once */
+ if (strlen(policy->name) > 0) {
+ flog_warn(EC_LIB_NB_CB_CONFIG_VALIDATE,
+ "The SR Policy name is fixed!");
+ return NB_ERR_RESOURCE;
+ } else
+ return NB_OK;
+ }
+
+ name = yang_dnode_get_string(args->dnode, NULL);
+ strlcpy(policy->name, name, sizeof(policy->name));
+ SET_FLAG(policy->flags, F_POLICY_MODIFIED);
+
+ return NB_OK;
+}
+
+int pathd_srte_policy_name_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_policy *policy;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ policy = nb_running_get_entry(args->dnode, NULL, true);
+ policy->name[0] = '\0';
+ SET_FLAG(policy->flags, F_POLICY_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/binding-sid
+ */
+int pathd_srte_policy_binding_sid_modify(struct nb_cb_modify_args *args)
+{
+ struct srte_policy *policy;
+ mpls_label_t binding_sid;
+
+ binding_sid = yang_dnode_get_uint32(args->dnode, NULL);
+
+ switch (args->event) {
+ case NB_EV_VALIDATE:
+ break;
+ case NB_EV_PREPARE:
+ if (path_zebra_request_label(binding_sid) < 0)
+ return NB_ERR_RESOURCE;
+ break;
+ case NB_EV_ABORT:
+ break;
+ case NB_EV_APPLY:
+ policy = nb_running_get_entry(args->dnode, NULL, true);
+ srte_policy_update_binding_sid(policy, binding_sid);
+ SET_FLAG(policy->flags, F_POLICY_MODIFIED);
+ break;
+ }
+
+ return NB_OK;
+}
+
+int pathd_srte_policy_binding_sid_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_policy *policy;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ policy = nb_running_get_entry(args->dnode, NULL, true);
+ srte_policy_update_binding_sid(policy, MPLS_LABEL_NONE);
+ SET_FLAG(policy->flags, F_POLICY_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path
+ */
+int pathd_srte_policy_candidate_path_create(struct nb_cb_create_args *args)
+{
+ struct srte_policy *policy;
+ struct srte_candidate *candidate;
+ uint32_t preference;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ policy = nb_running_get_entry(args->dnode, NULL, true);
+ preference = yang_dnode_get_uint32(args->dnode, "./preference");
+ candidate =
+ srte_candidate_add(policy, preference, SRTE_ORIGIN_LOCAL, NULL);
+ nb_running_set_entry(args->dnode, candidate);
+ SET_FLAG(candidate->flags, F_CANDIDATE_NEW);
+
+ return NB_OK;
+}
+
+int pathd_srte_policy_candidate_path_destroy(struct nb_cb_destroy_args *args)
+{
+ struct srte_candidate *candidate;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ candidate = nb_running_unset_entry(args->dnode);
+ SET_FLAG(candidate->flags, F_CANDIDATE_DELETED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/name
+ */
+int pathd_srte_policy_candidate_path_name_modify(struct nb_cb_modify_args *args)
+{
+ struct srte_candidate *candidate;
+ const char *name;
+ char xpath[XPATH_MAXLEN];
+ char xpath_buf[XPATH_MAXLEN - 3];
+
+ if (args->event != NB_EV_APPLY && args->event != NB_EV_VALIDATE)
+ return NB_OK;
+
+ /* the candidate name is fixed after setting it once, this is checked
+ * here */
+ if (args->event == NB_EV_VALIDATE) {
+ /* first get the precise path to the candidate path */
+ yang_dnode_get_path(args->dnode, xpath_buf, sizeof(xpath_buf));
+ snprintf(xpath, sizeof(xpath), "%s%s", xpath_buf, "/..");
+
+ candidate = nb_running_get_entry_non_rec(NULL, xpath, false);
+
+ /* then check if it exists and if the name was provided */
+ if (candidate && strlen(candidate->name) > 0) {
+ flog_warn(EC_LIB_NB_CB_CONFIG_VALIDATE,
+ "The candidate name is fixed!");
+ return NB_ERR_RESOURCE;
+ } else
+ return NB_OK;
+ }
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+
+ name = yang_dnode_get_string(args->dnode, NULL);
+ strlcpy(candidate->name, name, sizeof(candidate->name));
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ return NB_OK;
+}
+
+
+static int affinity_filter_modify(struct nb_cb_modify_args *args,
+ enum affinity_filter_type type)
+{
+ uint32_t filter;
+ struct srte_candidate *candidate;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ assert(args->context != NULL);
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ filter = yang_dnode_get_uint32(args->dnode, NULL);
+ srte_candidate_set_affinity_filter(candidate, type, filter);
+
+ return NB_OK;
+}
+
+static int affinity_filter_destroy(struct nb_cb_destroy_args *args,
+ enum affinity_filter_type type)
+{
+ struct srte_candidate *candidate;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ assert(args->context != NULL);
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ srte_candidate_unset_affinity_filter(candidate, type);
+
+ return NB_OK;
+}
+
+/*
+ * XPath:
+ * /frr-pathd:pathd/srte/policy/candidate-path/constraints/affinity/exclude-any
+ */
+
+int pathd_srte_policy_candidate_path_exclude_any_modify(
+ struct nb_cb_modify_args *args)
+{
+ return affinity_filter_modify(args, AFFINITY_FILTER_EXCLUDE_ANY);
+}
+
+int pathd_srte_policy_candidate_path_exclude_any_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ return affinity_filter_destroy(args, AFFINITY_FILTER_EXCLUDE_ANY);
+}
+
+
+/*
+ * XPath:
+ * /frr-pathd:pathd/srte/policy/candidate-path/constraints/affinity/include-any
+ */
+int pathd_srte_policy_candidate_path_include_any_modify(
+ struct nb_cb_modify_args *args)
+{
+ return affinity_filter_modify(args, AFFINITY_FILTER_INCLUDE_ANY);
+}
+
+int pathd_srte_policy_candidate_path_include_any_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ return affinity_filter_destroy(args, AFFINITY_FILTER_INCLUDE_ANY);
+}
+
+
+/*
+ * XPath:
+ * /frr-pathd:pathd/srte/policy/candidate-path/constraints/affinity/include-all
+ */
+int pathd_srte_policy_candidate_path_include_all_modify(
+ struct nb_cb_modify_args *args)
+{
+ return affinity_filter_modify(args, AFFINITY_FILTER_INCLUDE_ALL);
+}
+
+int pathd_srte_policy_candidate_path_include_all_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ return affinity_filter_destroy(args, AFFINITY_FILTER_INCLUDE_ALL);
+}
+
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/constraints/metrics
+ */
+int pathd_srte_policy_candidate_path_metrics_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ struct srte_candidate *candidate;
+ enum srte_candidate_metric_type type;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ assert(args->context != NULL);
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+
+ type = yang_dnode_get_enum(args->dnode, "./type");
+ srte_candidate_unset_metric(candidate, type);
+
+ return NB_OK;
+}
+
+void pathd_srte_policy_candidate_path_metrics_apply_finish(
+ struct nb_cb_apply_finish_args *args)
+{
+ struct srte_candidate *candidate;
+ enum srte_candidate_metric_type type;
+ float value;
+ bool required, is_bound = false, is_computed = false;
+
+ assert(args->context != NULL);
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+
+ type = yang_dnode_get_enum(args->dnode, "./type");
+ value = (float)yang_dnode_get_dec64(args->dnode, "./value");
+ required = yang_dnode_get_bool(args->dnode, "./required");
+ if (yang_dnode_exists(args->dnode, "./is-bound"))
+ is_bound = yang_dnode_get_bool(args->dnode, "./is-bound");
+ if (yang_dnode_exists(args->dnode, "./is-computed"))
+ is_computed = yang_dnode_get_bool(args->dnode, "./is-computed");
+
+ srte_candidate_set_metric(candidate, type, value, required, is_bound,
+ is_computed);
+}
+
+/*
+ * XPath:
+ * /frr-pathd:pathd/srte/policy/candidate-path/constraints/objective-function
+ */
+int pathd_srte_policy_candidate_path_objfun_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ struct srte_candidate *candidate;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ assert(args->context != NULL);
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ srte_candidate_unset_objfun(candidate);
+
+ return NB_OK;
+}
+
+void pathd_srte_policy_candidate_path_objfun_apply_finish(
+ struct nb_cb_apply_finish_args *args)
+{
+ struct srte_candidate *candidate;
+ enum objfun_type type;
+ bool required;
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ required = yang_dnode_get_bool(args->dnode, "./required");
+ type = yang_dnode_get_enum(args->dnode, "./type");
+ srte_candidate_set_objfun(candidate, required, type);
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/protocol-origin
+ */
+int pathd_srte_policy_candidate_path_protocol_origin_modify(
+ struct nb_cb_modify_args *args)
+{
+ struct srte_candidate *candidate;
+ enum srte_protocol_origin protocol_origin;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ protocol_origin = yang_dnode_get_enum(args->dnode, NULL);
+ candidate->protocol_origin = protocol_origin;
+ candidate->lsp->protocol_origin = protocol_origin;
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/originator
+ */
+int pathd_srte_policy_candidate_path_originator_modify(
+ struct nb_cb_modify_args *args)
+{
+ struct srte_candidate *candidate;
+ const char *originator;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ originator = yang_dnode_get_string(args->dnode, NULL);
+ strlcpy(candidate->originator, originator,
+ sizeof(candidate->originator));
+ strlcpy(candidate->lsp->originator, originator,
+ sizeof(candidate->lsp->originator));
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/type
+ */
+int pathd_srte_policy_candidate_path_type_modify(struct nb_cb_modify_args *args)
+{
+ struct srte_candidate *candidate;
+ enum srte_candidate_type type;
+ char xpath[XPATH_MAXLEN];
+ char xpath_buf[XPATH_MAXLEN - 3];
+
+ if (args->event != NB_EV_APPLY && args->event != NB_EV_VALIDATE)
+ return NB_OK;
+
+ /* the candidate type is fixed after setting it once, this is checked
+ * here */
+ if (args->event == NB_EV_VALIDATE) {
+ /* first get the precise path to the candidate path */
+ yang_dnode_get_path(args->dnode, xpath_buf, sizeof(xpath_buf));
+ snprintf(xpath, sizeof(xpath), "%s%s", xpath_buf, "/..");
+
+ candidate = nb_running_get_entry_non_rec(NULL, xpath, false);
+
+ /* then check if it exists and if the type was provided */
+ if (candidate
+ && candidate->type != SRTE_CANDIDATE_TYPE_UNDEFINED) {
+ flog_warn(EC_LIB_NB_CB_CONFIG_VALIDATE,
+ "The candidate type is fixed!");
+ return NB_ERR_RESOURCE;
+ } else
+ return NB_OK;
+ }
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+
+ type = yang_dnode_get_enum(args->dnode, NULL);
+ candidate->type = type;
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/segment-list-name
+ */
+int pathd_srte_policy_candidate_path_segment_list_name_modify(
+ struct nb_cb_modify_args *args)
+{
+ struct srte_candidate *candidate;
+ const char *segment_list_name;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ segment_list_name = yang_dnode_get_string(args->dnode, NULL);
+
+ candidate->segment_list = srte_segment_list_find(segment_list_name);
+ candidate->lsp->segment_list = candidate->segment_list;
+ assert(candidate->segment_list);
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ return NB_OK;
+}
+
+int pathd_srte_policy_candidate_path_segment_list_name_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ struct srte_candidate *candidate;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ candidate->segment_list = NULL;
+ candidate->lsp->segment_list = NULL;
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ return NB_OK;
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/constraints/bandwidth
+ */
+void pathd_srte_policy_candidate_path_bandwidth_apply_finish(
+ struct nb_cb_apply_finish_args *args)
+{
+ struct srte_candidate *candidate;
+ float value;
+ bool required;
+
+ assert(args->context != NULL);
+
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ value = (float)yang_dnode_get_dec64(args->dnode, "./value");
+ required = yang_dnode_get_bool(args->dnode, "./required");
+ srte_candidate_set_bandwidth(candidate, value, required);
+}
+
+int pathd_srte_policy_candidate_path_bandwidth_destroy(
+ struct nb_cb_destroy_args *args)
+{
+ struct srte_candidate *candidate;
+
+ if (args->event != NB_EV_APPLY)
+ return NB_OK;
+
+ assert(args->context != NULL);
+ candidate = nb_running_get_entry(args->dnode, NULL, true);
+ srte_candidate_unset_bandwidth(candidate);
+ return NB_OK;
+}
diff --git a/pathd/path_nb_state.c b/pathd/path_nb_state.c
new file mode 100644
index 0000000..60f04f4
--- /dev/null
+++ b/pathd/path_nb_state.c
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "log.h"
+#include "prefix.h"
+#include "table.h"
+#include "command.h"
+#include "northbound.h"
+#include "libfrr.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_nb.h"
+
+/*
+ * XPath: /frr-pathd:pathd/srte/segment-list
+ */
+const void *pathd_srte_segment_list_get_next(struct nb_cb_get_next_args *args)
+{
+ struct srte_segment_list *segment_list =
+ (struct srte_segment_list *)args->list_entry;
+
+ if (args->list_entry == NULL)
+ segment_list =
+ RB_MIN(srte_segment_list_head, &srte_segment_lists);
+ else
+ segment_list = RB_NEXT(srte_segment_list_head, segment_list);
+
+ return segment_list;
+}
+
+int pathd_srte_segment_list_get_keys(struct nb_cb_get_keys_args *args)
+{
+ const struct srte_segment_list *segment_list =
+ (struct srte_segment_list *)args->list_entry;
+
+ args->keys->num = 1;
+ snprintf(args->keys->key[0], sizeof(args->keys->key[0]), "%s",
+ segment_list->name);
+
+ return NB_OK;
+}
+
+const void *
+pathd_srte_segment_list_lookup_entry(struct nb_cb_lookup_entry_args *args)
+{
+ return srte_segment_list_find(args->keys->key[0]);
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy
+ */
+const void *pathd_srte_policy_get_next(struct nb_cb_get_next_args *args)
+{
+ struct srte_policy *policy = (struct srte_policy *)args->list_entry;
+
+ if (args->list_entry == NULL)
+ policy = RB_MIN(srte_policy_head, &srte_policies);
+ else
+ policy = RB_NEXT(srte_policy_head, policy);
+
+ return policy;
+}
+
+int pathd_srte_policy_get_keys(struct nb_cb_get_keys_args *args)
+{
+ const struct srte_policy *policy =
+ (struct srte_policy *)args->list_entry;
+
+ args->keys->num = 2;
+ snprintf(args->keys->key[0], sizeof(args->keys->key[0]), "%u",
+ policy->color);
+ ipaddr2str(&policy->endpoint, args->keys->key[1],
+ sizeof(args->keys->key[1]));
+
+ return NB_OK;
+}
+
+const void *pathd_srte_policy_lookup_entry(struct nb_cb_lookup_entry_args *args)
+{
+ uint32_t color;
+ struct ipaddr endpoint;
+
+ color = yang_str2uint32(args->keys->key[0]);
+ yang_str2ip(args->keys->key[1], &endpoint);
+
+ return srte_policy_find(color, &endpoint);
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/is-operational
+ */
+struct yang_data *
+pathd_srte_policy_is_operational_get_elem(struct nb_cb_get_elem_args *args)
+{
+ struct srte_policy *policy = (struct srte_policy *)args->list_entry;
+ bool is_operational = false;
+
+ if (policy->status == SRTE_POLICY_STATUS_UP)
+ is_operational = true;
+
+ return yang_data_new_bool(args->xpath, is_operational);
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path
+ */
+const void *
+pathd_srte_policy_candidate_path_get_next(struct nb_cb_get_next_args *args)
+{
+ struct srte_policy *policy =
+ (struct srte_policy *)args->parent_list_entry;
+ struct srte_candidate *candidate =
+ (struct srte_candidate *)args->list_entry;
+
+ if (args->list_entry == NULL)
+ candidate =
+ RB_MIN(srte_candidate_head, &policy->candidate_paths);
+ else
+ candidate = RB_NEXT(srte_candidate_head, candidate);
+
+ return candidate;
+}
+
+int pathd_srte_policy_candidate_path_get_keys(struct nb_cb_get_keys_args *args)
+{
+ const struct srte_candidate *candidate =
+ (struct srte_candidate *)args->list_entry;
+
+ args->keys->num = 1;
+ snprintf(args->keys->key[0], sizeof(args->keys->key[0]), "%u",
+ candidate->preference);
+
+ return NB_OK;
+}
+
+const void *pathd_srte_policy_candidate_path_lookup_entry(
+ struct nb_cb_lookup_entry_args *args)
+{
+ struct srte_policy *policy =
+ (struct srte_policy *)args->parent_list_entry;
+ uint32_t preference;
+
+ preference = yang_str2uint32(args->keys->key[0]);
+
+ return srte_candidate_find(policy, preference);
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate_path/is-best-candidate-path
+ */
+struct yang_data *
+pathd_srte_policy_candidate_path_is_best_candidate_path_get_elem(
+ struct nb_cb_get_elem_args *args)
+{
+ struct srte_candidate *candidate =
+ (struct srte_candidate *)args->list_entry;
+
+ return yang_data_new_bool(
+ args->xpath, CHECK_FLAG(candidate->flags, F_CANDIDATE_BEST));
+}
+
+/*
+ * XPath: /frr-pathd:pathd/srte/policy/candidate-path/discriminator
+ */
+struct yang_data *pathd_srte_policy_candidate_path_discriminator_get_elem(
+ struct nb_cb_get_elem_args *args)
+{
+ struct srte_candidate *candidate =
+ (struct srte_candidate *)args->list_entry;
+
+ return yang_data_new_uint32(args->xpath, candidate->discriminator);
+}
diff --git a/pathd/path_pcep.c b/pathd/path_pcep.c
new file mode 100644
index 0000000..ce631eb
--- /dev/null
+++ b/pathd/path_pcep.c
@@ -0,0 +1,387 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include "pceplib/pcep_utils_counters.h"
+
+#include "memory.h"
+#include "log.h"
+#include "command.h"
+#include "libfrr.h"
+#include "printfrr.h"
+#include "lib/version.h"
+#include "northbound.h"
+#include "frr_pthread.h"
+#include "jhash.h"
+#include "termtable.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_errors.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_cli.h"
+#include "pathd/path_pcep_controller.h"
+#include "pathd/path_pcep_lib.h"
+#include "pathd/path_pcep_config.h"
+#include "pathd/path_pcep_debug.h"
+
+DEFINE_MTYPE(PATHD, PCEP, "PCEP module");
+
+/*
+ * Globals.
+ */
+static struct pcep_glob pcep_glob_space = {.dbg = {0, "pathd module: pcep"}};
+struct pcep_glob *pcep_g = &pcep_glob_space;
+
+/* Main Thread Even Handler */
+static int pcep_main_event_handler(enum pcep_main_event_type type, int pcc_id,
+ void *payload);
+static int pcep_main_event_start_sync(int pcc_id);
+static int pcep_main_event_start_sync_cb(struct path *path, void *arg);
+static int pcep_main_event_initiate_candidate(struct path *path);
+static int pcep_main_event_update_candidate(struct path *path);
+static int pcep_main_event_remove_candidate_segments(const char *originator,
+ bool force);
+
+/* Hook Handlers called from the Main Thread */
+static int pathd_candidate_created_handler(struct srte_candidate *candidate);
+static int pathd_candidate_updated_handler(struct srte_candidate *candidate);
+static int pathd_candidate_removed_handler(struct srte_candidate *candidate);
+
+/* Path manipulation functions */
+static struct path_metric *pcep_copy_metrics(struct path_metric *metric);
+static struct path_hop *pcep_copy_hops(struct path_hop *hop);
+
+/* Other static functions */
+static void notify_status(struct path *path, bool not_changed);
+
+/* Module Functions */
+static int pcep_module_finish(void);
+static int pcep_module_late_init(struct thread_master *tm);
+static int pcep_module_init(void);
+
+/* ------------ Path Helper Functions ------------ */
+
+struct path *pcep_new_path(void)
+{
+ struct path *path;
+ path = XCALLOC(MTYPE_PCEP, sizeof(*path));
+ path->binding_sid = MPLS_LABEL_NONE;
+ path->enforce_bandwidth = true;
+ return path;
+}
+
+struct path_hop *pcep_new_hop(void)
+{
+ struct path_hop *hop;
+ hop = XCALLOC(MTYPE_PCEP, sizeof(*hop));
+ return hop;
+}
+
+struct path_metric *pcep_new_metric(void)
+{
+ struct path_metric *metric;
+ metric = XCALLOC(MTYPE_PCEP, sizeof(*metric));
+ return metric;
+}
+
+struct path_metric *pcep_copy_metrics(struct path_metric *metric)
+{
+ if (metric == NULL)
+ return NULL;
+ struct path_metric *new_metric = pcep_new_metric();
+ *new_metric = *metric;
+ new_metric->next = pcep_copy_metrics(metric->next);
+ return new_metric;
+}
+
+struct path_hop *pcep_copy_hops(struct path_hop *hop)
+{
+ if (hop == NULL)
+ return NULL;
+ struct path_hop *new_hop = pcep_new_hop();
+ *new_hop = *hop;
+ new_hop->next = pcep_copy_hops(hop->next);
+ return new_hop;
+}
+
+struct path *pcep_copy_path(struct path *path)
+{
+ struct path *new_path = pcep_new_path();
+
+ *new_path = *path;
+ new_path->first_metric = pcep_copy_metrics(path->first_metric);
+ new_path->first_hop = pcep_copy_hops(path->first_hop);
+ if (path->name != NULL)
+ new_path->name = XSTRDUP(MTYPE_PCEP, path->name);
+ if (path->originator != NULL)
+ new_path->originator = XSTRDUP(MTYPE_PCEP, path->originator);
+ return new_path;
+}
+
+void pcep_free_path(struct path *path)
+{
+ struct path_hop *hop;
+ struct path_metric *metric;
+ char *tmp;
+
+ metric = path->first_metric;
+ while (metric != NULL) {
+ struct path_metric *next = metric->next;
+ XFREE(MTYPE_PCEP, metric);
+ metric = next;
+ }
+ hop = path->first_hop;
+ while (hop != NULL) {
+ struct path_hop *next = hop->next;
+ XFREE(MTYPE_PCEP, hop);
+ hop = next;
+ }
+ if (path->originator != NULL) {
+ /* The path own the memory, it is const so it is clear it
+ shouldn't be modified. XFREE macro do not support type casting
+ so we need a temporary variable */
+ tmp = (char *)path->originator;
+ XFREE(MTYPE_PCEP, tmp);
+ path->originator = NULL;
+ }
+ if (path->name != NULL) {
+ /* The path own the memory, it is const so it is clear it
+ shouldn't be modified. XFREE macro do not support type casting
+ so we need a temporary variable */
+ tmp = (char *)path->name;
+ XFREE(MTYPE_PCEP, tmp);
+ path->name = NULL;
+ }
+ XFREE(MTYPE_PCEP, path);
+}
+
+/* ------------ Other Static Functions ------------ */
+
+void notify_status(struct path *path, bool not_changed)
+{
+ struct path *resp = NULL;
+
+ if ((resp = path_pcep_config_get_path(&path->nbkey))) {
+ resp->srp_id = path->srp_id;
+ flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ "(%s) Send report for candidate path %s", __func__,
+ path->name);
+ pcep_ctrl_send_report(pcep_g->fpt, path->pcc_id, resp,
+ not_changed);
+ }
+}
+
+/* ------------ Main Thread Even Handler ------------ */
+
+int pcep_main_event_handler(enum pcep_main_event_type type, int pcc_id,
+ void *payload)
+{
+ int ret = 0;
+
+ switch (type) {
+ case PCEP_MAIN_EVENT_START_SYNC:
+ ret = pcep_main_event_start_sync(pcc_id);
+ break;
+ case PCEP_MAIN_EVENT_INITIATE_CANDIDATE:
+ assert(payload != NULL);
+ ret = pcep_main_event_initiate_candidate(
+ (struct path *)payload);
+ break;
+ case PCEP_MAIN_EVENT_UPDATE_CANDIDATE:
+ assert(payload != NULL);
+ ret = pcep_main_event_update_candidate((struct path *)payload);
+ break;
+ case PCEP_MAIN_EVENT_REMOVE_CANDIDATE_LSP:
+ ret = pcep_main_event_remove_candidate_segments(
+ (const char *)payload, true);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ "Unexpected event received in the main thread: %u",
+ type);
+ break;
+ }
+
+ return ret;
+}
+
+int pcep_main_event_start_sync(int pcc_id)
+{
+ path_pcep_config_list_path(pcep_main_event_start_sync_cb, &pcc_id);
+ pcep_ctrl_sync_done(pcep_g->fpt, pcc_id);
+ return 0;
+}
+
+int pcep_main_event_start_sync_cb(struct path *path, void *arg)
+{
+ int *pcc_id = (int *)arg;
+ pcep_ctrl_sync_path(pcep_g->fpt, *pcc_id, path);
+ return 1;
+}
+
+int pcep_main_event_initiate_candidate(struct path *path)
+{
+ int ret = 0;
+
+ ret = path_pcep_config_initiate_path(path);
+ if (path->do_remove) {
+ struct pcep_error *error;
+ error = XCALLOC(MTYPE_PCEP, sizeof(*error));
+ error->path = path;
+ error->error_type = PCEP_ERRT_INVALID_OPERATION;
+ switch (ret) {
+ case ERROR_19_1:
+ error->error_value =
+ PCEP_ERRV_LSP_UPDATE_FOR_NON_DELEGATED_LSP;
+ break;
+ case ERROR_19_3:
+ error->error_value =
+ PCEP_ERRV_LSP_UPDATE_UNKNOWN_PLSP_ID;
+ break;
+ case ERROR_19_9:
+ error->error_value = PCEP_ERRV_LSP_NOT_PCE_INITIATED;
+ break;
+ default:
+ zlog_warn("(%s)PCE tried to REMOVE unknown error!",
+ __func__);
+ XFREE(MTYPE_PCEP, error);
+ pcep_free_path(path);
+ return ret;
+ break;
+ }
+ pcep_ctrl_send_error(pcep_g->fpt, path->pcc_id, error);
+ } else if (ret != PATH_NB_ERR && path->srp_id != 0)
+ notify_status(path, ret == PATH_NB_NO_CHANGE);
+ return ret;
+}
+
+int pcep_main_event_update_candidate(struct path *path)
+{
+ int ret = 0;
+
+ ret = path_pcep_config_update_path(path);
+ if (ret != PATH_NB_ERR && path->srp_id != 0)
+ notify_status(path, ret == PATH_NB_NO_CHANGE);
+ return ret;
+}
+
+int pcep_main_event_remove_candidate_segments(const char *originator,
+ bool force)
+{
+ srte_candidate_unset_segment_list(originator, force);
+ /* Avoid compiler warnings about const char* */
+ void *free_ptr = (void *)originator;
+ XFREE(MTYPE_PCEP, free_ptr);
+
+ srte_apply_changes();
+
+ return 0;
+}
+
+/* ------------ Hook Handlers Functions Called From Main Thread ------------ */
+
+int pathd_candidate_created_handler(struct srte_candidate *candidate)
+{
+ struct path *path = candidate_to_path(candidate);
+ int ret = pcep_ctrl_pathd_event(pcep_g->fpt, PCEP_PATH_CREATED, path);
+ return ret;
+}
+
+int pathd_candidate_updated_handler(struct srte_candidate *candidate)
+{
+ struct path *path = candidate_to_path(candidate);
+ int ret = pcep_ctrl_pathd_event(pcep_g->fpt, PCEP_PATH_UPDATED, path);
+ return ret;
+}
+
+int pathd_candidate_removed_handler(struct srte_candidate *candidate)
+{
+ struct path *path = candidate_to_path(candidate);
+ int ret = pcep_ctrl_pathd_event(pcep_g->fpt, PCEP_PATH_REMOVED, path);
+ return ret;
+}
+
+
+/* ------------ Module Functions ------------ */
+
+/* this creates threads, therefore must run after fork(). but it must also
+ * run before config load, so the CLI commands don't try to touch things that
+ * aren't set up yet...
+ */
+static int pcep_module_config_pre(struct thread_master *tm)
+{
+ assert(pcep_g->fpt == NULL);
+ assert(pcep_g->master == NULL);
+
+ struct frr_pthread *fpt;
+
+ if (pcep_ctrl_initialize(tm, &fpt, pcep_main_event_handler))
+ return 1;
+
+ if (pcep_lib_initialize(fpt))
+ return 1;
+
+ pcep_g->master = tm;
+ pcep_g->fpt = fpt;
+
+ return 0;
+}
+
+static int pcep_module_late_init(struct thread_master *tm)
+{
+ hook_register(pathd_candidate_created, pathd_candidate_created_handler);
+ hook_register(pathd_candidate_updated, pathd_candidate_updated_handler);
+ hook_register(pathd_candidate_removed, pathd_candidate_removed_handler);
+
+ hook_register(frr_config_pre, pcep_module_config_pre);
+ hook_register(frr_fini, pcep_module_finish);
+
+ pcep_cli_init();
+
+ return 0;
+}
+
+int pcep_module_finish(void)
+{
+ pcep_ctrl_finalize(&pcep_g->fpt);
+ pcep_lib_finalize();
+
+ for (int i = 0; i < MAX_PCC; i++)
+ if (pcep_g->pce_opts_cli[i] != NULL)
+ XFREE(MTYPE_PCEP, pcep_g->pce_opts_cli[i]);
+
+ return 0;
+}
+
+int pcep_module_init(void)
+{
+ pcep_g->num_pce_opts_cli = 0;
+ for (int i = 0; i < MAX_PCE; i++)
+ pcep_g->pce_opts_cli[i] = NULL;
+ pcep_g->num_config_group_opts = 0;
+ for (int i = 0; i < MAX_PCE; i++)
+ pcep_g->config_group_opts[i] = NULL;
+
+ hook_register(frr_late_init, pcep_module_late_init);
+ return 0;
+}
+
+FRR_MODULE_SETUP(.name = "frr_pathd_pcep", .version = FRR_VERSION,
+ .description = "FRR pathd PCEP module",
+ .init = pcep_module_init,
+);
diff --git a/pathd/path_pcep.h b/pathd/path_pcep.h
new file mode 100644
index 0000000..597a4b6
--- /dev/null
+++ b/pathd/path_pcep.h
@@ -0,0 +1,338 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_H_
+#define _PATH_PCEP_H_
+
+#include <stdbool.h>
+#include <debug.h>
+#include <netinet/tcp.h>
+#include "memory.h"
+#include "pceplib/pcep_utils_logging.h"
+#include "pceplib/pcep_pcc_api.h"
+#include "mpls.h"
+#include "pathd/pathd.h"
+
+DECLARE_MTYPE(PCEP);
+
+#define PCEP_DEFAULT_PORT 4189
+#define MAX_PCC 32
+#define MAX_PCE 32
+#define MAX_TAG_SIZE 50
+#define PCEP_DEBUG_MODE_BASIC 0x01
+#define PCEP_DEBUG_MODE_PATH 0x02
+#define PCEP_DEBUG_MODE_PCEP 0x04
+#define PCEP_DEBUG_MODE_PCEPLIB 0x08
+#define PCEP_DEBUG(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_BASIC)) \
+ DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__); \
+ } while (0)
+#define PCEP_DEBUG_PATH(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PATH)) \
+ DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__); \
+ } while (0)
+#define PCEP_DEBUG_PCEP(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEP)) \
+ DEBUGD(&pcep_g->dbg, "pcep: " fmt, ##__VA_ARGS__); \
+ } while (0)
+#define PCEP_DEBUG_PCEPLIB(priority, fmt, ...) \
+ do { \
+ switch (priority) { \
+ case LOG_DEBUG: \
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, \
+ PCEP_DEBUG_MODE_PCEPLIB)) \
+ DEBUGD(&pcep_g->dbg, "pcep: " fmt, \
+ ##__VA_ARGS__); \
+ break; \
+ case LOG_INFO: \
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, \
+ PCEP_DEBUG_MODE_PCEPLIB)) \
+ DEBUGI(&pcep_g->dbg, "pcep: " fmt, \
+ ##__VA_ARGS__); \
+ break; \
+ case LOG_NOTICE: \
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, \
+ PCEP_DEBUG_MODE_PCEPLIB)) \
+ DEBUGN(&pcep_g->dbg, "pcep: " fmt, \
+ ##__VA_ARGS__); \
+ break; \
+ case LOG_WARNING: \
+ case LOG_ERR: \
+ default: \
+ zlog(priority, "pcep: " fmt, ##__VA_ARGS__); \
+ break; \
+ } \
+ } while (0)
+
+struct pcep_config_group_opts {
+ char name[64];
+ char tcp_md5_auth[PCEP_MD5SIG_MAXKEYLEN];
+ struct ipaddr source_ip;
+ short source_port;
+ bool draft07;
+ bool pce_initiated;
+ int keep_alive_seconds;
+ int min_keep_alive_seconds;
+ int max_keep_alive_seconds;
+ int dead_timer_seconds;
+ int min_dead_timer_seconds;
+ int max_dead_timer_seconds;
+ int pcep_request_time_seconds;
+ int session_timeout_inteval_seconds;
+ int delegation_timeout_seconds;
+};
+
+struct pce_opts {
+ struct ipaddr addr;
+ short port;
+ char pce_name[64];
+ struct pcep_config_group_opts config_opts;
+ uint8_t precedence; /* Multi-PCE precedence */
+};
+
+struct pcc_opts {
+ struct ipaddr addr;
+ short port;
+ short msd;
+};
+
+/* Encapsulate the pce_opts with needed CLI information */
+struct pce_opts_cli {
+ struct pce_opts pce_opts;
+ char config_group_name[64];
+ /* These are the values configured in the pcc-peer sub-commands.
+ * These need to be stored for later merging. Notice, it could
+ * be that not all of them are set. */
+ struct pcep_config_group_opts pce_config_group_opts;
+ /* The pce_opts->config_opts will be a merge of the default values,
+ * optional config_group values (which overwrite default values),
+ * and any values configured in the pce sub-commands (which overwrite
+ * both default and config_group values). This flag indicates of the
+ * values need to be merged or not. */
+ bool merged;
+};
+
+struct lsp_nb_key {
+ uint32_t color;
+ struct ipaddr endpoint;
+ uint32_t preference;
+};
+
+struct sid_mpls {
+ mpls_label_t label;
+ uint8_t traffic_class;
+ bool is_bottom;
+ uint8_t ttl;
+};
+
+struct pcep_caps {
+ bool is_stateful;
+ /* If we know the objective functions supported by the PCE.
+ * If we don't know, it doesn't mean the PCE doesn't support any */
+ bool supported_ofs_are_known;
+ /* Defined if we know which objective funtions are supported by the PCE.
+ * One bit per objective function, the bit index being equal to
+ * enum pcep_objfun_type values: bit 0 is not used, bit 1 is
+ * PCEP_OBJFUN_MCP, up to bit 17 that is PCEP_OBJFUN_MSN */
+ uint32_t supported_ofs;
+};
+
+union sid {
+ uint32_t value;
+ struct sid_mpls mpls;
+};
+
+struct nai {
+ /* NAI type */
+ enum pcep_sr_subobj_nai type;
+ /* Local IP address*/
+ struct ipaddr local_addr;
+ /* Local interface identifier if the NAI is an unnumbered adjacency */
+ uint32_t local_iface;
+ /* Remote address if the NAI is an adjacency */
+ struct ipaddr remote_addr;
+ /* Remote interface identifier if the NAI is an unnumbered adjacency */
+ uint32_t remote_iface;
+};
+
+struct path_hop {
+ /* Pointer to the next hop in the path */
+ struct path_hop *next;
+ /* Indicateif this ia a loose or strict hop */
+ bool is_loose;
+ /* Indicate if there is an SID for the hop */
+ bool has_sid;
+ /* Indicate if the hop as a MPLS label */
+ bool is_mpls;
+ /* Indicate if the MPLS label has extra attributes (TTL, class..)*/
+ bool has_attribs;
+ /* Hop's SID if available */
+ union sid sid;
+ /* Indicate if there is a NAI for this hop */
+ bool has_nai;
+ /* NAI if available */
+ struct nai nai;
+};
+
+struct path_metric {
+ /* Pointer to the next metric */
+ struct path_metric *next;
+ /* The metric type */
+ enum pcep_metric_types type;
+ /* If the metric should be enforced */
+ bool enforce;
+ /* If the metric value is bound (a maximum) */
+ bool is_bound;
+ /* If the metric value is computed */
+ bool is_computed;
+ /* The metric value */
+ float value;
+};
+
+struct path {
+ /* Both the nbkey and the plspid are keys comming from the PCC,
+ but the PCE is only using the plspid. The missing key is looked up by
+ the PCC so we always have both */
+
+ /* The northbound key identifying this path */
+ struct lsp_nb_key nbkey;
+ /* The generated unique PLSP identifier for this path.
+ See draft-ietf-pce-stateful-pce */
+ uint32_t plsp_id;
+
+ /* The transport address the path is comming from, PCE or PCC*/
+ struct ipaddr sender;
+ /* The pcc protocol address, must be the same family as the endpoint */
+ struct ipaddr pcc_addr;
+
+ /* The identifier of the PCC the path is for/from. If 0 it is undefined,
+ meaning it hasn't be set yet or is for all the PCC */
+ int pcc_id;
+
+ /* The origin of the path creation */
+ enum srte_protocol_origin create_origin;
+ /* The origin of the path modification */
+ enum srte_protocol_origin update_origin;
+ /* The identifier of the entity that originated the path */
+ const char *originator;
+ /* The type of the path, for PCE initiated or updated path it is always
+ SRTE_CANDIDATE_TYPE_DYNAMIC */
+ enum srte_candidate_type type;
+
+ /* The following data comes from either the PCC or the PCE if available
+ */
+
+ /* Path's binding SID */
+ mpls_label_t binding_sid;
+ /* The name of the path */
+ const char *name;
+ /* The request identifier from the PCE, when getting a path from the
+ PCE. See draft-ietf-pce-stateful-pce */
+ uint32_t srp_id;
+ /* The request identifier from the PCC , when getting a path from the
+ PCE after a computation request. See rfc5440, section-7.4 */
+ uint32_t req_id;
+ /* The operational status of the path */
+ enum pcep_lsp_operational_status status;
+ /* If true, the receiver (PCC) must remove the path.
+ See draft-ietf-pce-pce-initiated-lsp */
+ bool do_remove;
+ /* Indicate the given path was removed by the PCC.
+ See draft-ietf-pce-stateful-pce, section-7.3, flag R */
+ bool was_removed;
+ /* Indicate the path is part of the synchronization process.
+ See draft-ietf-pce-stateful-pce, section-7.3, flag S */
+ bool is_synching;
+ /* Indicate if the path bandwidth requirment is defined */
+ bool has_bandwidth;
+ /* Indicate if the bandwidth requirment should be enforced */
+ bool enforce_bandwidth;
+ /* Path required bandwidth if defined */
+ float bandwidth;
+ /* Specify the list of hop defining the path */
+ struct path_hop *first_hop;
+ /* Specify the list of metrics */
+ struct path_metric *first_metric;
+ /* Indicate if the path has a PCC-defined objective function */
+ bool has_pcc_objfun;
+ /* Indicate the PCC-defined objective function is required */
+ bool enforce_pcc_objfun;
+ /* PCC-defined Objective Function */
+ enum objfun_type pcc_objfun;
+ /* Indicate if the path has a PCE-defined objective function */
+ bool has_pce_objfun;
+ /* PCE-defined Objective Function */
+ enum objfun_type pce_objfun;
+ /* Indicate if some affinity filters are defined */
+ bool has_affinity_filters;
+ /* Affinity attribute filters indexed by enum affinity_filter_type - 1
+ */
+ uint32_t affinity_filters[MAX_AFFINITY_FILTER_TYPE];
+
+ /* The following data need to be specialized for a given PCE */
+
+ /* Indicate the path is delegated to the PCE.
+ See draft-ietf-pce-stateful-pce, section-7.3, flag D */
+ bool is_delegated;
+ /* Indicate if the PCE wants the path to get active.
+ See draft-ietf-pce-stateful-pce, section-7.3, flag A */
+ bool go_active;
+ /* Indicate the given path was created by the PCE,
+ See draft-ietf-pce-pce-initiated-lsp, section-5.3.1, flag C */
+ bool was_created;
+
+ /* The following data is defined for comnputation replies */
+
+ /* Indicate that no path could be computed */
+ bool no_path;
+};
+
+struct pcep_glob {
+ struct debug dbg;
+ struct thread_master *master;
+ struct frr_pthread *fpt;
+ uint8_t num_pce_opts_cli;
+ struct pce_opts_cli *pce_opts_cli[MAX_PCE];
+ uint8_t num_config_group_opts;
+ struct pcep_config_group_opts *config_group_opts[MAX_PCE];
+};
+
+extern struct pcep_glob *pcep_g;
+
+struct pcep_error {
+ struct path *path;
+ int error_type;
+ int error_value;
+ /* Rfc 8281 PcInitiated error on bad values */
+#define ERROR_19_1 1
+#define ERROR_19_3 2
+#define ERROR_19_9 3
+};
+
+/* Path Helper Functions */
+struct path *pcep_new_path(void);
+struct path_hop *pcep_new_hop(void);
+struct path_metric *pcep_new_metric(void);
+struct path *pcep_copy_path(struct path *path);
+void pcep_free_path(struct path *path);
+
+
+#endif // _PATH_PCEP_H_
diff --git a/pathd/path_pcep_cli.c b/pathd/path_pcep_cli.c
new file mode 100644
index 0000000..d2b49a7
--- /dev/null
+++ b/pathd/path_pcep_cli.c
@@ -0,0 +1,2064 @@
+/*
+ * Copyright (C) 2020 Volta Networks, Inc
+ * Brady Johnson
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include "pceplib/pcep_utils_counters.h"
+#include "pceplib/pcep_session_logic.h"
+
+#include "log.h"
+#include "command.h"
+#include "libfrr.h"
+#include "printfrr.h"
+#include "lib/version.h"
+#include "northbound.h"
+#include "frr_pthread.h"
+#include "jhash.h"
+#include "termtable.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_errors.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_cli.h"
+#include "pathd/path_pcep_controller.h"
+#include "pathd/path_pcep_debug.h"
+#include "pathd/path_pcep_lib.h"
+#include "pathd/path_pcep_pcc.h"
+
+#ifndef VTYSH_EXTRACT_PL
+#include "pathd/path_pcep_cli_clippy.c"
+#endif
+
+#define DEFAULT_PCE_PRECEDENCE 255
+#define DEFAULT_PCC_MSD 4
+#define DEFAULT_SR_DRAFT07 false
+#define DEFAULT_PCE_INITIATED false
+#define DEFAULT_TIMER_KEEP_ALIVE 30
+#define DEFAULT_TIMER_KEEP_ALIVE_MIN 1
+#define DEFAULT_TIMER_KEEP_ALIVE_MAX 255
+#define DEFAULT_TIMER_DEADTIMER 120
+#define DEFAULT_TIMER_DEADTIMER_MIN 4
+#define DEFAULT_TIMER_DEADTIMER_MAX 255
+#define DEFAULT_TIMER_PCEP_REQUEST 30
+#define DEFAULT_TIMER_SESSION_TIMEOUT_INTERVAL 30
+#define DEFAULT_DELEGATION_TIMEOUT_INTERVAL 10
+
+/* CLI Function declarations */
+static int pcep_cli_debug_config_write(struct vty *vty);
+static int pcep_cli_debug_set_all(uint32_t flags, bool set);
+static int pcep_cli_pcep_config_write(struct vty *vty);
+static int pcep_cli_pcc_config_write(struct vty *vty);
+static int pcep_cli_pce_config_write(struct vty *vty);
+static int pcep_cli_pcep_pce_config_write(struct vty *vty);
+
+/* Internal Util Function declarations */
+static struct pce_opts_cli *pcep_cli_find_pce(const char *pce_name);
+static bool pcep_cli_add_pce(struct pce_opts_cli *pce_opts_cli);
+static struct pce_opts_cli *pcep_cli_create_pce_opts(const char *name);
+static void pcep_cli_delete_pce(const char *pce_name);
+static void
+pcep_cli_merge_pcep_pce_config_options(struct pce_opts_cli *pce_opts_cli);
+static struct pcep_config_group_opts *
+pcep_cli_find_pcep_pce_config(const char *group_name);
+static bool
+pcep_cli_add_pcep_pce_config(struct pcep_config_group_opts *config_group_opts);
+static struct pcep_config_group_opts *
+pcep_cli_create_pcep_pce_config(const char *group_name);
+static bool pcep_cli_is_pcep_pce_config_used(const char *group_name);
+static void pcep_cli_delete_pcep_pce_config(const char *group_name);
+static int pcep_cli_print_pce_config(struct pcep_config_group_opts *group_opts,
+ char *buf, size_t buf_len);
+static void print_pcep_capabilities(char *buf, size_t buf_len,
+ pcep_configuration *config);
+static void print_pcep_session(struct vty *vty, struct pce_opts *pce_opts,
+ struct pcep_pcc_info *pcc_info);
+static bool pcep_cli_pcc_has_pce(const char *pce_name);
+static void pcep_cli_add_pce_connection(struct pce_opts *pce_opts);
+static void pcep_cli_remove_pce_connection(struct pce_opts *pce_opts);
+static int path_pcep_cli_pcc_pcc_peer_delete(struct vty *vty,
+ const char *peer_name,
+ const char *precedence_str,
+ long precedence);
+
+/*
+ * Globals.
+ */
+
+static const char PCEP_VTYSH_ARG_ADDRESS[] = "address";
+static const char PCEP_VTYSH_ARG_SOURCE_ADDRESS[] = "source-address";
+static const char PCEP_VTYSH_ARG_IP[] = "ip";
+static const char PCEP_VTYSH_ARG_IPV6[] = "ipv6";
+static const char PCEP_VTYSH_ARG_PORT[] = "port";
+static const char PCEP_VTYSH_ARG_PRECEDENCE[] = "precedence";
+static const char PCEP_VTYSH_ARG_MSD[] = "msd";
+static const char PCEP_VTYSH_ARG_KEEP_ALIVE[] = "keep-alive";
+static const char PCEP_VTYSH_ARG_TIMER[] = "timer";
+static const char PCEP_VTYSH_ARG_KEEP_ALIVE_MIN[] = "min-peer-keep-alive";
+static const char PCEP_VTYSH_ARG_KEEP_ALIVE_MAX[] = "max-peer-keep-alive";
+static const char PCEP_VTYSH_ARG_DEAD_TIMER[] = "dead-timer";
+static const char PCEP_VTYSH_ARG_DEAD_TIMER_MIN[] = "min-peer-dead-timer";
+static const char PCEP_VTYSH_ARG_DEAD_TIMER_MAX[] = "max-peer-dead-timer";
+static const char PCEP_VTYSH_ARG_PCEP_REQUEST[] = "pcep-request";
+static const char PCEP_VTYSH_ARG_SESSION_TIMEOUT[] = "session-timeout-interval";
+static const char PCEP_VTYSH_ARG_DELEGATION_TIMEOUT[] = "delegation-timeout";
+static const char PCEP_VTYSH_ARG_SR_DRAFT07[] = "sr-draft07";
+static const char PCEP_VTYSH_ARG_PCE_INIT[] = "pce-initiated";
+static const char PCEP_VTYSH_ARG_TCP_MD5[] = "tcp-md5-auth";
+static const char PCEP_VTYSH_ARG_BASIC[] = "basic";
+static const char PCEP_VTYSH_ARG_PATH[] = "path";
+static const char PCEP_VTYSH_ARG_MESSAGE[] = "message";
+static const char PCEP_VTYSH_ARG_PCEPLIB[] = "pceplib";
+static const char PCEP_CLI_CAP_STATEFUL[] = " [Stateful PCE]";
+static const char PCEP_CLI_CAP_INCL_DB_VER[] = " [Include DB version]";
+static const char PCEP_CLI_CAP_LSP_TRIGGERED[] = " [LSP Triggered Resync]";
+static const char PCEP_CLI_CAP_LSP_DELTA[] = " [LSP Delta Sync]";
+static const char PCEP_CLI_CAP_PCE_TRIGGERED[] =
+ " [PCE triggered Initial Sync]";
+static const char PCEP_CLI_CAP_SR_TE_PST[] = " [SR TE PST]";
+static const char PCEP_CLI_CAP_PCC_RESOLVE_NAI[] =
+ " [PCC can resolve NAI to SID]";
+static const char PCEP_CLI_CAP_PCC_INITIATED[] = " [PCC Initiated LSPs]";
+static const char PCEP_CLI_CAP_PCC_PCE_INITIATED[] =
+ " [PCC and PCE Initiated LSPs]";
+
+struct pce_connections {
+ int num_connections;
+ struct pce_opts *connections[MAX_PCC];
+};
+
+struct pce_connections pce_connections_g = {.num_connections = 0};
+
+/* Default PCE group that all PCE-Groups and PCEs will inherit from */
+struct pcep_config_group_opts default_pcep_config_group_opts_g = {
+ .name = "default",
+ .tcp_md5_auth = "\0",
+ .draft07 = DEFAULT_SR_DRAFT07,
+ .pce_initiated = DEFAULT_PCE_INITIATED,
+ .keep_alive_seconds = DEFAULT_TIMER_KEEP_ALIVE,
+ .min_keep_alive_seconds = DEFAULT_TIMER_KEEP_ALIVE_MIN,
+ .max_keep_alive_seconds = DEFAULT_TIMER_KEEP_ALIVE_MAX,
+ .dead_timer_seconds = DEFAULT_TIMER_DEADTIMER,
+ .min_dead_timer_seconds = DEFAULT_TIMER_DEADTIMER_MIN,
+ .max_dead_timer_seconds = DEFAULT_TIMER_DEADTIMER_MAX,
+ .pcep_request_time_seconds = DEFAULT_TIMER_PCEP_REQUEST,
+ .session_timeout_inteval_seconds =
+ DEFAULT_TIMER_SESSION_TIMEOUT_INTERVAL,
+ .delegation_timeout_seconds = DEFAULT_DELEGATION_TIMEOUT_INTERVAL,
+ .source_port = DEFAULT_PCEP_TCP_PORT,
+ .source_ip.ipa_type = IPADDR_NONE,
+};
+
+/* Used by PCEP_PCE_CONFIG_NODE sub-commands to operate on the current pce group
+ */
+struct pcep_config_group_opts *current_pcep_config_group_opts_g = NULL;
+/* Used by PCEP_PCE_NODE sub-commands to operate on the current pce opts */
+struct pce_opts_cli *current_pce_opts_g = NULL;
+short pcc_msd_g = DEFAULT_PCC_MSD;
+bool pcc_msd_configured_g = false;
+
+static struct cmd_node pcep_node = {
+ .name = "srte pcep",
+ .node = PCEP_NODE,
+ .parent_node = SR_TRAFFIC_ENG_NODE,
+ .prompt = "%s(config-sr-te-pcep)# "
+};
+
+static struct cmd_node pcep_pcc_node = {
+ .name = "srte pcep pcc",
+ .node = PCEP_PCC_NODE,
+ .parent_node = PCEP_NODE,
+ .prompt = "%s(config-sr-te-pcep-pcc)# "
+};
+
+static struct cmd_node pcep_pce_node = {
+ .name = "srte pcep pce",
+ .node = PCEP_PCE_NODE,
+ .parent_node = PCEP_NODE,
+ .prompt = "%s(config-sr-te-pcep-pce)# "
+};
+
+static struct cmd_node pcep_pce_config_node = {
+ .name = "srte pcep pce-config",
+ .node = PCEP_PCE_CONFIG_NODE,
+ .parent_node = PCEP_NODE,
+ .prompt = "%s(pce-sr-te-pcep-pce-config)# "
+};
+
+/* Common code used in VTYSH processing for int values */
+#define PCEP_VTYSH_INT_ARG_CHECK(arg_str, arg_val, arg_store, min_value, \
+ max_value) \
+ if (arg_str != NULL) { \
+ if (arg_val <= min_value || arg_val >= max_value) { \
+ vty_out(vty, \
+ "%% Invalid value %ld in range [%d - %d]", \
+ arg_val, min_value, max_value); \
+ return CMD_WARNING; \
+ } \
+ arg_store = arg_val; \
+ }
+
+#define MERGE_COMPARE_CONFIG_GROUP_VALUE(config_param, not_set_value) \
+ pce_opts_cli->pce_opts.config_opts.config_param = \
+ pce_opts_cli->pce_config_group_opts.config_param; \
+ if (pce_opts_cli->pce_config_group_opts.config_param \
+ == not_set_value) { \
+ pce_opts_cli->pce_opts.config_opts.config_param = \
+ ((pce_config != NULL \
+ && pce_config->config_param != not_set_value) \
+ ? pce_config->config_param \
+ : default_pcep_config_group_opts_g \
+ .config_param); \
+ }
+
+/*
+ * Internal Util functions
+ */
+
+/* Check if a pce_opts_cli already exists based on its name and return it,
+ * return NULL otherwise */
+static struct pce_opts_cli *pcep_cli_find_pce(const char *pce_name)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ struct pce_opts_cli *pce_rhs_cli = pcep_g->pce_opts_cli[i];
+ if (pce_rhs_cli != NULL) {
+ if (strcmp(pce_name, pce_rhs_cli->pce_opts.pce_name)
+ == 0) {
+ return pce_rhs_cli;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+/* Add a new pce_opts_cli to pcep_g, return false if MAX_PCES, true otherwise */
+static bool pcep_cli_add_pce(struct pce_opts_cli *pce_opts_cli)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ if (pcep_g->pce_opts_cli[i] == NULL) {
+ pcep_g->pce_opts_cli[i] = pce_opts_cli;
+ pcep_g->num_pce_opts_cli++;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/* Create a new pce opts_cli */
+static struct pce_opts_cli *pcep_cli_create_pce_opts(const char *name)
+{
+ struct pce_opts_cli *pce_opts_cli =
+ XCALLOC(MTYPE_PCEP, sizeof(struct pce_opts_cli));
+ strlcpy(pce_opts_cli->pce_opts.pce_name, name,
+ sizeof(pce_opts_cli->pce_opts.pce_name));
+ pce_opts_cli->pce_opts.port = PCEP_DEFAULT_PORT;
+
+ return pce_opts_cli;
+}
+
+static void pcep_cli_delete_pce(const char *pce_name)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ if (pcep_g->pce_opts_cli[i] != NULL) {
+ if (strcmp(pcep_g->pce_opts_cli[i]->pce_opts.pce_name,
+ pce_name)
+ == 0) {
+ XFREE(MTYPE_PCEP, pcep_g->pce_opts_cli[i]);
+ pcep_g->pce_opts_cli[i] = NULL;
+ pcep_g->num_pce_opts_cli--;
+ return;
+ }
+ }
+ }
+}
+
+static void
+pcep_cli_merge_pcep_pce_config_options(struct pce_opts_cli *pce_opts_cli)
+{
+ if (pce_opts_cli->merged == true) {
+ return;
+ }
+
+ struct pcep_config_group_opts *pce_config =
+ pcep_cli_find_pcep_pce_config(pce_opts_cli->config_group_name);
+
+ /* Configuration priorities:
+ * 1) pce_opts->config_opts, if present, overwrite pce_config
+ * config_opts 2) pce_config config_opts, if present, overwrite
+ * default config_opts 3) If neither pce_opts->config_opts nor
+ * pce_config config_opts are set, then the default config_opts value
+ * will be used.
+ */
+
+ const char *tcp_md5_auth_str =
+ pce_opts_cli->pce_config_group_opts.tcp_md5_auth;
+ if (pce_opts_cli->pce_config_group_opts.tcp_md5_auth[0] == '\0') {
+ if (pce_config != NULL && pce_config->tcp_md5_auth[0] != '\0') {
+ tcp_md5_auth_str = pce_config->tcp_md5_auth;
+ } else {
+ tcp_md5_auth_str =
+ default_pcep_config_group_opts_g.tcp_md5_auth;
+ }
+ }
+ strlcpy(pce_opts_cli->pce_opts.config_opts.tcp_md5_auth,
+ tcp_md5_auth_str,
+ sizeof(pce_opts_cli->pce_opts.config_opts.tcp_md5_auth));
+
+ struct ipaddr *source_ip =
+ &pce_opts_cli->pce_config_group_opts.source_ip;
+ if (pce_opts_cli->pce_config_group_opts.source_ip.ipa_type
+ == IPADDR_NONE) {
+ if (pce_config != NULL
+ && pce_config->source_ip.ipa_type != IPADDR_NONE) {
+ source_ip = &pce_config->source_ip;
+ } else {
+ source_ip = &default_pcep_config_group_opts_g.source_ip;
+ }
+ }
+ memcpy(&pce_opts_cli->pce_opts.config_opts.source_ip, source_ip,
+ sizeof(struct ipaddr));
+
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(draft07, false);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(pce_initiated, false);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(keep_alive_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(min_keep_alive_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(max_keep_alive_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(dead_timer_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(min_dead_timer_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(max_dead_timer_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(pcep_request_time_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(session_timeout_inteval_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(delegation_timeout_seconds, 0);
+ MERGE_COMPARE_CONFIG_GROUP_VALUE(source_port, 0);
+
+ pce_opts_cli->merged = true;
+}
+
+/* Check if a pcep_config_group_opts already exists based on its name and return
+ * it, return NULL otherwise */
+static struct pcep_config_group_opts *
+pcep_cli_find_pcep_pce_config(const char *group_name)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ struct pcep_config_group_opts *pcep_pce_config_rhs =
+ pcep_g->config_group_opts[i];
+ if (pcep_pce_config_rhs != NULL) {
+ if (strcmp(group_name, pcep_pce_config_rhs->name)
+ == 0) {
+ return pcep_pce_config_rhs;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+/* Add a new pcep_config_group_opts to pcep_g, return false if MAX_PCE,
+ * true otherwise */
+static bool pcep_cli_add_pcep_pce_config(
+ struct pcep_config_group_opts *pcep_config_group_opts)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ if (pcep_g->config_group_opts[i] == NULL) {
+ pcep_g->config_group_opts[i] = pcep_config_group_opts;
+ pcep_g->num_config_group_opts++;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/* Create a new pce group, inheriting its values from the default pce group */
+static struct pcep_config_group_opts *
+pcep_cli_create_pcep_pce_config(const char *group_name)
+{
+ struct pcep_config_group_opts *pcep_config_group_opts =
+ XCALLOC(MTYPE_PCEP, sizeof(struct pcep_config_group_opts));
+ strlcpy(pcep_config_group_opts->name, group_name,
+ sizeof(pcep_config_group_opts->name));
+
+ return pcep_config_group_opts;
+}
+
+/* Iterate the pce_opts and return true if the pce-group-name is referenced,
+ * false otherwise. */
+static bool pcep_cli_is_pcep_pce_config_used(const char *group_name)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ if (pcep_g->pce_opts_cli[i] != NULL) {
+ if (strcmp(pcep_g->pce_opts_cli[i]->config_group_name,
+ group_name)
+ == 0) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+static void pcep_cli_delete_pcep_pce_config(const char *group_name)
+{
+ for (int i = 0; i < MAX_PCE; i++) {
+ if (pcep_g->config_group_opts[i] != NULL) {
+ if (strcmp(pcep_g->config_group_opts[i]->name,
+ group_name)
+ == 0) {
+ XFREE(MTYPE_PCEP, pcep_g->config_group_opts[i]);
+ pcep_g->config_group_opts[i] = NULL;
+ pcep_g->num_config_group_opts--;
+ return;
+ }
+ }
+ }
+}
+
+static bool pcep_cli_pcc_has_pce(const char *pce_name)
+{
+ for (int i = 0; i < MAX_PCC; i++) {
+ struct pce_opts *pce_opts = pce_connections_g.connections[i];
+ if (pce_opts == NULL) {
+ continue;
+ }
+
+ if (strcmp(pce_opts->pce_name, pce_name) == 0) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static void pcep_cli_add_pce_connection(struct pce_opts *pce_opts)
+{
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pce_connections_g.connections[i] == NULL) {
+ pce_connections_g.num_connections++;
+ pce_connections_g.connections[i] = pce_opts;
+ return;
+ }
+ }
+}
+
+static void pcep_cli_remove_pce_connection(struct pce_opts *pce_opts)
+{
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pce_connections_g.connections[i] == pce_opts) {
+ pce_connections_g.num_connections--;
+ pce_connections_g.connections[i] = NULL;
+ return;
+ }
+ }
+}
+
+/*
+ * VTY command implementations
+ */
+
+static int path_pcep_cli_debug(struct vty *vty, const char *no_str,
+ const char *basic_str, const char *path_str,
+ const char *message_str, const char *pceplib_str)
+{
+ uint32_t mode = DEBUG_NODE2MODE(vty->node);
+ bool no = (no_str != NULL);
+
+ DEBUG_MODE_SET(&pcep_g->dbg, mode, !no);
+
+ if (basic_str != NULL) {
+ DEBUG_FLAGS_SET(&pcep_g->dbg, PCEP_DEBUG_MODE_BASIC, !no);
+ }
+ if (path_str != NULL) {
+ DEBUG_FLAGS_SET(&pcep_g->dbg, PCEP_DEBUG_MODE_PATH, !no);
+ }
+ if (message_str != NULL) {
+ DEBUG_FLAGS_SET(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEP, !no);
+ }
+ if (pceplib_str != NULL) {
+ DEBUG_FLAGS_SET(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEPLIB, !no);
+ }
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_show_srte_pcep_counters(struct vty *vty)
+{
+ int i, j, row;
+ time_t diff_time;
+ struct tm tm_info;
+ char tm_buffer[26];
+ struct counters_group *group;
+ struct counters_subgroup *subgroup;
+ struct counter *counter;
+ const char *group_name, *empty_string = "";
+ struct ttable *tt;
+ char *table;
+
+ group = pcep_ctrl_get_counters(pcep_g->fpt, 1);
+
+ if (group == NULL) {
+ vty_out(vty, "No counters to display.\n\n");
+ return CMD_SUCCESS;
+ }
+
+ diff_time = time(NULL) - group->start_time;
+ localtime_r(&group->start_time, &tm_info);
+ strftime(tm_buffer, sizeof(tm_buffer), "%Y-%m-%d %H:%M:%S", &tm_info);
+
+ vty_out(vty, "PCEP counters since %s (%uh %um %us):\n", tm_buffer,
+ (uint32_t)(diff_time / 3600), (uint32_t)((diff_time / 60) % 60),
+ (uint32_t)(diff_time % 60));
+
+ /* Prepare table. */
+ tt = ttable_new(&ttable_styles[TTSTYLE_BLANK]);
+ ttable_add_row(tt, "Group|Name|Value");
+ tt->style.cell.rpad = 2;
+ tt->style.corner = '+';
+ ttable_restyle(tt);
+ ttable_rowseps(tt, 0, BOTTOM, true, '-');
+
+ for (row = 0, i = 0; i <= group->num_subgroups; i++) {
+ subgroup = group->subgroups[i];
+ if (subgroup != NULL) {
+ group_name = subgroup->counters_subgroup_name;
+ for (j = 0; j <= subgroup->num_counters; j++) {
+ counter = subgroup->counters[j];
+ if (counter != NULL) {
+ ttable_add_row(tt, "%s|%s|%u",
+ group_name,
+ counter->counter_name,
+ counter->counter_value);
+ row++;
+ group_name = empty_string;
+ }
+ }
+ ttable_rowseps(tt, row, BOTTOM, true, '-');
+ }
+ }
+
+ /* Dump the generated table. */
+ table = ttable_dump(tt, "\n");
+ vty_out(vty, "%s\n", table);
+ XFREE(MTYPE_TMP, table);
+
+ ttable_del(tt);
+
+ pcep_lib_free_counters(group);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcep_pce_config(struct vty *vty,
+ const char *pcep_pce_config)
+{
+ struct pcep_config_group_opts *pce_config =
+ pcep_cli_find_pcep_pce_config(pcep_pce_config);
+ if (pce_config == NULL) {
+ pce_config = pcep_cli_create_pcep_pce_config(pcep_pce_config);
+ if (pcep_cli_add_pcep_pce_config(pce_config) == false) {
+ vty_out(vty,
+ "%% Cannot create pce-config, as the Maximum limit of %d pce-config has been reached.\n",
+ MAX_PCE);
+ XFREE(MTYPE_PCEP, pce_config);
+ return CMD_WARNING;
+ }
+ } else {
+ vty_out(vty,
+ "Notice: changes to this pce-config will not affect PCEs already configured with this group\n");
+ }
+
+ current_pcep_config_group_opts_g = pce_config;
+ vty->node = PCEP_PCE_CONFIG_NODE;
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcep_pce_config_delete(struct vty *vty,
+ const char *pcep_pce_config)
+{
+ struct pcep_config_group_opts *pce_config =
+ pcep_cli_find_pcep_pce_config(pcep_pce_config);
+ if (pce_config == NULL) {
+ vty_out(vty,
+ "%% Cannot delete pce-config, since it does not exist.\n");
+ return CMD_WARNING;
+ }
+
+ if (pcep_cli_is_pcep_pce_config_used(pce_config->name)) {
+ vty_out(vty,
+ "%% Cannot delete pce-config, since it is in use by a peer.\n");
+ return CMD_WARNING;
+ }
+
+ pcep_cli_delete_pcep_pce_config(pce_config->name);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_show_srte_pcep_pce_config(struct vty *vty,
+ const char *pcep_pce_config)
+{
+ char buf[1024] = "";
+
+ /* Only show 1 Peer config group */
+ struct pcep_config_group_opts *group_opts;
+ if (pcep_pce_config != NULL) {
+ if (strcmp(pcep_pce_config, "default") == 0) {
+ group_opts = &default_pcep_config_group_opts_g;
+ } else {
+ group_opts =
+ pcep_cli_find_pcep_pce_config(pcep_pce_config);
+ }
+ if (group_opts == NULL) {
+ vty_out(vty, "%% pce-config [%s] does not exist.\n",
+ pcep_pce_config);
+ return CMD_WARNING;
+ }
+
+ vty_out(vty, "pce-config: %s\n", group_opts->name);
+ pcep_cli_print_pce_config(group_opts, buf, sizeof(buf));
+ vty_out(vty, "%s", buf);
+ return CMD_SUCCESS;
+ }
+
+ /* Show all Peer config groups */
+ for (int i = 0; i < MAX_PCE; i++) {
+ group_opts = pcep_g->config_group_opts[i];
+ if (group_opts == NULL) {
+ continue;
+ }
+
+ vty_out(vty, "pce-config: %s\n", group_opts->name);
+ pcep_cli_print_pce_config(group_opts, buf, sizeof(buf));
+ vty_out(vty, "%s", buf);
+ buf[0] = 0;
+ }
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pce(struct vty *vty, const char *pce_peer_name)
+{
+ /* If it already exists, it will be updated in the sub-commands */
+ struct pce_opts_cli *pce_opts_cli = pcep_cli_find_pce(pce_peer_name);
+ if (pce_opts_cli == NULL) {
+ pce_opts_cli = pcep_cli_create_pce_opts(pce_peer_name);
+
+ if (!pcep_cli_add_pce(pce_opts_cli)) {
+ vty_out(vty,
+ "%% Cannot create PCE, as the Maximum limit of %d PCEs has been reached.\n",
+ MAX_PCE);
+ XFREE(MTYPE_PCEP, pce_opts_cli);
+ return CMD_WARNING;
+ }
+ }
+
+ current_pce_opts_g = pce_opts_cli;
+ vty->node = PCEP_PCE_NODE;
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pce_delete(struct vty *vty, const char *pce_peer_name)
+{
+ struct pce_opts_cli *pce_opts_cli = pcep_cli_find_pce(pce_peer_name);
+ if (pce_opts_cli == NULL) {
+ vty_out(vty, "%% PCC peer does not exist.\n");
+ return CMD_WARNING;
+ }
+
+ /* To better work with frr-reload, go ahead and delete it if its in use
+ */
+ if (pcep_cli_pcc_has_pce(pce_peer_name)) {
+ vty_out(vty,
+ "%% Notice: the pce is in use by a PCC, also disconnecting.\n");
+ path_pcep_cli_pcc_pcc_peer_delete(vty, pce_peer_name, NULL, 0);
+ }
+
+ pcep_cli_delete_pce(pce_peer_name);
+
+ return CMD_SUCCESS;
+}
+
+/* Internal Util func to show an individual PCE,
+ * only used by path_pcep_cli_show_srte_pcep_pce() */
+static void show_pce_peer(struct vty *vty, struct pce_opts_cli *pce_opts_cli)
+{
+ struct pce_opts *pce_opts = &pce_opts_cli->pce_opts;
+ vty_out(vty, "PCE: %s\n", pce_opts->pce_name);
+
+ /* Remote PCE IP address */
+ if (IS_IPADDR_V6(&pce_opts->addr)) {
+ vty_out(vty, " %s %s %pI6 %s %d\n", PCEP_VTYSH_ARG_ADDRESS,
+ PCEP_VTYSH_ARG_IPV6, &pce_opts->addr.ipaddr_v6,
+ PCEP_VTYSH_ARG_PORT, pce_opts->port);
+ } else {
+ vty_out(vty, " %s %s %pI4 %s %d\n", PCEP_VTYSH_ARG_ADDRESS,
+ PCEP_VTYSH_ARG_IP, &pce_opts->addr.ipaddr_v4,
+ PCEP_VTYSH_ARG_PORT, pce_opts->port);
+ }
+
+ if (pce_opts_cli->config_group_name[0] != '\0') {
+ vty_out(vty, " pce-config: %s\n",
+ pce_opts_cli->config_group_name);
+ }
+
+ char buf[1024] = "";
+ pcep_cli_print_pce_config(&pce_opts->config_opts, buf, sizeof(buf));
+ vty_out(vty, "%s", buf);
+}
+
+static int path_pcep_cli_show_srte_pcep_pce(struct vty *vty,
+ const char *pce_peer)
+{
+ /* Only show 1 PCE */
+ struct pce_opts_cli *pce_opts_cli;
+ if (pce_peer != NULL) {
+ pce_opts_cli = pcep_cli_find_pce(pce_peer);
+ if (pce_opts_cli == NULL) {
+ vty_out(vty, "%% PCE [%s] does not exist.\n", pce_peer);
+ return CMD_WARNING;
+ }
+
+ pcep_cli_merge_pcep_pce_config_options(pce_opts_cli);
+ show_pce_peer(vty, pce_opts_cli);
+
+ return CMD_SUCCESS;
+ }
+
+ /* Show all PCEs */
+ for (int i = 0; i < MAX_PCE; i++) {
+ pce_opts_cli = pcep_g->pce_opts_cli[i];
+ if (pce_opts_cli == NULL) {
+ continue;
+ }
+
+ pcep_cli_merge_pcep_pce_config_options(pce_opts_cli);
+ show_pce_peer(vty, pce_opts_cli);
+ }
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_sr_draft07(struct vty *vty)
+{
+ struct pcep_config_group_opts *pce_config = NULL;
+
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ pce_config = &current_pce_opts_g->pce_config_group_opts;
+ current_pce_opts_g->merged = false;
+ } else if (vty->node == PCEP_PCE_CONFIG_NODE) {
+ pce_config = current_pcep_config_group_opts_g;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ pce_config->draft07 = true;
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_pce_initiated(struct vty *vty)
+{
+ struct pcep_config_group_opts *pce_config = NULL;
+
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ pce_config = &current_pce_opts_g->pce_config_group_opts;
+ current_pce_opts_g->merged = false;
+ } else if (vty->node == PCEP_PCE_CONFIG_NODE) {
+ pce_config = current_pcep_config_group_opts_g;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ pce_config->pce_initiated = true;
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_tcp_md5_auth(struct vty *vty,
+ const char *tcp_md5_auth)
+{
+ struct pcep_config_group_opts *pce_config = NULL;
+
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ pce_config = &current_pce_opts_g->pce_config_group_opts;
+ current_pce_opts_g->merged = false;
+ } else if (vty->node == PCEP_PCE_CONFIG_NODE) {
+ pce_config = current_pcep_config_group_opts_g;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ strlcpy(pce_config->tcp_md5_auth, tcp_md5_auth,
+ sizeof(pce_config->tcp_md5_auth));
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_address(struct vty *vty, const char *ip_str,
+ struct in_addr *ip, const char *ipv6_str,
+ struct in6_addr *ipv6,
+ const char *port_str, long port)
+{
+ struct pce_opts *pce_opts = NULL;
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ pce_opts = &current_pce_opts_g->pce_opts;
+ current_pce_opts_g->merged = false;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ if (ipv6_str != NULL) {
+ pce_opts->addr.ipa_type = IPADDR_V6;
+ memcpy(&pce_opts->addr.ipaddr_v6, ipv6,
+ sizeof(struct in6_addr));
+ } else if (ip_str != NULL) {
+ pce_opts->addr.ipa_type = IPADDR_V4;
+ memcpy(&pce_opts->addr.ipaddr_v4, ip, sizeof(struct in_addr));
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ /* Handle the optional port */
+ pce_opts->port = PCEP_DEFAULT_PORT;
+ PCEP_VTYSH_INT_ARG_CHECK(port_str, port, pce_opts->port, 0, 65535);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_source_address(struct vty *vty,
+ const char *ip_str,
+ struct in_addr *ip,
+ const char *ipv6_str,
+ struct in6_addr *ipv6,
+ const char *port_str, long port)
+{
+ struct pcep_config_group_opts *pce_config = NULL;
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ pce_config = &current_pce_opts_g->pce_config_group_opts;
+ current_pce_opts_g->merged = false;
+ } else if (vty->node == PCEP_PCE_CONFIG_NODE) {
+ pce_config = current_pcep_config_group_opts_g;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ /* Handle the optional source IP */
+ if (ipv6_str != NULL) {
+ pce_config->source_ip.ipa_type = IPADDR_V6;
+ memcpy(&pce_config->source_ip.ipaddr_v6, ipv6,
+ sizeof(struct in6_addr));
+ } else if (ip_str != NULL) {
+ pce_config->source_ip.ipa_type = IPADDR_V4;
+ memcpy(&pce_config->source_ip.ipaddr_v4, ip,
+ sizeof(struct in_addr));
+ }
+
+ /* Handle the optional port */
+ PCEP_VTYSH_INT_ARG_CHECK(port_str, port, pce_config->source_port, 0,
+ 65535);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_pcep_pce_config_ref(struct vty *vty,
+ const char *config_group_name)
+{
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ current_pce_opts_g->merged = false;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ struct pcep_config_group_opts *pce_config =
+ pcep_cli_find_pcep_pce_config(config_group_name);
+ if (pce_config == NULL) {
+ vty_out(vty, "%% pce-config [%s] does not exist.\n",
+ config_group_name);
+ return CMD_WARNING;
+ }
+
+ strlcpy(current_pce_opts_g->config_group_name, config_group_name,
+ sizeof(current_pce_opts_g->config_group_name));
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_peer_timers(
+ struct vty *vty, const char *keep_alive_str, long keep_alive,
+ const char *min_peer_keep_alive_str, long min_peer_keep_alive,
+ const char *max_peer_keep_alive_str, long max_peer_keep_alive,
+ const char *dead_timer_str, long dead_timer,
+ const char *min_peer_dead_timer_str, long min_peer_dead_timer,
+ const char *max_peer_dead_timer_str, long max_peer_dead_timer,
+ const char *pcep_request_str, long pcep_request,
+ const char *session_timeout_interval_str, long session_timeout_interval,
+ const char *delegation_timeout_str, long delegation_timeout)
+{
+ struct pcep_config_group_opts *pce_config = NULL;
+ if (vty->node == PCEP_PCE_NODE) {
+ /* TODO need to see if the pce is in use, and reset the
+ * connection */
+ pce_config = &current_pce_opts_g->pce_config_group_opts;
+ current_pce_opts_g->merged = false;
+ } else if (vty->node == PCEP_PCE_CONFIG_NODE) {
+ pce_config = current_pcep_config_group_opts_g;
+ } else {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ if (min_peer_keep_alive && max_peer_keep_alive)
+ if (min_peer_keep_alive >= max_peer_keep_alive) {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ if (min_peer_dead_timer && max_peer_dead_timer)
+ if (min_peer_dead_timer >= max_peer_dead_timer) {
+ return CMD_ERR_NO_MATCH;
+ }
+
+ /* Handle the arguments */
+ PCEP_VTYSH_INT_ARG_CHECK(keep_alive_str, keep_alive,
+ pce_config->keep_alive_seconds, 0, 64);
+ PCEP_VTYSH_INT_ARG_CHECK(min_peer_keep_alive_str, min_peer_keep_alive,
+ pce_config->min_keep_alive_seconds, 0, 256);
+ PCEP_VTYSH_INT_ARG_CHECK(max_peer_keep_alive_str, max_peer_keep_alive,
+ pce_config->max_keep_alive_seconds, 0, 256);
+ PCEP_VTYSH_INT_ARG_CHECK(dead_timer_str, dead_timer,
+ pce_config->dead_timer_seconds, 3, 256);
+ PCEP_VTYSH_INT_ARG_CHECK(min_peer_dead_timer_str, min_peer_dead_timer,
+ pce_config->min_dead_timer_seconds, 3, 256);
+ PCEP_VTYSH_INT_ARG_CHECK(max_peer_dead_timer_str, max_peer_dead_timer,
+ pce_config->max_dead_timer_seconds, 3, 256);
+ PCEP_VTYSH_INT_ARG_CHECK(pcep_request_str, pcep_request,
+ pce_config->pcep_request_time_seconds, 0, 121);
+ PCEP_VTYSH_INT_ARG_CHECK(
+ session_timeout_interval_str, session_timeout_interval,
+ pce_config->session_timeout_inteval_seconds, 0, 121);
+ PCEP_VTYSH_INT_ARG_CHECK(delegation_timeout_str, delegation_timeout,
+ pce_config->delegation_timeout_seconds, 0, 61);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcc(struct vty *vty)
+{
+ VTY_PUSH_CONTEXT_NULL(PCEP_PCC_NODE);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcc_delete(struct vty *vty)
+{
+ /* Clear the pce_connections */
+ memset(&pce_connections_g, 0, sizeof(pce_connections_g));
+ pcc_msd_configured_g = false;
+
+ pcep_ctrl_remove_pcc(pcep_g->fpt, NULL);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcc_pcc_msd(struct vty *vty, const char *msd_str,
+ long msd)
+{
+ pcc_msd_configured_g = true;
+ PCEP_VTYSH_INT_ARG_CHECK(msd_str, msd, pcc_msd_g, 0, 33);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcc_pcc_peer(struct vty *vty, const char *peer_name,
+ const char *precedence_str,
+ long precedence)
+{
+ /* Check if the pcc-peer exists */
+ struct pce_opts_cli *pce_opts_cli = pcep_cli_find_pce(peer_name);
+ if (pce_opts_cli == NULL) {
+ vty_out(vty, "%% PCE [%s] does not exist.\n", peer_name);
+ return CMD_WARNING;
+ }
+ struct pce_opts *pce_opts = &pce_opts_cli->pce_opts;
+
+ /* Check if the pcc-peer is duplicated */
+ if (pcep_cli_pcc_has_pce(peer_name)) {
+ vty_out(vty, "%% The peer [%s] has already been configured.\n",
+ peer_name);
+ return CMD_WARNING;
+ }
+
+ /* Get the optional precedence argument */
+ pce_opts->precedence = DEFAULT_PCE_PRECEDENCE;
+ PCEP_VTYSH_INT_ARG_CHECK(precedence_str, precedence,
+ pce_opts->precedence, 0, 256);
+
+ /* Finalize the pce_opts config values */
+ pcep_cli_merge_pcep_pce_config_options(pce_opts_cli);
+ pcep_cli_add_pce_connection(&pce_opts_cli->pce_opts);
+
+ /* Verify the PCE has the IP set */
+ struct in6_addr zero_v6_addr;
+ memset(&zero_v6_addr, 0, sizeof(zero_v6_addr));
+ if (memcmp(&pce_opts->addr.ip, &zero_v6_addr, IPADDRSZ(&pce_opts->addr))
+ == 0) {
+ vty_out(vty,
+ "%% The peer [%s] does not have an IP set and cannot be used until it does.\n",
+ peer_name);
+ return CMD_WARNING;
+ }
+
+ /* Update the pcc_opts with the source ip, port, and msd */
+ struct pcc_opts *pcc_opts_copy =
+ XMALLOC(MTYPE_PCEP, sizeof(struct pcc_opts));
+ memcpy(&pcc_opts_copy->addr,
+ &pce_opts_cli->pce_opts.config_opts.source_ip,
+ sizeof(pcc_opts_copy->addr));
+ pcc_opts_copy->msd = pcc_msd_g;
+ pcc_opts_copy->port = pce_opts_cli->pce_opts.config_opts.source_port;
+ if (pcep_ctrl_update_pcc_options(pcep_g->fpt, pcc_opts_copy)) {
+ return CMD_WARNING;
+ }
+
+ /* Send a copy of the pce_opts, this one is only used for the CLI */
+ struct pce_opts *pce_opts_copy =
+ XMALLOC(MTYPE_PCEP, sizeof(struct pce_opts));
+ memcpy(pce_opts_copy, pce_opts, sizeof(struct pce_opts));
+ if (pcep_ctrl_update_pce_options(pcep_g->fpt, pce_opts_copy)) {
+ return CMD_WARNING;
+ }
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_pcc_pcc_peer_delete(struct vty *vty,
+ const char *peer_name,
+ const char *precedence_str,
+ long precedence)
+{
+ /* Check if the pcc-peer is connected to the PCC */
+ if (!pcep_cli_pcc_has_pce(peer_name)) {
+ vty_out(vty,
+ "%% WARN: The peer [%s] is not connected to the PCC.\n",
+ peer_name);
+ return CMD_WARNING;
+ }
+
+ struct pce_opts_cli *pce_opts_cli = pcep_cli_find_pce(peer_name);
+ pcep_cli_remove_pce_connection(&pce_opts_cli->pce_opts);
+
+ /* Send a copy of the pce_opts, this one is used for CLI only */
+ struct pce_opts *pce_opts_copy =
+ XMALLOC(MTYPE_PCEP, sizeof(struct pce_opts));
+ memcpy(pce_opts_copy, &pce_opts_cli->pce_opts, sizeof(struct pce_opts));
+ pcep_ctrl_remove_pcc(pcep_g->fpt, pce_opts_copy);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_show_srte_pcep_pcc(struct vty *vty)
+{
+ vty_out(vty, "pcc msd %d\n", pcc_msd_g);
+
+ return CMD_SUCCESS;
+}
+
+/* Internal util function to print pcep capabilities to a buffer */
+static void print_pcep_capabilities(char *buf, size_t buf_len,
+ pcep_configuration *config)
+{
+ if (config->support_stateful_pce_lsp_update) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_STATEFUL);
+ }
+ if (config->support_include_db_version) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_INCL_DB_VER);
+ }
+ if (config->support_lsp_triggered_resync) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_LSP_TRIGGERED);
+ }
+ if (config->support_lsp_delta_sync) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_LSP_DELTA);
+ }
+ if (config->support_pce_triggered_initial_sync) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_PCE_TRIGGERED);
+ }
+ if (config->support_sr_te_pst) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_SR_TE_PST);
+ }
+ if (config->pcc_can_resolve_nai_to_sid) {
+ csnprintfrr(buf, buf_len, "%s", PCEP_CLI_CAP_PCC_RESOLVE_NAI);
+ }
+}
+
+/* Internal util function to print a pcep session */
+static void print_pcep_session(struct vty *vty, struct pce_opts *pce_opts,
+ struct pcep_pcc_info *pcc_info)
+{
+ char buf[1024];
+ buf[0] = '\0';
+
+ vty_out(vty, "\nPCE %s\n", pce_opts->pce_name);
+
+ /* PCE IP */
+ if (IS_IPADDR_V4(&pce_opts->addr)) {
+ vty_out(vty, " PCE IP %pI4 port %d\n",
+ &pce_opts->addr.ipaddr_v4, pce_opts->port);
+ } else if (IS_IPADDR_V6(&pce_opts->addr)) {
+ vty_out(vty, " PCE IPv6 %pI6 port %d\n",
+ &pce_opts->addr.ipaddr_v6, pce_opts->port);
+ }
+
+ /* PCC IP */
+ if (IS_IPADDR_V4(&pcc_info->pcc_addr)) {
+ vty_out(vty, " PCC IP %pI4 port %d\n",
+ &pcc_info->pcc_addr.ipaddr_v4, pcc_info->pcc_port);
+ } else if (IS_IPADDR_V6(&pcc_info->pcc_addr)) {
+ vty_out(vty, " PCC IPv6 %pI6 port %d\n",
+ &pcc_info->pcc_addr.ipaddr_v6, pcc_info->pcc_port);
+ }
+ vty_out(vty, " PCC MSD %d\n", pcc_info->msd);
+
+ if (pcc_info->status == PCEP_PCC_OPERATING) {
+ vty_out(vty, " Session Status UP\n");
+ } else {
+ vty_out(vty, " Session Status %s\n",
+ pcc_status_name(pcc_info->status));
+ }
+
+ if (pcc_info->is_best_multi_pce) {
+ vty_out(vty, " Precedence %d, best candidate\n",
+ ((pcc_info->precedence > 0) ? pcc_info->precedence
+ : DEFAULT_PCE_PRECEDENCE));
+ } else {
+ vty_out(vty, " Precedence %d\n",
+ ((pcc_info->precedence > 0) ? pcc_info->precedence
+ : DEFAULT_PCE_PRECEDENCE));
+ }
+ vty_out(vty, " Confidence %s\n",
+ ((pcc_info->previous_best) ? "low"
+ : "normal"));
+
+ /* PCEPlib pcep session values, get a thread safe copy of the counters
+ */
+ pcep_session *session =
+ pcep_ctrl_get_pcep_session(pcep_g->fpt, pcc_info->pcc_id);
+
+ /* Config Options values */
+ struct pcep_config_group_opts *config_opts = &pce_opts->config_opts;
+ if (session != NULL) {
+ vty_out(vty, " Timer: KeepAlive config %d, pce-negotiated %d\n",
+ config_opts->keep_alive_seconds,
+ session->pcc_config
+ .keep_alive_pce_negotiated_timer_seconds);
+ vty_out(vty, " Timer: DeadTimer config %d, pce-negotiated %d\n",
+ config_opts->dead_timer_seconds,
+ session->pcc_config.dead_timer_pce_negotiated_seconds);
+ } else {
+ vty_out(vty, " Timer: KeepAlive %d\n",
+ config_opts->keep_alive_seconds);
+ vty_out(vty, " Timer: DeadTimer %d\n",
+ config_opts->dead_timer_seconds);
+ }
+ vty_out(vty, " Timer: PcRequest %d\n",
+ config_opts->pcep_request_time_seconds);
+ vty_out(vty, " Timer: SessionTimeout Interval %d\n",
+ config_opts->session_timeout_inteval_seconds);
+ vty_out(vty, " Timer: Delegation Timeout %d\n",
+ config_opts->delegation_timeout_seconds);
+ if (strlen(config_opts->tcp_md5_auth) > 0) {
+ vty_out(vty, " TCP MD5 Auth Str: %s\n",
+ config_opts->tcp_md5_auth);
+ } else {
+ vty_out(vty, " No TCP MD5 Auth\n");
+ }
+
+ if (config_opts->draft07) {
+ vty_out(vty, " PCE SR Version draft07\n");
+ } else {
+ vty_out(vty, " PCE SR Version draft16 and RFC8408\n");
+ }
+
+ vty_out(vty, " Next PcReq ID %d\n", pcc_info->next_reqid);
+ vty_out(vty, " Next PLSP ID %d\n", pcc_info->next_plspid);
+
+ if (session != NULL) {
+ if (pcc_info->status == PCEP_PCC_SYNCHRONIZING
+ || pcc_info->status == PCEP_PCC_OPERATING) {
+ time_t current_time = time(NULL);
+ struct tm lt = {0};
+ /* Just for the timezone */
+ localtime_r(&current_time, &lt);
+ gmtime_r(&session->time_connected, &lt);
+ vty_out(vty,
+ " Connected for %u seconds, since %d-%02d-%02d %02d:%02d:%02d UTC\n",
+ (uint32_t)(current_time
+ - session->time_connected),
+ lt.tm_year + 1900, lt.tm_mon + 1, lt.tm_mday,
+ lt.tm_hour, lt.tm_min, lt.tm_sec);
+ }
+
+ /* PCC capabilities */
+ buf[0] = '\0';
+ int index = 0;
+ if (config_opts->pce_initiated) {
+ index += csnprintfrr(buf, sizeof(buf), "%s",
+ PCEP_CLI_CAP_PCC_PCE_INITIATED);
+ } else {
+ index += csnprintfrr(buf, sizeof(buf), "%s",
+ PCEP_CLI_CAP_PCC_INITIATED);
+ }
+ print_pcep_capabilities(buf, sizeof(buf) - index,
+ &session->pcc_config);
+ vty_out(vty, " PCC Capabilities:%s\n", buf);
+
+ /* PCE capabilities */
+ buf[0] = '\0';
+ print_pcep_capabilities(buf, sizeof(buf), &session->pce_config);
+ if (buf[0] != '\0') {
+ vty_out(vty, " PCE Capabilities:%s\n", buf);
+ }
+ XFREE(MTYPE_PCEP, session);
+ } else {
+ vty_out(vty, " Detailed session information not available\n");
+ }
+
+ /* Message Counters, get a thread safe copy of the counters */
+ struct counters_group *group =
+ pcep_ctrl_get_counters(pcep_g->fpt, pcc_info->pcc_id);
+
+ if (group != NULL) {
+ struct counters_subgroup *rx_msgs =
+ find_subgroup(group, COUNTER_SUBGROUP_ID_RX_MSG);
+ struct counters_subgroup *tx_msgs =
+ find_subgroup(group, COUNTER_SUBGROUP_ID_TX_MSG);
+
+ if (rx_msgs != NULL && tx_msgs != NULL) {
+ vty_out(vty, " PCEP Message Statistics\n");
+ vty_out(vty, " %27s %6s\n", "Sent", "Rcvd");
+ for (int i = 0; i < rx_msgs->max_counters; i++) {
+ struct counter *rx_counter =
+ rx_msgs->counters[i];
+ struct counter *tx_counter =
+ tx_msgs->counters[i];
+ if (rx_counter != NULL && tx_counter != NULL) {
+ vty_out(vty, " %20s: %5d %5d\n",
+ tx_counter->counter_name,
+ tx_counter->counter_value,
+ rx_counter->counter_value);
+ }
+ }
+ vty_out(vty, " %20s: %5d %5d\n", "Total",
+ subgroup_counters_total(tx_msgs),
+ subgroup_counters_total(rx_msgs));
+ }
+ pcep_lib_free_counters(group);
+ } else {
+ vty_out(vty, " Counters not available\n");
+ }
+
+ XFREE(MTYPE_PCEP, pcc_info);
+}
+
+static int path_pcep_cli_show_srte_pcep_session(struct vty *vty,
+ const char *pcc_peer)
+{
+ struct pce_opts_cli *pce_opts_cli;
+ struct pcep_pcc_info *pcc_info;
+
+ /* Only show 1 PCEP session */
+ if (pcc_peer != NULL) {
+ pce_opts_cli = pcep_cli_find_pce(pcc_peer);
+ if (pce_opts_cli == NULL) {
+ vty_out(vty, "%% PCE [%s] does not exist.\n", pcc_peer);
+ return CMD_WARNING;
+ }
+
+ if (!pcep_cli_pcc_has_pce(pcc_peer)) {
+ vty_out(vty, "%% PCC is not connected to PCE [%s].\n",
+ pcc_peer);
+ return CMD_WARNING;
+ }
+
+ pcc_info = pcep_ctrl_get_pcc_info(pcep_g->fpt, pcc_peer);
+ if (pcc_info == NULL) {
+ vty_out(vty,
+ "%% Cannot retrieve PCEP session info for PCE [%s]\n",
+ pcc_peer);
+ return CMD_WARNING;
+ }
+
+ print_pcep_session(vty, &pce_opts_cli->pce_opts, pcc_info);
+
+ return CMD_SUCCESS;
+ }
+
+ /* Show all PCEP sessions */
+ struct pce_opts *pce_opts;
+ int num_pcep_sessions_conf = 0;
+ int num_pcep_sessions_conn = 0;
+ for (int i = 0; i < MAX_PCC; i++) {
+ pce_opts = pce_connections_g.connections[i];
+ if (pce_opts == NULL) {
+ continue;
+ }
+
+ pcc_info =
+ pcep_ctrl_get_pcc_info(pcep_g->fpt, pce_opts->pce_name);
+ if (pcc_info == NULL) {
+ vty_out(vty,
+ "%% Cannot retrieve PCEP session info for PCE [%s]\n",
+ pce_opts->pce_name);
+ continue;
+ }
+
+ num_pcep_sessions_conn +=
+ pcc_info->status == PCEP_PCC_OPERATING ? 1 : 0;
+ num_pcep_sessions_conf++;
+ print_pcep_session(vty, pce_opts, pcc_info);
+ }
+
+ vty_out(vty, "PCEP Sessions => Configured %d ; Connected %d\n",
+ num_pcep_sessions_conf, num_pcep_sessions_conn);
+
+ return CMD_SUCCESS;
+}
+
+static int path_pcep_cli_clear_srte_pcep_session(struct vty *vty,
+ const char *pcc_peer)
+{
+ struct pce_opts_cli *pce_opts_cli;
+
+ /* Only clear 1 PCEP session */
+ if (pcc_peer != NULL) {
+ pce_opts_cli = pcep_cli_find_pce(pcc_peer);
+ if (pce_opts_cli == NULL) {
+ vty_out(vty, "%% PCE [%s] does not exist.\n", pcc_peer);
+ return CMD_WARNING;
+ }
+
+ if (!pcep_cli_pcc_has_pce(pcc_peer)) {
+ vty_out(vty, "%% PCC is not connected to PCE [%s].\n",
+ pcc_peer);
+ return CMD_WARNING;
+ }
+
+ pcep_ctrl_reset_pcc_session(pcep_g->fpt,
+ pce_opts_cli->pce_opts.pce_name);
+ vty_out(vty, "PCEP session cleared for peer %s\n", pcc_peer);
+
+ return CMD_SUCCESS;
+ }
+
+ /* Clear all PCEP sessions */
+ struct pce_opts *pce_opts;
+ int num_pcep_sessions = 0;
+ for (int i = 0; i < MAX_PCC; i++) {
+ pce_opts = pce_connections_g.connections[i];
+ if (pce_opts == NULL) {
+ continue;
+ }
+
+ num_pcep_sessions++;
+ pcep_ctrl_reset_pcc_session(pcep_g->fpt, pce_opts->pce_name);
+ vty_out(vty, "PCEP session cleared for peer %s\n",
+ pce_opts->pce_name);
+ }
+
+ vty_out(vty, "Cleared [%d] PCEP sessions\n", num_pcep_sessions);
+
+ return CMD_SUCCESS;
+}
+
+/*
+ * Config Write functions
+ */
+
+int pcep_cli_debug_config_write(struct vty *vty)
+{
+ char buff[128] = "";
+
+ if (DEBUG_MODE_CHECK(&pcep_g->dbg, DEBUG_MODE_CONF)) {
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_BASIC))
+ csnprintfrr(buff, sizeof(buff), " %s",
+ PCEP_VTYSH_ARG_BASIC);
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PATH))
+ csnprintfrr(buff, sizeof(buff), " %s",
+ PCEP_VTYSH_ARG_PATH);
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEP))
+ csnprintfrr(buff, sizeof(buff), " %s",
+ PCEP_VTYSH_ARG_MESSAGE);
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEPLIB))
+ csnprintfrr(buff, sizeof(buff), " %s",
+ PCEP_VTYSH_ARG_PCEPLIB);
+ vty_out(vty, "debug pathd pcep%s\n", buff);
+ buff[0] = 0;
+ return 1;
+ }
+
+ return 0;
+}
+
+int pcep_cli_debug_set_all(uint32_t flags, bool set)
+{
+ DEBUG_FLAGS_SET(&pcep_g->dbg, flags, set);
+
+ /* If all modes have been turned off, don't preserve options. */
+ if (!DEBUG_MODE_CHECK(&pcep_g->dbg, DEBUG_MODE_ALL))
+ DEBUG_CLEAR(&pcep_g->dbg);
+
+ return 0;
+}
+
+int pcep_cli_pcep_config_write(struct vty *vty)
+{
+ vty_out(vty, " pcep\n");
+ pcep_cli_pcep_pce_config_write(vty);
+ pcep_cli_pce_config_write(vty);
+ pcep_cli_pcc_config_write(vty);
+ vty_out(vty, " exit\n");
+ return 1;
+}
+
+int pcep_cli_pcc_config_write(struct vty *vty)
+{
+ struct pce_opts *pce_opts;
+ char buf[128] = "";
+ int lines = 0;
+
+ /* The MSD, nor any PCE peers have been configured on the PCC */
+ if (!pcc_msd_configured_g && pce_connections_g.num_connections == 0) {
+ return lines;
+ }
+
+ vty_out(vty, " pcc\n");
+ lines++;
+
+ /* Prepare the MSD, if present */
+ if (pcc_msd_configured_g) {
+ vty_out(vty, " %s %d\n", PCEP_VTYSH_ARG_MSD, pcc_msd_g);
+ lines++;
+ }
+
+ if (pce_connections_g.num_connections == 0) {
+ goto exit;
+ }
+
+ buf[0] = 0;
+ for (int i = 0; i < MAX_PCC; i++) {
+ pce_opts = pce_connections_g.connections[i];
+ if (pce_opts == NULL) {
+ continue;
+ }
+
+ /* Only show the PCEs configured in the pcc sub-command */
+ if (!pcep_cli_pcc_has_pce(pce_opts->pce_name)) {
+ continue;
+ }
+
+ csnprintfrr(buf, sizeof(buf), " peer %s",
+ pce_opts->pce_name);
+ if (pce_opts->precedence > 0
+ && pce_opts->precedence != DEFAULT_PCE_PRECEDENCE) {
+ csnprintfrr(buf, sizeof(buf), " %s %d",
+ PCEP_VTYSH_ARG_PRECEDENCE,
+ pce_opts->precedence);
+ }
+ vty_out(vty, "%s\n", buf);
+ lines++;
+ buf[0] = 0;
+ }
+exit:
+ vty_out(vty, " exit\n");
+
+ return lines;
+}
+
+/* Internal function used by pcep_cli_pce_config_write()
+ * and pcep_cli_pcep_pce_config_write() */
+static int pcep_cli_print_pce_config(struct pcep_config_group_opts *group_opts,
+ char *buf, size_t buf_len)
+{
+ int lines = 0;
+
+ if (group_opts->source_ip.ipa_type != IPADDR_NONE
+ || group_opts->source_port != 0) {
+ csnprintfrr(buf, buf_len, " ");
+ if (IS_IPADDR_V4(&group_opts->source_ip)) {
+ csnprintfrr(buf, buf_len, " %s %s %pI4",
+ PCEP_VTYSH_ARG_SOURCE_ADDRESS,
+ PCEP_VTYSH_ARG_IP,
+ &group_opts->source_ip.ipaddr_v4);
+ } else if (IS_IPADDR_V6(&group_opts->source_ip)) {
+ csnprintfrr(buf, buf_len, " %s %s %pI6",
+ PCEP_VTYSH_ARG_SOURCE_ADDRESS,
+ PCEP_VTYSH_ARG_IPV6,
+ &group_opts->source_ip.ipaddr_v6);
+ }
+ if (group_opts->source_port > 0) {
+ csnprintfrr(buf, buf_len, " %s %d", PCEP_VTYSH_ARG_PORT,
+ group_opts->source_port);
+ }
+ csnprintfrr(buf, buf_len, "\n");
+ lines++;
+ }
+ /* Group the keep-alive together for devman */
+ if ((group_opts->keep_alive_seconds > 0)
+ || (group_opts->min_keep_alive_seconds > 0)
+ || (group_opts->max_keep_alive_seconds > 0)) {
+ csnprintfrr(buf, buf_len, " %s", PCEP_VTYSH_ARG_TIMER);
+
+ if (group_opts->keep_alive_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %d",
+ PCEP_VTYSH_ARG_KEEP_ALIVE,
+ group_opts->keep_alive_seconds);
+ }
+ if (group_opts->min_keep_alive_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %d",
+ PCEP_VTYSH_ARG_KEEP_ALIVE_MIN,
+ group_opts->min_keep_alive_seconds);
+ }
+ if (group_opts->max_keep_alive_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %d",
+ PCEP_VTYSH_ARG_KEEP_ALIVE_MAX,
+ group_opts->max_keep_alive_seconds);
+ }
+ csnprintfrr(buf, buf_len, "\n");
+ lines++;
+ }
+
+ /* Group the dead-timer together for devman */
+ if ((group_opts->dead_timer_seconds > 0)
+ || (group_opts->min_dead_timer_seconds > 0)
+ || (group_opts->max_dead_timer_seconds > 0)) {
+ csnprintfrr(buf, buf_len, " %s", PCEP_VTYSH_ARG_TIMER);
+
+ if (group_opts->dead_timer_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %d",
+ PCEP_VTYSH_ARG_DEAD_TIMER,
+ group_opts->dead_timer_seconds);
+ }
+ if (group_opts->min_dead_timer_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %d",
+ PCEP_VTYSH_ARG_DEAD_TIMER_MIN,
+ group_opts->min_dead_timer_seconds);
+ }
+ if (group_opts->max_dead_timer_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %d",
+ PCEP_VTYSH_ARG_DEAD_TIMER_MAX,
+ group_opts->max_dead_timer_seconds);
+ }
+ csnprintfrr(buf, buf_len, "\n");
+ lines++;
+ }
+
+ if (group_opts->pcep_request_time_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %s %d\n",
+ PCEP_VTYSH_ARG_TIMER, PCEP_VTYSH_ARG_PCEP_REQUEST,
+ group_opts->pcep_request_time_seconds);
+ lines++;
+ }
+ if (group_opts->delegation_timeout_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %s %d\n",
+ PCEP_VTYSH_ARG_TIMER,
+ PCEP_VTYSH_ARG_DELEGATION_TIMEOUT,
+ group_opts->delegation_timeout_seconds);
+ lines++;
+ }
+ if (group_opts->session_timeout_inteval_seconds > 0) {
+ csnprintfrr(buf, buf_len, " %s %s %d\n",
+ PCEP_VTYSH_ARG_TIMER,
+ PCEP_VTYSH_ARG_SESSION_TIMEOUT,
+ group_opts->session_timeout_inteval_seconds);
+ lines++;
+ }
+ if (group_opts->tcp_md5_auth[0] != '\0') {
+ csnprintfrr(buf, buf_len, " %s %s\n", PCEP_VTYSH_ARG_TCP_MD5,
+ group_opts->tcp_md5_auth);
+ lines++;
+ }
+ if (group_opts->draft07) {
+ csnprintfrr(buf, buf_len, " %s\n",
+ PCEP_VTYSH_ARG_SR_DRAFT07);
+ lines++;
+ }
+ if (group_opts->pce_initiated) {
+ csnprintfrr(buf, buf_len, " %s\n", PCEP_VTYSH_ARG_PCE_INIT);
+ lines++;
+ }
+
+ return lines;
+}
+
+int pcep_cli_pce_config_write(struct vty *vty)
+{
+ int lines = 0;
+ char buf[1024] = "";
+
+ for (int i = 0; i < MAX_PCE; i++) {
+ struct pce_opts_cli *pce_opts_cli = pcep_g->pce_opts_cli[i];
+ if (pce_opts_cli == NULL) {
+ continue;
+ }
+ struct pce_opts *pce_opts = &pce_opts_cli->pce_opts;
+
+ vty_out(vty, " pce %s\n", pce_opts->pce_name);
+ if (IS_IPADDR_V6(&pce_opts->addr)) {
+ vty_out(vty, " %s %s %pI6", PCEP_VTYSH_ARG_ADDRESS,
+ PCEP_VTYSH_ARG_IPV6, &pce_opts->addr.ipaddr_v6);
+ } else if (IS_IPADDR_V4(&pce_opts->addr)) {
+ vty_out(vty, " address %s %pI4", PCEP_VTYSH_ARG_IP,
+ &pce_opts->addr.ipaddr_v4);
+ }
+ if (pce_opts->port != PCEP_DEFAULT_PORT) {
+ vty_out(vty, " %s %d", PCEP_VTYSH_ARG_PORT,
+ pce_opts->port);
+ }
+ vty_out(vty, "%s\n", buf);
+ lines += 2;
+
+ if (pce_opts_cli->config_group_name[0] != '\0') {
+ vty_out(vty, " config %s\n",
+ pce_opts_cli->config_group_name);
+ lines++;
+ }
+
+ /* Only display the values configured on the PCE, not the values
+ * from its optional pce-config-group, nor the default values */
+ lines += pcep_cli_print_pce_config(
+ &pce_opts_cli->pce_config_group_opts, buf, sizeof(buf));
+
+ vty_out(vty, "%s", buf);
+ buf[0] = '\0';
+
+ vty_out(vty, " exit\n");
+ }
+
+ return lines;
+}
+
+int pcep_cli_pcep_pce_config_write(struct vty *vty)
+{
+ int lines = 0;
+ char buf[1024] = "";
+
+ for (int i = 0; i < MAX_PCE; i++) {
+ struct pcep_config_group_opts *group_opts =
+ pcep_g->config_group_opts[i];
+ if (group_opts == NULL) {
+ continue;
+ }
+
+ vty_out(vty, " pce-config %s\n", group_opts->name);
+ lines += 1;
+
+ lines +=
+ pcep_cli_print_pce_config(group_opts, buf, sizeof(buf));
+ vty_out(vty, "%s", buf);
+ buf[0] = 0;
+
+ vty_out(vty, " exit\n");
+ }
+
+ return lines;
+}
+
+/*
+ * VTYSH command syntax definitions
+ * The param names are taken from the path_pcep_cli_clippy.c generated file.
+ */
+
+DEFPY(show_debugging_pathd_pcep,
+ show_debugging_pathd_pcep_cmd,
+ "show debugging pathd-pcep",
+ SHOW_STR
+ "State of each debugging option\n"
+ "pathd pcep module debugging\n")
+{
+ vty_out(vty, "Pathd pcep debugging status:\n");
+
+ if (DEBUG_MODE_CHECK(&pcep_g->dbg, DEBUG_MODE_CONF)) {
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_BASIC))
+ vty_out(vty, " Pathd pcep %s debugging is on\n",
+ PCEP_VTYSH_ARG_BASIC);
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PATH))
+ vty_out(vty, " Pathd pcep %s debugging is on\n",
+ PCEP_VTYSH_ARG_PATH);
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEP))
+ vty_out(vty, " Pathd pcep %s debugging is on\n",
+ PCEP_VTYSH_ARG_MESSAGE);
+ if (DEBUG_FLAGS_CHECK(&pcep_g->dbg, PCEP_DEBUG_MODE_PCEPLIB))
+ vty_out(vty, " Pathd pcep %s debugging is on\n",
+ PCEP_VTYSH_ARG_PCEPLIB);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFPY(pcep_cli_debug,
+ pcep_cli_debug_cmd,
+ "[no] debug pathd pcep [basic]$basic_str [path]$path_str [message]$message_str [pceplib]$pceplib_str",
+ NO_STR DEBUG_STR
+ "pathd debugging\n"
+ "pcep module debugging\n"
+ "module basic debugging\n"
+ "path structures debugging\n"
+ "pcep message debugging\n"
+ "pceplib debugging\n")
+{
+ return path_pcep_cli_debug(vty, no, basic_str, path_str, message_str,
+ pceplib_str);
+}
+
+DEFPY(pcep_cli_show_srte_pcep_counters,
+ pcep_cli_show_srte_pcep_counters_cmd,
+ "show sr-te pcep counters",
+ SHOW_STR
+ "SR-TE info\n"
+ "PCEP info\n"
+ "PCEP counters\n")
+{
+ return path_pcep_cli_show_srte_pcep_counters(vty);
+}
+
+DEFPY_NOSH(
+ pcep_cli_pcep,
+ pcep_cli_pcep_cmd,
+ "pcep",
+ "PCEP configuration\n")
+{
+ vty->node = PCEP_NODE;
+ return CMD_SUCCESS;
+}
+
+DEFPY_NOSH(
+ pcep_cli_pcep_pce_config,
+ pcep_cli_pcep_pce_config_cmd,
+ "pce-config WORD$name",
+ "Shared configuration\n"
+ "Shared configuration name\n")
+{
+ return path_pcep_cli_pcep_pce_config(vty, name);
+}
+
+DEFPY(pcep_cli_pcep_no_pce_config,
+ pcep_cli_pcep_no_pce_config_cmd,
+ "no pce-config WORD$name",
+ NO_STR
+ "Shared configuration\n"
+ "Shared configuration name\n")
+{
+ return path_pcep_cli_pcep_pce_config_delete(vty, name);
+}
+
+DEFPY(pcep_cli_show_srte_pcep_pce_config,
+ pcep_cli_show_srte_pcep_pce_config_cmd,
+ "show sr-te pcep pce-config [<default|WORD>$name]",
+ SHOW_STR
+ "SR-TE info\n"
+ "PCEP info\n"
+ "Show shared PCE configuration\n"
+ "Show default hard-coded values\n"
+ "Shared configuration name\n")
+{
+ return path_pcep_cli_show_srte_pcep_pce_config(vty, name);
+}
+
+DEFPY_NOSH(
+ pcep_cli_pce,
+ pcep_cli_pce_cmd,
+ "pce WORD$name",
+ "PCE configuration, address sub-config is mandatory\n"
+ "PCE name\n")
+{
+ return path_pcep_cli_pce(vty, name);
+}
+
+DEFPY(pcep_cli_no_pce,
+ pcep_cli_no_pce_cmd,
+ "no pce WORD$name",
+ NO_STR
+ "PCE configuration, address sub-config is mandatory\n"
+ "PCE name\n")
+{
+ return path_pcep_cli_pce_delete(vty, name);
+}
+
+DEFPY(pcep_cli_show_srte_pcep_pce,
+ pcep_cli_show_srte_pcep_pce_cmd,
+ "show sr-te pcep pce [WORD$name]",
+ SHOW_STR
+ "SR-TE info\n"
+ "PCEP info\n"
+ "Show detailed pce values\n"
+ "pce name\n")
+{
+ return path_pcep_cli_show_srte_pcep_pce(vty, name);
+}
+
+DEFPY(pcep_cli_peer_sr_draft07,
+ pcep_cli_peer_sr_draft07_cmd,
+ "sr-draft07",
+ "Configure PCC to send PCEP Open with SR draft07\n")
+{
+ return path_pcep_cli_peer_sr_draft07(vty);
+}
+
+DEFPY(pcep_cli_peer_pce_initiated,
+ pcep_cli_peer_pce_initiated_cmd,
+ "pce-initiated",
+ "Configure PCC to accept PCE initiated LSPs\n")
+{
+ return path_pcep_cli_peer_pce_initiated(vty);
+}
+
+DEFPY(pcep_cli_peer_tcp_md5_auth,
+ pcep_cli_peer_tcp_md5_auth_cmd,
+ "tcp-md5-auth WORD",
+ "Configure PCC TCP-MD5 RFC2385 Authentication\n"
+ "TCP-MD5 Authentication string\n")
+{
+ return path_pcep_cli_peer_tcp_md5_auth(vty, tcp_md5_auth);
+}
+
+DEFPY(pcep_cli_peer_address,
+ pcep_cli_peer_address_cmd,
+ "address <ip A.B.C.D | ipv6 X:X::X:X> [port (1024-65535)]",
+ "PCE IP Address configuration, mandatory configuration\n"
+ "PCE IPv4 address\n"
+ "Remote PCE server IPv4 address\n"
+ "PCE IPv6 address\n"
+ "Remote PCE server IPv6 address\n"
+ "Remote PCE server port\n"
+ "Remote PCE server port value\n")
+{
+ return path_pcep_cli_peer_address(vty, ip_str, &ip, ipv6_str, &ipv6,
+ port_str, port);
+}
+
+DEFPY(pcep_cli_peer_source_address,
+ pcep_cli_peer_source_address_cmd,
+ "source-address [ip A.B.C.D | ipv6 X:X::X:X] [port (1024-65535)]",
+ "PCE source IP Address configuration\n"
+ "PCE source IPv4 address\n"
+ "PCE source IPv4 address value\n"
+ "PCE source IPv6 address\n"
+ "PCE source IPv6 address value\n"
+ "Source PCE server port\n"
+ "Source PCE server port value\n")
+{
+ return path_pcep_cli_peer_source_address(vty, ip_str, &ip, ipv6_str,
+ &ipv6, port_str, port);
+}
+
+DEFPY(pcep_cli_peer_pcep_pce_config_ref,
+ pcep_cli_peer_pcep_pce_config_ref_cmd,
+ "config WORD$name",
+ "PCE shared configuration to use\n"
+ "Shared configuration name\n")
+{
+ return path_pcep_cli_peer_pcep_pce_config_ref(vty, name);
+}
+
+DEFPY(pcep_cli_peer_timers,
+ pcep_cli_peer_timers_cmd,
+ "timer [keep-alive (1-63)] [min-peer-keep-alive (1-255)] [max-peer-keep-alive (1-255)] "
+ "[dead-timer (4-255)] [min-peer-dead-timer (4-255)] [max-peer-dead-timer (4-255)] "
+ "[pcep-request (1-120)] [session-timeout-interval (1-120)] [delegation-timeout (1-60)]",
+ "PCE PCEP Session Timers configuration\n"
+ "PCC Keep Alive Timer\n"
+ "PCC Keep Alive Timer value in seconds\n"
+ "Min Acceptable PCE Keep Alive Timer\n"
+ "Min Acceptable PCE Keep Alive Timer value in seconds\n"
+ "Max Acceptable PCE Keep Alive Timer\n"
+ "Max Acceptable PCE Keep Alive Timer value in seconds\n"
+ "PCC Dead Timer\n"
+ "PCC Dead Timer value in seconds\n"
+ "Min Acceptable PCE Dead Timer\n"
+ "Min Acceptable PCE Dead Timer value in seconds\n"
+ "Max Acceptable PCE Dead Timer\n"
+ "Max Acceptable PCE Dead Timer value in seconds\n"
+ "PCC PCEP Request Timer\n"
+ "PCC PCEP Request Timer value in seconds\n"
+ "PCC Session Timeout Interval\n"
+ "PCC Session Timeout Interval value in seconds\n"
+ "Multi-PCE delegation timeout\n"
+ "Multi-PCE delegation timeout value in seconds\n")
+{
+ return path_pcep_cli_peer_timers(
+ vty, keep_alive_str, keep_alive, min_peer_keep_alive_str,
+ min_peer_keep_alive, max_peer_keep_alive_str,
+ max_peer_keep_alive, dead_timer_str, dead_timer,
+ min_peer_dead_timer_str, min_peer_dead_timer,
+ max_peer_dead_timer_str, max_peer_dead_timer, pcep_request_str,
+ pcep_request, session_timeout_interval_str,
+ session_timeout_interval, delegation_timeout_str,
+ delegation_timeout);
+}
+
+DEFPY_NOSH(
+ pcep_cli_pcc,
+ pcep_cli_pcc_cmd,
+ "pcc",
+ "PCC configuration\n")
+{
+ return path_pcep_cli_pcc(vty);
+}
+
+DEFPY(pcep_cli_no_pcc,
+ pcep_cli_no_pcc_cmd,
+ "no pcc",
+ NO_STR
+ "PCC configuration\n")
+{
+ return path_pcep_cli_pcc_delete(vty);
+}
+
+DEFPY(pcep_cli_pcc_pcc_msd,
+ pcep_cli_pcc_pcc_msd_cmd,
+ "msd (1-32)",
+ "PCC maximum SID depth \n"
+ "PCC maximum SID depth value\n")
+{
+ return path_pcep_cli_pcc_pcc_msd(vty, msd_str, msd);
+}
+
+DEFPY(pcep_cli_pcc_pcc_peer,
+ pcep_cli_pcc_pcc_peer_cmd,
+ "[no] peer WORD [precedence (1-255)]",
+ NO_STR
+ "PCC PCE peer\n"
+ "PCC PCE name\n"
+ "PCC Multi-PCE precedence\n"
+ "PCE precedence\n")
+{
+ if (no != NULL) {
+ return path_pcep_cli_pcc_pcc_peer_delete(
+ vty, peer, precedence_str, precedence);
+ } else {
+ return path_pcep_cli_pcc_pcc_peer(vty, peer, precedence_str,
+ precedence);
+ }
+}
+
+DEFPY(pcep_cli_show_srte_pcc,
+ pcep_cli_show_srte_pcc_cmd,
+ "show sr-te pcep pcc",
+ SHOW_STR
+ "SR-TE info\n"
+ "PCEP info\n"
+ "Show current PCC configuration\n")
+{
+ return path_pcep_cli_show_srte_pcep_pcc(vty);
+}
+
+DEFPY(pcep_cli_show_srte_pcep_session,
+ pcep_cli_show_srte_pcep_session_cmd,
+ "show sr-te pcep session [WORD]$pce",
+ SHOW_STR
+ "SR-TE info\n"
+ "PCEP info\n"
+ "Show PCEP Session information\n"
+ "PCE name\n")
+{
+ return path_pcep_cli_show_srte_pcep_session(vty, pce);
+}
+
+DEFPY(pcep_cli_clear_srte_pcep_session,
+ pcep_cli_clear_srte_pcep_session_cmd,
+ "clear sr-te pcep session [WORD]$pce",
+ CLEAR_STR
+ "SR-TE\n"
+ "PCEP\n"
+ "Reset PCEP connection\n"
+ "PCE name\n")
+{
+ return path_pcep_cli_clear_srte_pcep_session(vty, pce);
+}
+
+void pcep_cli_init(void)
+{
+ hook_register(pathd_srte_config_write, pcep_cli_pcep_config_write);
+ hook_register(nb_client_debug_config_write,
+ pcep_cli_debug_config_write);
+ hook_register(nb_client_debug_set_all, pcep_cli_debug_set_all);
+
+ memset(&pce_connections_g, 0, sizeof(pce_connections_g));
+
+ install_node(&pcep_node);
+ install_node(&pcep_pcc_node);
+ install_node(&pcep_pce_node);
+ install_node(&pcep_pce_config_node);
+
+ install_default(PCEP_PCE_CONFIG_NODE);
+ install_default(PCEP_PCE_NODE);
+ install_default(PCEP_PCC_NODE);
+ install_default(PCEP_NODE);
+
+ install_element(SR_TRAFFIC_ENG_NODE, &pcep_cli_pcep_cmd);
+
+ /* PCEP configuration group related configuration commands */
+ install_element(PCEP_NODE, &pcep_cli_pcep_pce_config_cmd);
+ install_element(PCEP_NODE, &pcep_cli_pcep_no_pce_config_cmd);
+ install_element(PCEP_PCE_CONFIG_NODE,
+ &pcep_cli_peer_source_address_cmd);
+ install_element(PCEP_PCE_CONFIG_NODE, &pcep_cli_peer_timers_cmd);
+ install_element(PCEP_PCE_CONFIG_NODE, &pcep_cli_peer_sr_draft07_cmd);
+ install_element(PCEP_PCE_CONFIG_NODE, &pcep_cli_peer_pce_initiated_cmd);
+ install_element(PCEP_PCE_CONFIG_NODE, &pcep_cli_peer_tcp_md5_auth_cmd);
+
+ /* PCE peer related configuration commands */
+ install_element(PCEP_NODE, &pcep_cli_pce_cmd);
+ install_element(PCEP_NODE, &pcep_cli_no_pce_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_address_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_source_address_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_pcep_pce_config_ref_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_timers_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_sr_draft07_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_pce_initiated_cmd);
+ install_element(PCEP_PCE_NODE, &pcep_cli_peer_tcp_md5_auth_cmd);
+
+ /* PCC related configuration commands */
+ install_element(ENABLE_NODE, &pcep_cli_show_srte_pcc_cmd);
+ install_element(PCEP_NODE, &pcep_cli_pcc_cmd);
+ install_element(PCEP_NODE, &pcep_cli_no_pcc_cmd);
+ install_element(PCEP_PCC_NODE, &pcep_cli_pcc_pcc_peer_cmd);
+ install_element(PCEP_PCC_NODE, &pcep_cli_pcc_pcc_msd_cmd);
+
+ /* Top commands */
+ install_element(CONFIG_NODE, &pcep_cli_debug_cmd);
+ install_element(ENABLE_NODE, &pcep_cli_debug_cmd);
+ install_element(ENABLE_NODE, &show_debugging_pathd_pcep_cmd);
+ install_element(ENABLE_NODE, &pcep_cli_show_srte_pcep_counters_cmd);
+ install_element(ENABLE_NODE, &pcep_cli_show_srte_pcep_pce_config_cmd);
+ install_element(ENABLE_NODE, &pcep_cli_show_srte_pcep_pce_cmd);
+ install_element(ENABLE_NODE, &pcep_cli_show_srte_pcep_session_cmd);
+ install_element(ENABLE_NODE, &pcep_cli_clear_srte_pcep_session_cmd);
+}
diff --git a/pathd/path_pcep_cli.h b/pathd/path_pcep_cli.h
new file mode 100644
index 0000000..0b101ab
--- /dev/null
+++ b/pathd/path_pcep_cli.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 Volta Networks, Inc
+ * Brady Johnson
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_CLI_H_
+#define _PATH_PCEP_CLI_H_
+
+
+/* PCEP CLI Functions */
+void pcep_cli_init(void);
+
+#endif // _PATH_PCEP_CLI_H_
diff --git a/pathd/path_pcep_config.c b/pathd/path_pcep_config.c
new file mode 100644
index 0000000..99b1c34
--- /dev/null
+++ b/pathd/path_pcep_config.c
@@ -0,0 +1,546 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include <northbound.h>
+#include <yang.h>
+#include <printfrr.h>
+#include "pceplib/pcep_msg_objects.h"
+#include "pathd/pathd.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_config.h"
+#include "pathd/path_pcep_debug.h"
+#include "thread.h"
+
+#define MAX_XPATH 256
+#define MAX_FLOAT_LEN 22
+#define INETADDR4_MAXLEN 16
+#define INETADDR6_MAXLEN 40
+#define INITIATED_CANDIDATE_PREFERENCE 255
+#define INITIATED_POLICY_COLOR 1
+
+
+static void copy_candidate_objfun_info(struct srte_candidate *candidate,
+ struct path *path);
+static void copy_candidate_affinity_filters(struct srte_candidate *candidate,
+ struct path *path);
+static struct path_hop *
+path_pcep_config_list_path_hops(struct srte_segment_list *segment_list);
+static struct srte_candidate *lookup_candidate(struct lsp_nb_key *key);
+static char *candidate_name(struct srte_candidate *candidate);
+static enum pcep_lsp_operational_status
+status_int_to_ext(enum srte_policy_status status);
+static enum pcep_sr_subobj_nai pcep_nai_type(enum srte_segment_nai_type type);
+static enum srte_segment_nai_type srte_nai_type(enum pcep_sr_subobj_nai type);
+
+void path_pcep_refine_path(struct path *path)
+{
+ struct srte_candidate *candidate = lookup_candidate(&path->nbkey);
+ struct srte_lsp *lsp;
+
+ if (candidate == NULL)
+ return;
+
+ lsp = candidate->lsp;
+
+ if (path->name == NULL)
+ path->name = candidate_name(candidate);
+ if (path->type == SRTE_CANDIDATE_TYPE_UNDEFINED)
+ path->type = candidate->type;
+ if (path->create_origin == SRTE_ORIGIN_UNDEFINED)
+ path->create_origin = candidate->protocol_origin;
+ if ((path->update_origin == SRTE_ORIGIN_UNDEFINED)
+ && (lsp->segment_list != NULL))
+ path->update_origin = lsp->segment_list->protocol_origin;
+}
+
+struct path *path_pcep_config_get_path(struct lsp_nb_key *key)
+{
+ struct srte_candidate *candidate = lookup_candidate(key);
+ if (candidate == NULL)
+ return NULL;
+ return candidate_to_path(candidate);
+}
+
+void path_pcep_config_list_path(path_list_cb_t cb, void *arg)
+{
+ struct path *path;
+ struct srte_policy *policy;
+ struct srte_candidate *candidate;
+
+ RB_FOREACH (policy, srte_policy_head, &srte_policies) {
+ RB_FOREACH (candidate, srte_candidate_head,
+ &policy->candidate_paths) {
+ path = candidate_to_path(candidate);
+ if (!cb(path, arg))
+ return;
+ }
+ }
+}
+
+struct path *candidate_to_path(struct srte_candidate *candidate)
+{
+ char *name;
+ struct path *path;
+ struct path_hop *hop = NULL;
+ struct path_metric *metric = NULL;
+ struct srte_policy *policy;
+ struct srte_lsp *lsp;
+ enum pcep_lsp_operational_status status;
+ enum srte_protocol_origin update_origin = 0;
+ char *originator = NULL;
+
+ policy = candidate->policy;
+ lsp = candidate->lsp;
+
+ if (lsp->segment_list != NULL) {
+ hop = path_pcep_config_list_path_hops(lsp->segment_list);
+ update_origin = lsp->segment_list->protocol_origin;
+ originator = XSTRDUP(MTYPE_PCEP, lsp->segment_list->originator);
+ }
+ path = pcep_new_path();
+ name = candidate_name(candidate);
+ if (CHECK_FLAG(candidate->flags, F_CANDIDATE_BEST)) {
+ status = status_int_to_ext(policy->status);
+ } else {
+ status = PCEP_LSP_OPERATIONAL_DOWN;
+ }
+ for (uint32_t i = 0; i < MAX_METRIC_TYPE; i++) {
+ struct path_metric *path_metric;
+ struct srte_metric *srte_metric = &lsp->metrics[i];
+ if (CHECK_FLAG(srte_metric->flags, F_METRIC_IS_DEFINED)) {
+ path_metric = pcep_new_metric();
+ path_metric->next = metric;
+ metric = path_metric;
+ metric->type = i + 1;
+ metric->value = srte_metric->value;
+ metric->enforce = CHECK_FLAG(srte_metric->flags,
+ F_METRIC_IS_REQUIRED);
+ metric->is_bound = CHECK_FLAG(srte_metric->flags,
+ F_METRIC_IS_BOUND);
+ metric->is_computed = CHECK_FLAG(srte_metric->flags,
+ F_METRIC_IS_COMPUTED);
+ }
+ }
+ *path = (struct path){
+ .nbkey = (struct lsp_nb_key){.color = policy->color,
+ .endpoint = policy->endpoint,
+ .preference =
+ candidate->preference},
+ .create_origin = lsp->protocol_origin,
+ .update_origin = update_origin,
+ .originator = originator,
+ .plsp_id = 0,
+ .name = name,
+ .type = candidate->type,
+ .srp_id = policy->srp_id,
+ .req_id = 0,
+ .binding_sid = policy->binding_sid,
+ .status = status,
+ .do_remove = false,
+ .go_active = false,
+ .was_created = false,
+ .was_removed = false,
+ .is_synching = false,
+ .is_delegated = false,
+ .first_hop = hop,
+ .first_metric = metric};
+
+ path->has_bandwidth = CHECK_FLAG(lsp->flags, F_CANDIDATE_HAS_BANDWIDTH);
+ if (path->has_bandwidth) {
+ path->enforce_bandwidth =
+ CHECK_FLAG(lsp->flags, F_CANDIDATE_REQUIRED_BANDWIDTH);
+ path->bandwidth = lsp->bandwidth;
+ } else {
+ path->enforce_bandwidth = true;
+ path->bandwidth = 0;
+ }
+
+ copy_candidate_objfun_info(candidate, path);
+ copy_candidate_affinity_filters(candidate, path);
+
+ return path;
+}
+
+void copy_candidate_objfun_info(struct srte_candidate *candidate,
+ struct path *path)
+{
+ struct srte_lsp *lsp = candidate->lsp;
+
+ if (lsp != NULL) {
+ if (CHECK_FLAG(lsp->flags, F_CANDIDATE_HAS_OBJFUN)) {
+ path->has_pce_objfun = true;
+ path->pce_objfun = lsp->objfun;
+ } else {
+ path->has_pce_objfun = false;
+ path->pce_objfun = OBJFUN_UNDEFINED;
+ }
+ }
+ if (CHECK_FLAG(candidate->flags, F_CANDIDATE_HAS_OBJFUN)) {
+ path->has_pcc_objfun = true;
+ path->pcc_objfun = candidate->objfun;
+ path->enforce_pcc_objfun = CHECK_FLAG(
+ candidate->flags, F_CANDIDATE_REQUIRED_OBJFUN);
+
+ } else {
+ path->has_pcc_objfun = false;
+ path->pcc_objfun = OBJFUN_UNDEFINED;
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_OBJFUN);
+ }
+}
+
+void copy_candidate_affinity_filters(struct srte_candidate *candidate,
+ struct path *path)
+{
+ bool eany = CHECK_FLAG(candidate->flags, F_CANDIDATE_HAS_EXCLUDE_ANY);
+ bool iany = CHECK_FLAG(candidate->flags, F_CANDIDATE_HAS_INCLUDE_ANY);
+ bool iall = CHECK_FLAG(candidate->flags, F_CANDIDATE_HAS_INCLUDE_ALL);
+ path->has_affinity_filters = eany || iany || iall;
+ path->affinity_filters[AFFINITY_FILTER_EXCLUDE_ANY - 1] =
+ eany ? candidate->affinity_filters[AFFINITY_FILTER_EXCLUDE_ANY
+ - 1]
+ : 0;
+ path->affinity_filters[AFFINITY_FILTER_INCLUDE_ANY - 1] =
+ iany ? candidate->affinity_filters[AFFINITY_FILTER_INCLUDE_ANY
+ - 1]
+ : 0;
+ path->affinity_filters[AFFINITY_FILTER_INCLUDE_ALL - 1] =
+ iall ? candidate->affinity_filters[AFFINITY_FILTER_INCLUDE_ALL
+ - 1]
+ : 0;
+}
+
+struct path_hop *
+path_pcep_config_list_path_hops(struct srte_segment_list *segment_list)
+{
+ struct srte_segment_entry *segment;
+ struct path_hop *hop = NULL, *last_hop = NULL;
+
+ RB_FOREACH_REVERSE (segment, srte_segment_entry_head,
+ &segment_list->segments) {
+ hop = pcep_new_hop();
+ *hop = (struct path_hop){
+ .next = last_hop,
+ .is_loose = false,
+ .has_sid = true,
+ .is_mpls = true,
+ .has_attribs = false,
+ .sid = {.mpls = {.label = segment->sid_value}},
+ .has_nai =
+ segment->nai_type != SRTE_SEGMENT_NAI_TYPE_NONE,
+ .nai = {.type = pcep_nai_type(segment->nai_type)}};
+ switch (segment->nai_type) {
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_NODE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_NODE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_LOCAL_IFACE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ALGORITHM:
+ memcpy(&hop->nai.local_addr, &segment->nai_local_addr,
+ sizeof(struct ipaddr));
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY:
+ memcpy(&hop->nai.local_addr, &segment->nai_local_addr,
+ sizeof(struct ipaddr));
+ memcpy(&hop->nai.remote_addr, &segment->nai_remote_addr,
+ sizeof(struct ipaddr));
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_UNNUMBERED_ADJACENCY:
+ memcpy(&hop->nai.local_addr, &segment->nai_local_addr,
+ sizeof(struct ipaddr));
+ hop->nai.local_iface = segment->nai_local_iface;
+ memcpy(&hop->nai.remote_addr, &segment->nai_remote_addr,
+ sizeof(struct ipaddr));
+ hop->nai.remote_iface = segment->nai_remote_iface;
+ break;
+ default:
+ break;
+ }
+ last_hop = hop;
+ }
+ return hop;
+}
+
+int path_pcep_config_initiate_path(struct path *path)
+{
+ struct srte_policy *policy;
+ struct srte_candidate *candidate;
+
+ if (path->do_remove) {
+ zlog_warn("PCE %s tried to REMOVE pce-initiate a path ",
+ path->originator);
+ candidate = lookup_candidate(&path->nbkey);
+ if (candidate) {
+ if (!path->is_delegated) {
+ zlog_warn(
+ "(%s)PCE tried to REMOVE but it's not Delegated!",
+ __func__);
+ return ERROR_19_1;
+ }
+ if (candidate->type != SRTE_CANDIDATE_TYPE_DYNAMIC) {
+ zlog_warn(
+ "(%s)PCE tried to REMOVE but it's not PCE origin!",
+ __func__);
+ return ERROR_19_9;
+ }
+ zlog_warn(
+ "(%s)PCE tried to REMOVE found candidate!, let's remove",
+ __func__);
+ candidate->policy->srp_id = path->srp_id;
+ SET_FLAG(candidate->policy->flags, F_POLICY_DELETED);
+ SET_FLAG(candidate->flags, F_CANDIDATE_DELETED);
+ } else {
+ zlog_warn("(%s)PCE tried to REMOVE not existing LSP!",
+ __func__);
+ return ERROR_19_3;
+ }
+ srte_apply_changes();
+ } else {
+ assert(!IS_IPADDR_NONE(&path->nbkey.endpoint));
+
+ if (path->nbkey.preference == 0)
+ path->nbkey.preference = INITIATED_CANDIDATE_PREFERENCE;
+
+ if (path->nbkey.color == 0)
+ path->nbkey.color = INITIATED_POLICY_COLOR;
+
+ candidate = lookup_candidate(&path->nbkey);
+ if (!candidate) {
+ policy = srte_policy_add(
+ path->nbkey.color, &path->nbkey.endpoint,
+ SRTE_ORIGIN_PCEP, path->originator);
+ strlcpy(policy->name, path->name, sizeof(policy->name));
+ policy->binding_sid = path->binding_sid;
+ SET_FLAG(policy->flags, F_POLICY_NEW);
+ candidate = srte_candidate_add(
+ policy, path->nbkey.preference,
+ SRTE_ORIGIN_PCEP, path->originator);
+ candidate->policy->srp_id = path->srp_id;
+ strlcpy(candidate->name, path->name,
+ sizeof(candidate->name));
+ SET_FLAG(candidate->flags, F_CANDIDATE_NEW);
+ } else {
+ policy = candidate->policy;
+ if ((path->originator != candidate->originator)
+ || (path->originator != policy->originator)) {
+ /* There is already an initiated path from
+ * another PCE, show a warning and regect the
+ * initiated path */
+ zlog_warn(
+ "PCE %s tried to initiate a path already initiated by PCE %s",
+ path->originator,
+ candidate->originator);
+ return 1;
+ }
+ if ((policy->protocol_origin != SRTE_ORIGIN_PCEP)
+ || (candidate->protocol_origin
+ != SRTE_ORIGIN_PCEP)) {
+ /* There is already an initiated path from
+ * another PCE, show a warning and regect the
+ * initiated path */
+ zlog_warn(
+ "PCE %s tried to initiate a path created localy",
+ path->originator);
+ return 1;
+ }
+ }
+ return path_pcep_config_update_path(path);
+ }
+ return 0;
+}
+
+int path_pcep_config_update_path(struct path *path)
+{
+ assert(path != NULL);
+ assert(path->nbkey.preference != 0);
+ assert(path->nbkey.endpoint.ipa_type == IPADDR_V4);
+
+ int number_of_sid_clashed = 0;
+ struct path_hop *hop;
+ struct path_metric *metric;
+ int index;
+ char segment_list_name_buff[64 + 1 + 64 + 1 + 11 + 1];
+ char *segment_list_name = NULL;
+ struct srte_candidate *candidate;
+ struct srte_segment_list *segment_list = NULL;
+ struct srte_segment_entry *segment;
+
+ candidate = lookup_candidate(&path->nbkey);
+
+ // if there is no candidate to update we are done
+ if (!candidate)
+ return 0;
+
+ candidate->policy->srp_id = path->srp_id;
+ // first clean up old segment list if present
+ if (candidate->lsp->segment_list) {
+ SET_FLAG(candidate->lsp->segment_list->flags,
+ F_SEGMENT_LIST_DELETED);
+ srte_segment_list_del(candidate->lsp->segment_list);
+ candidate->lsp->segment_list = NULL;
+ }
+
+ if (path->first_hop == NULL)
+ return PATH_NB_ERR;
+
+ snprintf(segment_list_name_buff, sizeof(segment_list_name_buff),
+ "%s-%u", path->name, path->plsp_id);
+ segment_list_name = segment_list_name_buff;
+
+ segment_list = srte_segment_list_add(segment_list_name);
+ segment_list->protocol_origin = path->update_origin;
+ strlcpy(segment_list->originator, path->originator,
+ sizeof(segment_list->originator));
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_NEW);
+ SET_FLAG(segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ for (hop = path->first_hop, index = 10; hop != NULL;
+ hop = hop->next, index += 10) {
+ assert(hop->has_sid);
+ assert(hop->is_mpls);
+
+ segment = srte_segment_entry_add(segment_list, index);
+
+ segment->sid_value = (mpls_label_t)hop->sid.mpls.label;
+ SET_FLAG(segment->segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+
+ if (!hop->has_nai)
+ continue;
+ if (srte_segment_entry_set_nai(
+ segment, srte_nai_type(hop->nai.type),
+ &hop->nai.local_addr, hop->nai.local_iface,
+ &hop->nai.remote_addr, hop->nai.remote_iface, 0, 0)
+ == PATH_SID_ERROR)
+ /* TED queries don't match PCE */
+ /* Don't apply srte,zebra changes */
+ number_of_sid_clashed++;
+ }
+
+ candidate->lsp->segment_list = segment_list;
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+
+ for (metric = path->first_metric; metric != NULL; metric = metric->next)
+ srte_lsp_set_metric(
+ candidate->lsp,
+ (enum srte_candidate_metric_type)metric->type,
+ metric->value, metric->enforce, metric->is_bound,
+ metric->is_computed);
+
+ if (path->has_bandwidth)
+ srte_lsp_set_bandwidth(candidate->lsp, path->bandwidth,
+ path->enforce_bandwidth);
+
+ if (path->has_pce_objfun) {
+ SET_FLAG(candidate->lsp->flags, F_CANDIDATE_HAS_OBJFUN);
+ candidate->lsp->objfun = path->pce_objfun;
+ }
+
+ if (number_of_sid_clashed)
+ SET_FLAG(segment->segment_list->flags,
+ F_SEGMENT_LIST_SID_CONFLICT);
+ else
+ srte_apply_changes();
+
+ return 0;
+}
+
+struct srte_candidate *lookup_candidate(struct lsp_nb_key *key)
+{
+ struct srte_policy *policy = NULL;
+ policy = srte_policy_find(key->color, &key->endpoint);
+ if (policy == NULL)
+ return NULL;
+ return srte_candidate_find(policy, key->preference);
+}
+
+char *candidate_name(struct srte_candidate *candidate)
+{
+ if (candidate->protocol_origin == SRTE_ORIGIN_PCEP
+ || candidate->protocol_origin == SRTE_ORIGIN_BGP)
+ return asprintfrr(MTYPE_PCEP, "%s", candidate->policy->name);
+ else
+ return asprintfrr(MTYPE_PCEP, "%s-%s", candidate->policy->name,
+ candidate->name);
+}
+
+enum pcep_lsp_operational_status
+status_int_to_ext(enum srte_policy_status status)
+{
+ switch (status) {
+ case SRTE_POLICY_STATUS_UP:
+ return PCEP_LSP_OPERATIONAL_ACTIVE;
+ case SRTE_POLICY_STATUS_GOING_UP:
+ return PCEP_LSP_OPERATIONAL_GOING_UP;
+ case SRTE_POLICY_STATUS_GOING_DOWN:
+ return PCEP_LSP_OPERATIONAL_GOING_DOWN;
+ default:
+ return PCEP_LSP_OPERATIONAL_DOWN;
+ }
+}
+
+enum pcep_sr_subobj_nai pcep_nai_type(enum srte_segment_nai_type type)
+{
+ switch (type) {
+ case SRTE_SEGMENT_NAI_TYPE_NONE:
+ return PCEP_SR_SUBOBJ_NAI_ABSENT;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_NODE:
+ return PCEP_SR_SUBOBJ_NAI_IPV4_NODE;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_NODE:
+ return PCEP_SR_SUBOBJ_NAI_IPV6_NODE;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY:
+ return PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY:
+ return PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_UNNUMBERED_ADJACENCY:
+ return PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY_LINK_LOCAL_ADDRESSES:
+ return PCEP_SR_SUBOBJ_NAI_LINK_LOCAL_IPV6_ADJACENCY;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE:
+ return PCEP_SR_SUBOBJ_NAI_IPV4_NODE;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_LOCAL_IFACE:
+ return PCEP_SR_SUBOBJ_NAI_IPV6_NODE;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM:
+ return PCEP_SR_SUBOBJ_NAI_IPV4_NODE;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ALGORITHM:
+ return PCEP_SR_SUBOBJ_NAI_IPV6_NODE;
+ default:
+ return PCEP_SR_SUBOBJ_NAI_UNKNOWN;
+ }
+}
+
+enum srte_segment_nai_type srte_nai_type(enum pcep_sr_subobj_nai type)
+{
+ switch (type) {
+ case PCEP_SR_SUBOBJ_NAI_ABSENT:
+ return SRTE_SEGMENT_NAI_TYPE_NONE;
+ case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
+ return SRTE_SEGMENT_NAI_TYPE_IPV4_NODE;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
+ return SRTE_SEGMENT_NAI_TYPE_IPV6_NODE;
+ case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
+ return SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
+ return SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY;
+ case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
+ return SRTE_SEGMENT_NAI_TYPE_IPV4_UNNUMBERED_ADJACENCY;
+ default:
+ return SRTE_SEGMENT_NAI_TYPE_NONE;
+ }
+}
diff --git a/pathd/path_pcep_config.h b/pathd/path_pcep_config.h
new file mode 100644
index 0000000..e56d497
--- /dev/null
+++ b/pathd/path_pcep_config.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_CONFIG_H_
+#define _PATH_PCEP_CONFIG_H_
+
+#include <stdbool.h>
+#include <debug.h>
+
+#include "pathd/path_pcep.h"
+
+#define PATH_NB_NO_CHANGE 0
+#define PATH_NB_OK 1
+#define PATH_NB_ERR -1
+
+typedef int (*path_list_cb_t)(struct path *path, void *arg);
+
+/* Lookup the candidate path and fill up the missing path attributes like name
+ * and type. Used for path generated from PCEP message received from the PCE
+ * so they contains more information about the candidate path. If no matching
+ * policy or candidate path is found, nothing is changed.
+ * MUST BE CALLED FROM THE MAIN THREAD */
+void path_pcep_refine_path(struct path *path);
+struct path *path_pcep_config_get_path(struct lsp_nb_key *key);
+void path_pcep_config_list_path(path_list_cb_t cb, void *arg);
+int path_pcep_config_initiate_path(struct path *path);
+int path_pcep_config_update_path(struct path *path);
+struct path *candidate_to_path(struct srte_candidate *candidate);
+
+
+#endif // _PATH_PCEP_CONFIG_H_
diff --git a/pathd/path_pcep_controller.c b/pathd/path_pcep_controller.c
new file mode 100644
index 0000000..b9f2ba3
--- /dev/null
+++ b/pathd/path_pcep_controller.c
@@ -0,0 +1,1092 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "log.h"
+#include "command.h"
+#include "libfrr.h"
+#include "printfrr.h"
+#include "lib/version.h"
+#include "northbound.h"
+#include "frr_pthread.h"
+#include "jhash.h"
+#include "network.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_errors.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_controller.h"
+#include "pathd/path_pcep_pcc.h"
+#include "pathd/path_pcep_config.h"
+#include "pathd/path_pcep_debug.h"
+
+#define MAX_RECONNECT_DELAY 120
+
+/* Event handling data structures */
+enum pcep_ctrl_event_type {
+ EV_UPDATE_PCC_OPTS = 1,
+ EV_UPDATE_PCE_OPTS,
+ EV_REMOVE_PCC,
+ EV_PATHD_EVENT,
+ EV_SYNC_PATH,
+ EV_SYNC_DONE,
+ EV_PCEPLIB_EVENT,
+ EV_RESET_PCC_SESSION,
+ EV_SEND_REPORT,
+ EV_SEND_ERROR,
+ EV_PATH_REFINED
+};
+
+struct pcep_ctrl_event_data {
+ struct ctrl_state *ctrl_state;
+ enum pcep_ctrl_event_type type;
+ uint32_t sub_type;
+ int pcc_id;
+ void *payload;
+};
+
+struct pcep_main_event_data {
+ pcep_main_event_handler_t handler;
+ int pcc_id;
+ enum pcep_main_event_type type;
+ void *payload;
+};
+
+struct pcep_refine_path_event_data {
+ struct ctrl_state *ctrl_state;
+ int pcc_id;
+ pcep_refine_callback_t continue_lsp_update_handler;
+ struct path *path;
+ void *payload;
+};
+
+/* Synchronous call arguments */
+
+struct get_counters_args {
+ struct ctrl_state *ctrl_state;
+ int pcc_id;
+ struct counters_group *counters;
+};
+
+struct get_pcep_session_args {
+ struct ctrl_state *ctrl_state;
+ int pcc_id;
+ pcep_session *pcep_session;
+};
+
+/* Internal Functions Called From Main Thread */
+static int pcep_ctrl_halt_cb(struct frr_pthread *fpt, void **res);
+static void pcep_refine_path_event_cb(struct thread *thread);
+
+/* Internal Functions Called From Controller Thread */
+static void pcep_thread_finish_event_handler(struct thread *thread);
+
+/* Controller Thread Timer Handler */
+static int schedule_thread_timer(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_timer_type timer_type,
+ enum pcep_ctrl_timeout_type timeout_type,
+ uint32_t delay, void *payload,
+ struct thread **thread);
+static int schedule_thread_timer_with_cb(
+ struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_timer_type timer_type,
+ enum pcep_ctrl_timeout_type timeout_type, uint32_t delay, void *payload,
+ struct thread **thread, pcep_ctrl_thread_callback timer_cb);
+static void pcep_thread_timer_handler(struct thread *thread);
+
+/* Controller Thread Socket read/write Handler */
+static int schedule_thread_socket(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_socket_type type, bool is_read,
+ void *payload, int fd, struct thread **thread,
+ pcep_ctrl_thread_callback cb);
+
+/* Controller Thread Event Handler */
+static int send_to_thread(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_event_type type, uint32_t sub_type,
+ void *payload);
+static int send_to_thread_with_cb(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_event_type type,
+ uint32_t sub_type, void *payload,
+ pcep_ctrl_thread_callback event_cb);
+static void pcep_thread_event_handler(struct thread *thread);
+static int pcep_thread_event_update_pcc_options(struct ctrl_state *ctrl_state,
+ struct pcc_opts *opts);
+static int pcep_thread_event_update_pce_options(struct ctrl_state *ctrl_state,
+ int pcc_id,
+ struct pce_opts *opts);
+static int pcep_thread_event_remove_pcc_by_id(struct ctrl_state *ctrl_state,
+ int pcc_id);
+static int pcep_thread_event_remove_pcc_all(struct ctrl_state *ctrl_state);
+static int pcep_thread_event_remove_pcc(struct ctrl_state *ctrl_state,
+ struct pce_opts *pce_opts);
+static int pcep_thread_event_sync_path(struct ctrl_state *ctrl_state,
+ int pcc_id, struct path *path);
+static int pcep_thread_event_sync_done(struct ctrl_state *ctrl_state,
+ int pcc_id);
+static int pcep_thread_event_pathd_event(struct ctrl_state *ctrl_state,
+ enum pcep_pathd_event_type type,
+ struct path *path);
+static void
+pcep_thread_path_refined_event(struct ctrl_state *ctrl_state,
+ struct pcep_refine_path_event_data *data);
+
+/* Main Thread Event Handler */
+static int send_to_main(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_main_event_type type, void *payload);
+static void pcep_main_event_handler(struct thread *thread);
+
+/* Helper functions */
+static void set_ctrl_state(struct frr_pthread *fpt,
+ struct ctrl_state *ctrl_state);
+static struct ctrl_state *get_ctrl_state(struct frr_pthread *fpt);
+int get_next_id(struct ctrl_state *ctrl_state);
+int set_pcc_state(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state);
+void remove_pcc_state(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+static uint32_t backoff_delay(uint32_t max, uint32_t base, uint32_t attempt);
+static const char *timer_type_name(enum pcep_ctrl_timer_type type);
+static const char *timeout_type_name(enum pcep_ctrl_timeout_type type);
+
+
+/* ------------ API Functions Called from Main Thread ------------ */
+
+int pcep_ctrl_initialize(struct thread_master *main_thread,
+ struct frr_pthread **fpt,
+ pcep_main_event_handler_t event_handler)
+{
+ assert(fpt != NULL);
+
+ int ret = 0;
+ struct ctrl_state *ctrl_state;
+ struct frr_pthread_attr attr = {
+ .start = frr_pthread_attr_default.start,
+ .stop = pcep_ctrl_halt_cb,
+ };
+
+ PCEP_DEBUG("Initializing pcep module controller");
+
+ /* Create and start the FRR pthread */
+ *fpt = frr_pthread_new(&attr, "PCEP thread", "pcep_controller");
+ if (*fpt == NULL) {
+ flog_err(EC_PATH_SYSTEM_CALL,
+ "failed to initialize PCEP thread");
+ return 1;
+ }
+ ret = frr_pthread_run(*fpt, NULL);
+ if (ret < 0) {
+ flog_err(EC_PATH_SYSTEM_CALL, "failed to create PCEP thread");
+ return ret;
+ }
+ frr_pthread_wait_running(*fpt);
+
+ /* Initialize the thread state */
+ ctrl_state = XCALLOC(MTYPE_PCEP, sizeof(*ctrl_state));
+ ctrl_state->main = main_thread;
+ ctrl_state->self = (*fpt)->master;
+ ctrl_state->main_event_handler = event_handler;
+ ctrl_state->pcc_count = 0;
+ ctrl_state->pcc_last_id = 0;
+ ctrl_state->pcc_opts =
+ XCALLOC(MTYPE_PCEP, sizeof(*ctrl_state->pcc_opts));
+ /* Default to no PCC address defined */
+ ctrl_state->pcc_opts->addr.ipa_type = IPADDR_NONE;
+ ctrl_state->pcc_opts->port = PCEP_DEFAULT_PORT;
+
+ /* Keep the state reference for events */
+ set_ctrl_state(*fpt, ctrl_state);
+
+ return ret;
+}
+
+int pcep_ctrl_finalize(struct frr_pthread **fpt)
+{
+ assert(fpt != NULL);
+
+ int ret = 0;
+
+ PCEP_DEBUG("Finalizing pcep module controller");
+
+ if (*fpt != NULL) {
+ frr_pthread_stop(*fpt, NULL);
+ *fpt = NULL;
+ }
+
+ return ret;
+}
+
+int pcep_ctrl_update_pcc_options(struct frr_pthread *fpt, struct pcc_opts *opts)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, 0, EV_UPDATE_PCC_OPTS, 0, opts);
+}
+
+int pcep_ctrl_update_pce_options(struct frr_pthread *fpt, struct pce_opts *opts)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, 0, EV_UPDATE_PCE_OPTS, 0, opts);
+}
+
+int pcep_ctrl_remove_pcc(struct frr_pthread *fpt, struct pce_opts *pce_opts)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, 0, EV_REMOVE_PCC, 0, pce_opts);
+}
+
+int pcep_ctrl_reset_pcc_session(struct frr_pthread *fpt, char *pce_name)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, 0, EV_RESET_PCC_SESSION, 0, pce_name);
+}
+
+int pcep_ctrl_pathd_event(struct frr_pthread *fpt,
+ enum pcep_pathd_event_type type, struct path *path)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, 0, EV_PATHD_EVENT, type, path);
+}
+
+int pcep_ctrl_sync_path(struct frr_pthread *fpt, int pcc_id, struct path *path)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, pcc_id, EV_SYNC_PATH, 0, path);
+}
+
+int pcep_ctrl_sync_done(struct frr_pthread *fpt, int pcc_id)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, pcc_id, EV_SYNC_DONE, 0, NULL);
+}
+
+struct counters_group *pcep_ctrl_get_counters(struct frr_pthread *fpt,
+ int pcc_id)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ struct counters_group *counters = NULL;
+ struct pcc_state *pcc_state;
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ if (pcc_state) {
+ counters = pcep_lib_copy_counters(pcc_state->sess);
+ }
+ return counters;
+}
+
+pcep_session *pcep_ctrl_get_pcep_session(struct frr_pthread *fpt, int pcc_id)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ struct pcc_state *pcc_state;
+ pcep_session *session = NULL;
+
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ if (pcc_state) {
+ session = pcep_lib_copy_pcep_session(pcc_state->sess);
+ }
+ return session;
+}
+
+struct pcep_pcc_info *pcep_ctrl_get_pcc_info(struct frr_pthread *fpt,
+ const char *pce_name)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ struct pcep_pcc_info *pcc_info = XCALLOC(MTYPE_PCEP, sizeof(*pcc_info));
+ if( pcc_info && ctrl_state){
+ strlcpy(pcc_info->pce_name, pce_name, sizeof(pcc_info->pce_name));
+ pcep_pcc_copy_pcc_info(ctrl_state->pcc, pcc_info);
+ }
+
+ return pcc_info;
+}
+
+int pcep_ctrl_send_report(struct frr_pthread *fpt, int pcc_id,
+ struct path *path, bool is_stable)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, pcc_id, EV_SEND_REPORT, is_stable,
+ path);
+}
+
+
+int pcep_ctrl_send_error(struct frr_pthread *fpt, int pcc_id,
+ struct pcep_error *error)
+{
+ struct ctrl_state *ctrl_state = get_ctrl_state(fpt);
+ return send_to_thread(ctrl_state, pcc_id, EV_SEND_ERROR, 0, error);
+}
+
+
+/* ------------ Internal Functions Called from Main Thread ------------ */
+
+int pcep_ctrl_halt_cb(struct frr_pthread *fpt, void **res)
+{
+ thread_add_event(fpt->master, pcep_thread_finish_event_handler,
+ (void *)fpt, 0, NULL);
+ pthread_join(fpt->thread, res);
+
+ return 0;
+}
+
+void pcep_refine_path_event_cb(struct thread *thread)
+{
+ struct pcep_refine_path_event_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+ struct ctrl_state *ctrl_state = data->ctrl_state;
+ struct path *path = data->path;
+ assert(path != NULL);
+ int pcc_id = data->pcc_id;
+
+
+ path_pcep_refine_path(path);
+ send_to_thread(ctrl_state, pcc_id, EV_PATH_REFINED, 0, data);
+}
+
+
+/* ------------ API Functions Called From Controller Thread ------------ */
+
+void pcep_thread_start_sync(struct ctrl_state *ctrl_state, int pcc_id)
+{
+ send_to_main(ctrl_state, pcc_id, PCEP_MAIN_EVENT_START_SYNC, NULL);
+}
+
+void pcep_thread_update_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct path *path)
+{
+ send_to_main(ctrl_state, pcc_id, PCEP_MAIN_EVENT_UPDATE_CANDIDATE,
+ path);
+}
+
+void pcep_thread_initiate_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct path *path)
+{
+ send_to_main(ctrl_state, pcc_id, PCEP_MAIN_EVENT_INITIATE_CANDIDATE,
+ path);
+}
+
+void pcep_thread_remove_candidate_path_segments(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ if (!pcc_state)
+ return;
+ /* Will be deleted when the event is handled */
+ char *originator = XSTRDUP(MTYPE_PCEP, pcc_state->originator);
+ PCEP_DEBUG("schedule candidate path segments removal for originator %s",
+ originator);
+ send_to_main(ctrl_state, pcep_pcc_get_pcc_id(pcc_state),
+ PCEP_MAIN_EVENT_REMOVE_CANDIDATE_LSP, originator);
+}
+
+void pcep_thread_schedule_sync_best_pce(struct ctrl_state *ctrl_state,
+ int pcc_id, int delay,
+ struct thread **thread)
+{
+
+ schedule_thread_timer(ctrl_state, pcc_id, TM_CALCULATE_BEST_PCE,
+ TO_UNDEFINED, delay, NULL, thread);
+}
+
+void pcep_thread_cancel_timer(struct thread **thread)
+{
+ if (thread == NULL || *thread == NULL) {
+ return;
+ }
+
+ struct pcep_ctrl_timer_data *data = THREAD_ARG(*thread);
+ PCEP_DEBUG("Timer %s / %s canceled", timer_type_name(data->timer_type),
+ timeout_type_name(data->timeout_type));
+ if (data != NULL) {
+ XFREE(MTYPE_PCEP, data);
+ }
+
+ if ((*thread)->master->owner == pthread_self()) {
+ thread_cancel(thread);
+ } else {
+ thread_cancel_async((*thread)->master, thread, NULL);
+ }
+}
+
+void pcep_thread_schedule_reconnect(struct ctrl_state *ctrl_state, int pcc_id,
+ int retry_count, struct thread **thread)
+{
+ uint32_t delay = backoff_delay(MAX_RECONNECT_DELAY, 1, retry_count);
+ PCEP_DEBUG("Schedule RECONNECT_PCC for %us (retry %u)", delay,
+ retry_count);
+ schedule_thread_timer(ctrl_state, pcc_id, TM_RECONNECT_PCC,
+ TO_UNDEFINED, delay, NULL, thread);
+}
+
+void pcep_thread_schedule_timeout(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_timeout_type timeout_type,
+ uint32_t delay, void *param,
+ struct thread **thread)
+{
+ assert(timeout_type > TO_UNDEFINED);
+ assert(timeout_type < TO_MAX);
+ PCEP_DEBUG("Schedule timeout %s for %us",
+ timeout_type_name(timeout_type), delay);
+ schedule_thread_timer(ctrl_state, pcc_id, TM_TIMEOUT, timeout_type,
+ delay, param, thread);
+}
+
+void pcep_thread_schedule_pceplib_timer(struct ctrl_state *ctrl_state,
+ int delay, void *payload,
+ struct thread **thread,
+ pcep_ctrl_thread_callback timer_cb)
+{
+ PCEP_DEBUG("Schedule PCEPLIB_TIMER for %us", delay);
+ schedule_thread_timer_with_cb(ctrl_state, 0, TM_PCEPLIB_TIMER,
+ TO_UNDEFINED, delay, payload, thread,
+ timer_cb);
+}
+
+void pcep_thread_schedule_session_timeout(struct ctrl_state *ctrl_state,
+ int pcc_id, int delay,
+ struct thread **thread)
+{
+ PCEP_DEBUG("Schedule session_timeout interval for %us", delay);
+ schedule_thread_timer(ctrl_state, pcc_id, TM_SESSION_TIMEOUT_PCC,
+ TO_UNDEFINED, delay, NULL, thread);
+}
+
+int pcep_thread_pcc_count(struct ctrl_state *ctrl_state)
+{
+ if (ctrl_state == NULL) {
+ return 0;
+ }
+
+ return ctrl_state->pcc_count;
+}
+
+int pcep_thread_refine_path(struct ctrl_state *ctrl_state, int pcc_id,
+ pcep_refine_callback_t cb, struct path *path,
+ void *payload)
+{
+ struct pcep_refine_path_event_data *data;
+
+ data = XCALLOC(MTYPE_PCEP, sizeof(*data));
+ data->ctrl_state = ctrl_state;
+ data->path = path;
+ data->pcc_id = pcc_id;
+ data->continue_lsp_update_handler = cb;
+ data->payload = payload;
+
+ thread_add_event(ctrl_state->main, pcep_refine_path_event_cb,
+ (void *)data, 0, NULL);
+ return 0;
+}
+
+void pcep_thread_path_refined_event(struct ctrl_state *ctrl_state,
+ struct pcep_refine_path_event_data *data)
+{
+ assert(data != NULL);
+ int pcc_id = data->pcc_id;
+ pcep_refine_callback_t continue_lsp_update_handler = data->continue_lsp_update_handler;
+ assert(continue_lsp_update_handler != NULL);
+ struct path *path = data->path;
+ void *payload = data->payload;
+ struct pcc_state *pcc_state = NULL;
+ XFREE(MTYPE_PCEP, data);
+
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ continue_lsp_update_handler(ctrl_state, pcc_state, path, payload);
+}
+
+
+/* ------------ Internal Functions Called From Controller Thread ------------ */
+
+void pcep_thread_finish_event_handler(struct thread *thread)
+{
+ int i;
+ struct frr_pthread *fpt = THREAD_ARG(thread);
+ struct ctrl_state *ctrl_state = fpt->data;
+
+ assert(ctrl_state != NULL);
+
+ for (i = 0; i < MAX_PCC; i++) {
+ if (ctrl_state->pcc[i]) {
+ pcep_pcc_finalize(ctrl_state, ctrl_state->pcc[i]);
+ ctrl_state->pcc[i] = NULL;
+ }
+ }
+
+ XFREE(MTYPE_PCEP, ctrl_state->pcc_opts);
+ XFREE(MTYPE_PCEP, ctrl_state);
+ fpt->data = NULL;
+
+ atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
+}
+
+/* ------------ Controller Thread Timer Handler ------------ */
+
+int schedule_thread_timer_with_cb(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_timer_type timer_type,
+ enum pcep_ctrl_timeout_type timeout_type,
+ uint32_t delay, void *payload,
+ struct thread **thread,
+ pcep_ctrl_thread_callback timer_cb)
+{
+ assert(thread != NULL);
+
+ struct pcep_ctrl_timer_data *data;
+
+ data = XCALLOC(MTYPE_PCEP, sizeof(*data));
+ data->ctrl_state = ctrl_state;
+ data->timer_type = timer_type;
+ data->timeout_type = timeout_type;
+ data->pcc_id = pcc_id;
+ data->payload = payload;
+
+ thread_add_timer(ctrl_state->self, timer_cb, (void *)data, delay,
+ thread);
+
+ return 0;
+}
+
+int schedule_thread_timer(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_timer_type timer_type,
+ enum pcep_ctrl_timeout_type timeout_type,
+ uint32_t delay, void *payload, struct thread **thread)
+{
+ return schedule_thread_timer_with_cb(ctrl_state, pcc_id, timer_type,
+ timeout_type, delay, payload,
+ thread, pcep_thread_timer_handler);
+}
+
+void pcep_thread_timer_handler(struct thread *thread)
+{
+ /* data unpacking */
+ struct pcep_ctrl_timer_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+ struct ctrl_state *ctrl_state = data->ctrl_state;
+ assert(ctrl_state != NULL);
+ enum pcep_ctrl_timer_type timer_type = data->timer_type;
+ enum pcep_ctrl_timeout_type timeout_type = data->timeout_type;
+ int pcc_id = data->pcc_id;
+ void *param = data->payload;
+ XFREE(MTYPE_PCEP, data);
+
+ struct pcc_state *pcc_state = NULL;
+
+ switch (timer_type) {
+ case TM_RECONNECT_PCC:
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ if (!pcc_state)
+ return;
+ pcep_pcc_reconnect(ctrl_state, pcc_state);
+ break;
+ case TM_TIMEOUT:
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ if (!pcc_state)
+ return;
+ pcep_pcc_timeout_handler(ctrl_state, pcc_state, timeout_type,
+ param);
+ break;
+ case TM_CALCULATE_BEST_PCE:
+ /* Previous best disconnect so new best should be synced */
+ pcep_pcc_timer_update_best_pce(ctrl_state, pcc_id);
+ break;
+ case TM_SESSION_TIMEOUT_PCC:
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ pcep_thread_remove_candidate_path_segments(ctrl_state,
+ pcc_state);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ "Unknown controller timer triggered: %u", timer_type);
+ break;
+ }
+}
+
+void pcep_thread_pcep_event(struct thread *thread)
+{
+ struct pcep_ctrl_event_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+ struct ctrl_state *ctrl_state = data->ctrl_state;
+ pcep_event *event = data->payload;
+ XFREE(MTYPE_PCEP, data);
+ int i;
+
+ for (i = 0; i < MAX_PCC; i++) {
+ if (ctrl_state->pcc[i]) {
+ struct pcc_state *pcc_state = ctrl_state->pcc[i];
+ if (pcc_state->sess != event->session)
+ continue;
+ pcep_pcc_pcep_event_handler(ctrl_state, pcc_state,
+ event);
+ break;
+ }
+ }
+ destroy_pcep_event(event);
+}
+
+/* ------------ Controller Thread Socket Functions ------------ */
+
+int schedule_thread_socket(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_socket_type type, bool is_read,
+ void *payload, int fd, struct thread **thread,
+ pcep_ctrl_thread_callback socket_cb)
+{
+ assert(thread != NULL);
+
+ struct pcep_ctrl_socket_data *data;
+
+ data = XCALLOC(MTYPE_PCEP, sizeof(*data));
+ data->ctrl_state = ctrl_state;
+ data->type = type;
+ data->is_read = is_read;
+ data->fd = fd;
+ data->pcc_id = pcc_id;
+ data->payload = payload;
+
+ if (is_read) {
+ thread_add_read(ctrl_state->self, socket_cb, (void *)data, fd,
+ thread);
+ } else {
+ thread_add_write(ctrl_state->self, socket_cb, (void *)data, fd,
+ thread);
+ }
+
+ return 0;
+}
+
+int pcep_thread_socket_write(void *fpt, void **thread, int fd, void *payload,
+ pcep_ctrl_thread_callback socket_cb)
+{
+ struct ctrl_state *ctrl_state = ((struct frr_pthread *)fpt)->data;
+
+ return schedule_thread_socket(ctrl_state, 0, SOCK_PCEPLIB, false,
+ payload, fd, (struct thread **)thread,
+ socket_cb);
+}
+
+int pcep_thread_socket_read(void *fpt, void **thread, int fd, void *payload,
+ pcep_ctrl_thread_callback socket_cb)
+{
+ struct ctrl_state *ctrl_state = ((struct frr_pthread *)fpt)->data;
+
+ return schedule_thread_socket(ctrl_state, 0, SOCK_PCEPLIB, true,
+ payload, fd, (struct thread **)thread,
+ socket_cb);
+}
+
+int pcep_thread_send_ctrl_event(void *fpt, void *payload,
+ pcep_ctrl_thread_callback cb)
+{
+ struct ctrl_state *ctrl_state = ((struct frr_pthread *)fpt)->data;
+
+ return send_to_thread_with_cb(ctrl_state, 0, EV_PCEPLIB_EVENT, 0,
+ payload, cb);
+}
+
+/* ------------ Controller Thread Event Handler ------------ */
+
+int send_to_thread(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_event_type type, uint32_t sub_type,
+ void *payload)
+{
+ return send_to_thread_with_cb(ctrl_state, pcc_id, type, sub_type,
+ payload, pcep_thread_event_handler);
+}
+
+int send_to_thread_with_cb(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_event_type type, uint32_t sub_type,
+ void *payload, pcep_ctrl_thread_callback event_cb)
+{
+ struct pcep_ctrl_event_data *data;
+
+ data = XCALLOC(MTYPE_PCEP, sizeof(*data));
+ data->ctrl_state = ctrl_state;
+ data->type = type;
+ data->sub_type = sub_type;
+ data->pcc_id = pcc_id;
+ data->payload = payload;
+
+ thread_add_event(ctrl_state->self, event_cb, (void *)data, 0, NULL);
+
+ return 0;
+}
+
+void pcep_thread_event_handler(struct thread *thread)
+{
+ /* data unpacking */
+ struct pcep_ctrl_event_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+ struct ctrl_state *ctrl_state = data->ctrl_state;
+ assert(ctrl_state != NULL);
+ enum pcep_ctrl_event_type type = data->type;
+ uint32_t sub_type = data->sub_type;
+ int pcc_id = data->pcc_id;
+ void *payload = data->payload;
+ XFREE(MTYPE_PCEP, data);
+
+ /* Possible sub-type values */
+ enum pcep_pathd_event_type path_event_type = PCEP_PATH_UNDEFINED;
+
+ /* Possible payload values, maybe an union would be better... */
+ struct path *path = NULL;
+ struct pcc_opts *pcc_opts = NULL;
+ struct pce_opts *pce_opts = NULL;
+ struct pcc_state *pcc_state = NULL;
+ struct pcep_refine_path_event_data *refine_data = NULL;
+
+ struct path *path_copy = NULL;
+ struct pcep_error *error = NULL;
+
+ switch (type) {
+ case EV_UPDATE_PCC_OPTS:
+ assert(payload != NULL);
+ pcc_opts = (struct pcc_opts *)payload;
+ pcep_thread_event_update_pcc_options(ctrl_state, pcc_opts);
+ break;
+ case EV_UPDATE_PCE_OPTS:
+ assert(payload != NULL);
+ pce_opts = (struct pce_opts *)payload;
+ pcep_thread_event_update_pce_options(ctrl_state, pcc_id,
+ pce_opts);
+ break;
+ case EV_REMOVE_PCC:
+ pce_opts = (struct pce_opts *)payload;
+ if (pcep_thread_event_remove_pcc(ctrl_state, pce_opts) == 0)
+ pcep_pcc_multi_pce_remove_pcc(ctrl_state,
+ ctrl_state->pcc);
+ break;
+ case EV_PATHD_EVENT:
+ assert(payload != NULL);
+ path_event_type = (enum pcep_pathd_event_type)sub_type;
+ path = (struct path *)payload;
+ pcep_thread_event_pathd_event(ctrl_state, path_event_type,
+ path);
+ break;
+ case EV_SYNC_PATH:
+ assert(payload != NULL);
+ path = (struct path *)payload;
+ pcep_pcc_multi_pce_sync_path(ctrl_state, pcc_id,
+ ctrl_state->pcc);
+ pcep_thread_event_sync_path(ctrl_state, pcc_id, path);
+ break;
+ case EV_SYNC_DONE:
+ pcep_thread_event_sync_done(ctrl_state, pcc_id);
+ break;
+ case EV_RESET_PCC_SESSION:
+ pcc_state = pcep_pcc_get_pcc_by_name(ctrl_state->pcc,
+ (const char *)payload);
+ if (pcc_state) {
+ pcep_pcc_disable(ctrl_state, pcc_state);
+ pcep_pcc_enable(ctrl_state, pcc_state);
+ } else {
+ flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ "Cannot reset state for PCE: %s",
+ (const char *)payload);
+ }
+ break;
+ case EV_SEND_REPORT:
+ assert(payload != NULL);
+ path = (struct path *)payload;
+ if (pcc_id == 0) {
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (ctrl_state->pcc[i]) {
+ path_copy = pcep_copy_path(path);
+ pcep_pcc_send_report(
+ ctrl_state, ctrl_state->pcc[i],
+ path_copy, (bool)sub_type);
+ }
+ }
+ } else {
+ pcc_state =
+ pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ pcep_pcc_send_report(ctrl_state, pcc_state, path,
+ (bool)sub_type);
+ }
+ break;
+ case EV_PATH_REFINED:
+ assert(payload != NULL);
+ refine_data = (struct pcep_refine_path_event_data *)payload;
+ pcep_thread_path_refined_event(ctrl_state, refine_data);
+ break;
+ case EV_SEND_ERROR:
+ assert(payload != NULL);
+ error = (struct pcep_error *)payload;
+ pcc_state = pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ pcep_pcc_send_error(ctrl_state, pcc_state, error,
+ (bool)sub_type);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ "Unexpected event received in controller thread: %u",
+ type);
+ break;
+ }
+}
+
+int pcep_thread_event_update_pcc_options(struct ctrl_state *ctrl_state,
+ struct pcc_opts *opts)
+{
+ assert(opts != NULL);
+ if (ctrl_state->pcc_opts != NULL) {
+ XFREE(MTYPE_PCEP, ctrl_state->pcc_opts);
+ }
+ ctrl_state->pcc_opts = opts;
+ return 0;
+}
+
+int pcep_thread_event_update_pce_options(struct ctrl_state *ctrl_state,
+ int pcc_id, struct pce_opts *pce_opts)
+{
+ if (!pce_opts || !ctrl_state) {
+ return 0;
+ }
+ struct pcc_state *pcc_state;
+ struct pcc_opts *pcc_opts;
+
+ int current_pcc_id =
+ pcep_pcc_get_pcc_id_by_ip_port(ctrl_state->pcc, pce_opts);
+ if (current_pcc_id) {
+ pcc_state =
+ pcep_pcc_get_pcc_by_id(ctrl_state->pcc, current_pcc_id);
+ } else {
+ pcc_state = pcep_pcc_initialize(ctrl_state,
+ get_next_id(ctrl_state));
+ if (set_pcc_state(ctrl_state, pcc_state)) {
+ XFREE(MTYPE_PCEP, pcc_state);
+ return 0;
+ }
+ }
+
+ /* Copy the pcc options to delegate it to the update function */
+ pcc_opts = XCALLOC(MTYPE_PCEP, sizeof(*pcc_opts));
+ memcpy(pcc_opts, ctrl_state->pcc_opts, sizeof(*pcc_opts));
+
+ if (pcep_pcc_update(ctrl_state, pcc_state, pcc_opts, pce_opts)) {
+ flog_err(EC_PATH_PCEP_PCC_CONF_UPDATE,
+ "failed to update PCC configuration");
+ }
+
+
+ return 0;
+}
+
+int pcep_thread_event_remove_pcc_by_id(struct ctrl_state *ctrl_state,
+ int pcc_id)
+{
+ if (pcc_id) {
+ struct pcc_state *pcc_state =
+ pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ if (pcc_state) {
+ remove_pcc_state(ctrl_state, pcc_state);
+ pcep_pcc_finalize(ctrl_state, pcc_state);
+ }
+ }
+ return 0;
+}
+
+int pcep_thread_event_remove_pcc_all(struct ctrl_state *ctrl_state)
+{
+ assert(ctrl_state != NULL);
+
+ for (int i = 0; i < MAX_PCC; i++) {
+ pcep_thread_event_remove_pcc_by_id(
+ ctrl_state,
+ pcep_pcc_get_pcc_id_by_idx(ctrl_state->pcc, i));
+ }
+ return 0;
+}
+
+int pcep_thread_event_remove_pcc(struct ctrl_state *ctrl_state,
+ struct pce_opts *pce_opts)
+{
+ assert(ctrl_state != NULL);
+
+ if (pce_opts) {
+ int pcc_id = pcep_pcc_get_pcc_id_by_ip_port(ctrl_state->pcc,
+ pce_opts);
+ if (pcc_id) {
+ pcep_thread_event_remove_pcc_by_id(ctrl_state, pcc_id);
+ } else {
+ return -1;
+ }
+ XFREE(MTYPE_PCEP, pce_opts);
+ } else {
+ pcep_thread_event_remove_pcc_all(ctrl_state);
+ }
+
+ return 0;
+}
+
+int pcep_thread_event_sync_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct path *path)
+{
+ struct pcc_state *pcc_state =
+ pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ pcep_pcc_sync_path(ctrl_state, pcc_state, path);
+ pcep_free_path(path);
+ return 0;
+}
+
+int pcep_thread_event_sync_done(struct ctrl_state *ctrl_state, int pcc_id)
+{
+ struct pcc_state *pcc_state =
+ pcep_pcc_get_pcc_by_id(ctrl_state->pcc, pcc_id);
+ pcep_pcc_sync_done(ctrl_state, pcc_state);
+ return 0;
+}
+
+int pcep_thread_event_pathd_event(struct ctrl_state *ctrl_state,
+ enum pcep_pathd_event_type type,
+ struct path *path)
+{
+ int i;
+
+ for (i = 0; i < MAX_PCC; i++) {
+ if (ctrl_state->pcc[i]) {
+ struct pcc_state *pcc_state = ctrl_state->pcc[i];
+ pcep_pcc_pathd_event_handler(ctrl_state, pcc_state,
+ type, path);
+ }
+ }
+
+ pcep_free_path(path);
+
+ return 0;
+}
+
+
+/* ------------ Main Thread Event Handler ------------ */
+
+int send_to_main(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_main_event_type type, void *payload)
+{
+ struct pcep_main_event_data *data;
+
+ data = XCALLOC(MTYPE_PCEP, sizeof(*data));
+ data->handler = ctrl_state->main_event_handler;
+ data->type = type;
+ data->pcc_id = pcc_id;
+ data->payload = payload;
+
+ thread_add_event(ctrl_state->main, pcep_main_event_handler,
+ (void *)data, 0, NULL);
+ return 0;
+}
+
+void pcep_main_event_handler(struct thread *thread)
+{
+ /* data unpacking */
+ struct pcep_main_event_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+ pcep_main_event_handler_t handler = data->handler;
+ enum pcep_main_event_type type = data->type;
+ int pcc_id = data->pcc_id;
+ void *payload = data->payload;
+ XFREE(MTYPE_PCEP, data);
+
+ handler(type, pcc_id, payload);
+}
+
+
+/* ------------ Helper functions ------------ */
+
+void set_ctrl_state(struct frr_pthread *fpt, struct ctrl_state *ctrl_state)
+{
+ assert(fpt != NULL);
+ fpt->data = ctrl_state;
+}
+
+struct ctrl_state *get_ctrl_state(struct frr_pthread *fpt)
+{
+ assert(fpt != NULL);
+ assert(fpt->data != NULL);
+
+ struct ctrl_state *ctrl_state;
+ ctrl_state = (struct ctrl_state *)fpt->data;
+ assert(ctrl_state != NULL);
+ return ctrl_state;
+}
+
+int get_next_id(struct ctrl_state *ctrl_state)
+{
+ return ++ctrl_state->pcc_last_id;
+}
+
+int set_pcc_state(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state)
+{
+ assert(ctrl_state != NULL);
+ assert(pcep_pcc_get_pcc_id(pcc_state) != 0);
+
+ int current_pcc_idx = pcep_pcc_get_free_pcc_idx(ctrl_state->pcc);
+ if (current_pcc_idx >= 0) {
+ ctrl_state->pcc[current_pcc_idx] = pcc_state;
+ ctrl_state->pcc_count++;
+ PCEP_DEBUG("added pce pcc_id (%d) idx (%d)",
+ pcep_pcc_get_pcc_id(pcc_state), current_pcc_idx);
+ return 0;
+ } else {
+ PCEP_DEBUG("Max number of pce ");
+ return 1;
+ }
+}
+
+void remove_pcc_state(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ assert(ctrl_state != NULL);
+ assert(pcep_pcc_get_pcc_id(pcc_state) != 0);
+
+ int idx = 0;
+ idx = pcep_pcc_get_pcc_idx_by_id(ctrl_state->pcc,
+ pcep_pcc_get_pcc_id(pcc_state));
+ if (idx != -1) {
+ ctrl_state->pcc[idx] = NULL;
+ ctrl_state->pcc_count--;
+ PCEP_DEBUG("removed pce pcc_id (%d)",
+ pcep_pcc_get_pcc_id(pcc_state));
+ }
+}
+
+uint32_t backoff_delay(uint32_t max, uint32_t base, uint32_t retry_count)
+{
+ uint32_t a = MIN(max, base * (1 << retry_count));
+ uint64_t r = frr_weak_random(), m = RAND_MAX;
+ uint32_t b = (a / 2) + (r * (a / 2)) / m;
+ return b;
+}
+
+const char *timer_type_name(enum pcep_ctrl_timer_type type)
+{
+ switch (type) {
+ case TM_UNDEFINED:
+ return "UNDEFINED";
+ case TM_RECONNECT_PCC:
+ return "RECONNECT_PCC";
+ case TM_PCEPLIB_TIMER:
+ return "PCEPLIB_TIMER";
+ case TM_TIMEOUT:
+ return "TIMEOUT";
+ default:
+ return "UNKNOWN";
+ }
+};
+
+const char *timeout_type_name(enum pcep_ctrl_timeout_type type)
+{
+ switch (type) {
+ case TO_UNDEFINED:
+ return "UNDEFINED";
+ case TO_COMPUTATION_REQUEST:
+ return "COMPUTATION_REQUEST";
+ default:
+ return "UNKNOWN";
+ }
+}
diff --git a/pathd/path_pcep_controller.h b/pathd/path_pcep_controller.h
new file mode 100644
index 0000000..bc7ed49
--- /dev/null
+++ b/pathd/path_pcep_controller.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_CONTROLLER_H_
+#define _PATH_PCEP_CONTROLLER_H_
+
+#include "pathd/path_pcep.h"
+
+struct ctrl_state;
+struct pcc_state;
+
+enum pcep_main_event_type {
+ PCEP_MAIN_EVENT_UNDEFINED = 0,
+ PCEP_MAIN_EVENT_START_SYNC,
+ PCEP_MAIN_EVENT_INITIATE_CANDIDATE,
+ PCEP_MAIN_EVENT_UPDATE_CANDIDATE,
+ PCEP_MAIN_EVENT_REMOVE_CANDIDATE_LSP,
+};
+
+typedef int (*pcep_main_event_handler_t)(enum pcep_main_event_type type,
+ int pcc_id, void *payload);
+typedef void (*pcep_refine_callback_t)(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct path *path, void *payload);
+
+enum pcep_pathd_event_type {
+ PCEP_PATH_UNDEFINED = 0,
+ PCEP_PATH_CREATED,
+ PCEP_PATH_UPDATED,
+ PCEP_PATH_REMOVED
+};
+
+struct ctrl_state {
+ struct thread_master *main;
+ struct thread_master *self;
+ pcep_main_event_handler_t main_event_handler;
+ struct pcc_opts *pcc_opts;
+ int pcc_count;
+ int pcc_last_id;
+ struct pcc_state *pcc[MAX_PCC];
+};
+
+/* Timer handling data structures */
+
+enum pcep_ctrl_timeout_type { TO_UNDEFINED, TO_COMPUTATION_REQUEST, TO_MAX };
+
+enum pcep_ctrl_timer_type {
+ TM_UNDEFINED,
+ TM_RECONNECT_PCC,
+ TM_PCEPLIB_TIMER,
+ TM_TIMEOUT,
+ TM_CALCULATE_BEST_PCE,
+ TM_SESSION_TIMEOUT_PCC,
+ TM_MAX
+};
+
+struct pcep_ctrl_timer_data {
+ struct ctrl_state *ctrl_state;
+ enum pcep_ctrl_timer_type timer_type;
+ enum pcep_ctrl_timeout_type timeout_type;
+ int pcc_id;
+ void *payload;
+};
+
+/* Socket handling data structures */
+
+enum pcep_ctrl_socket_type { SOCK_PCEPLIB = 1 };
+
+struct pcep_ctrl_socket_data {
+ struct ctrl_state *ctrl_state;
+ enum pcep_ctrl_socket_type type;
+ bool is_read;
+ int fd;
+ int pcc_id;
+ void *payload;
+};
+
+typedef void (*pcep_ctrl_thread_callback)(struct thread *);
+
+/* PCC connection information, populated in a thread-safe
+ * manner with pcep_ctrl_get_pcc_info() */
+struct pcep_pcc_info {
+ struct ctrl_state *ctrl_state; /* will be NULL when returned */
+ char pce_name[64];
+ int pcc_id;
+ struct ipaddr pcc_addr;
+ uint16_t pcc_port;
+ int status;
+ short msd;
+ uint32_t next_reqid;
+ uint32_t next_plspid;
+ bool is_best_multi_pce;
+ bool previous_best;
+ uint8_t precedence;
+};
+
+/* Functions called from the main thread */
+int pcep_ctrl_initialize(struct thread_master *main_thread,
+ struct frr_pthread **fpt,
+ pcep_main_event_handler_t event_handler);
+int pcep_ctrl_finalize(struct frr_pthread **fpt);
+int pcep_ctrl_update_pcc_options(struct frr_pthread *fpt,
+ struct pcc_opts *opts);
+int pcep_ctrl_update_pce_options(struct frr_pthread *fpt,
+ struct pce_opts *opts);
+int pcep_ctrl_remove_pcc(struct frr_pthread *fpt, struct pce_opts *pce_opts);
+int pcep_ctrl_reset_pcc_session(struct frr_pthread *fpt, char *pce_name);
+int pcep_ctrl_pathd_event(struct frr_pthread *fpt,
+ enum pcep_pathd_event_type type, struct path *path);
+int pcep_ctrl_sync_path(struct frr_pthread *fpt, int pcc_id, struct path *path);
+int pcep_ctrl_sync_done(struct frr_pthread *fpt, int pcc_id);
+struct counters_group *pcep_ctrl_get_counters(struct frr_pthread *fpt,
+ int pcc_id);
+pcep_session *pcep_ctrl_get_pcep_session(struct frr_pthread *fpt, int pcc_id);
+struct pcep_pcc_info *pcep_ctrl_get_pcc_info(struct frr_pthread *fpt,
+ const char *pce_name);
+
+/* Asynchronously send a report. The caller is giving away the path structure,
+ * it shouldn't be allocated on the stack. If `pcc_id` is `0` the report is
+ * sent by all PCCs. The parameter is_stable is used to hint whether the status
+ * will soon change, this is used to ensure all report updates are sent even
+ * when missing status update events */
+int pcep_ctrl_send_report(struct frr_pthread *fpt, int pcc_id,
+ struct path *path, bool is_stable);
+
+int pcep_ctrl_send_error(struct frr_pthread *fpt, int pcc_id,
+ struct pcep_error *error);
+
+/* Functions called from the controller thread */
+void pcep_thread_start_sync(struct ctrl_state *ctrl_state, int pcc_id);
+void pcep_thread_update_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct path *path);
+void pcep_thread_initiate_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct path *path);
+void pcep_thread_cancel_timer(struct thread **thread);
+void pcep_thread_schedule_reconnect(struct ctrl_state *ctrl_state, int pcc_id,
+ int retry_count, struct thread **thread);
+void pcep_thread_schedule_timeout(struct ctrl_state *ctrl_state, int pcc_id,
+ enum pcep_ctrl_timeout_type type,
+ uint32_t delay, void *param,
+ struct thread **thread);
+void pcep_thread_schedule_session_timeout(struct ctrl_state *ctrl_state,
+ int pcc_id, int delay,
+ struct thread **thread);
+void pcep_thread_remove_candidate_path_segments(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+
+void pcep_thread_schedule_sync_best_pce(struct ctrl_state *ctrl_state,
+ int pcc_id, int delay,
+ struct thread **thread);
+void pcep_thread_schedule_pceplib_timer(struct ctrl_state *ctrl_state,
+ int delay, void *payload,
+ struct thread **thread,
+ pcep_ctrl_thread_callback cb);
+int pcep_thread_socket_read(void *fpt, void **thread, int fd, void *payload,
+ pcep_ctrl_thread_callback cb);
+int pcep_thread_socket_write(void *fpt, void **thread, int fd, void *payload,
+ pcep_ctrl_thread_callback cb);
+
+int pcep_thread_send_ctrl_event(void *fpt, void *payload,
+ pcep_ctrl_thread_callback cb);
+void pcep_thread_pcep_event(struct thread *thread);
+int pcep_thread_pcc_count(struct ctrl_state *ctrl_state);
+/* Called by the PCC to refine a path in the main thread */
+int pcep_thread_refine_path(struct ctrl_state *ctrl_state, int pcc_id,
+ pcep_refine_callback_t cb, struct path *path,
+ void *payload);
+
+#endif // _PATH_PCEP_CONTROLLER_H_
diff --git a/pathd/path_pcep_debug.c b/pathd/path_pcep_debug.c
new file mode 100644
index 0000000..b0802ae
--- /dev/null
+++ b/pathd/path_pcep_debug.c
@@ -0,0 +1,1777 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include <string.h>
+#include <stdbool.h>
+#include <time.h>
+#include <libyang/libyang.h>
+
+#include "printfrr.h"
+#include "ipaddr.h"
+
+#include "pathd/path_pcep_debug.h"
+
+static void _format_pcc_opts(int ps, struct pcc_opts *ops);
+static void _format_pce_opts(int ps, struct pce_opts *ops);
+static void _format_pcc_caps(int ps, struct pcep_caps *caps);
+static void _format_pcc_state(int ps, struct pcc_state *state);
+static void _format_ctrl_state(int ps, struct ctrl_state *state);
+static void _format_path(int ps, struct path *path);
+static void _format_path_hop(int ps, struct path_hop *hop);
+static void _format_path_metric(int ps, struct path_metric *metric);
+static void _format_pcep_event(int ps, pcep_event *event);
+static void _format_pcep_message(int ps, struct pcep_message *msg);
+static void _format_pcep_objects(int ps, double_linked_list *objs);
+static void _format_pcep_object(int ps, struct pcep_object_header *obj);
+static void _format_pcep_object_details(int ps, struct pcep_object_header *obj);
+static void _format_pcep_object_error(int ps, struct pcep_object_error *obj);
+static void _format_pcep_object_open(int ps, struct pcep_object_open *obj);
+static void _format_pcep_object_rp(int ps, struct pcep_object_rp *obj);
+static void _format_pcep_object_srp(int ps, struct pcep_object_srp *obj);
+static void _format_pcep_object_lsp(int psps, struct pcep_object_lsp *obj);
+static void _format_pcep_object_lspa(int psps, struct pcep_object_lspa *obj);
+static void
+_format_pcep_object_ipv4_endpoint(int ps,
+ struct pcep_object_endpoints_ipv4 *obj);
+static void _format_pcep_object_metric(int ps, struct pcep_object_metric *obj);
+static void _format_pcep_object_bandwidth(int ps,
+ struct pcep_object_bandwidth *obj);
+static void _format_pcep_object_nopath(int ps, struct pcep_object_nopath *obj);
+static void
+_format_pcep_object_objfun(int ps, struct pcep_object_objective_function *obj);
+static void _format_pcep_object_ro(int ps, struct pcep_object_ro *obj);
+static void _format_pcep_object_ro_details(int ps,
+ struct pcep_object_ro_subobj *ro);
+static void _format_pcep_object_ro_ipv4(int ps,
+ struct pcep_ro_subobj_ipv4 *obj);
+static void _format_pcep_object_ro_sr(int ps, struct pcep_ro_subobj_sr *obj);
+static void _format_pcep_object_tlvs(int ps, struct pcep_object_header *obj);
+static void _format_pcep_object_tlv(int ps,
+ struct pcep_object_tlv_header *tlv_header);
+static void
+_format_pcep_object_tlv_details(int ps,
+ struct pcep_object_tlv_header *tlv_header);
+static void _format_pcep_object_tlv_symbolic_path_name(
+ int ps, struct pcep_object_tlv_symbolic_path_name *tlv);
+static void _format_pcep_object_tlv_stateful_pce_capability(
+ int ps, struct pcep_object_tlv_stateful_pce_capability *tlv);
+static void _format_pcep_object_tlv_sr_pce_capability(
+ int ps, struct pcep_object_tlv_sr_pce_capability *tlv);
+static void _format_pcep_object_tlv_path_setup_type(
+ int ps, struct pcep_object_tlv_path_setup_type *tlv);
+
+const char *pcc_status_name(enum pcc_status status)
+{
+ switch (status) {
+ case PCEP_PCC_INITIALIZED:
+ return "INITIALIZED";
+ case PCEP_PCC_DISCONNECTED:
+ return "DISCONNECTED";
+ case PCEP_PCC_CONNECTING:
+ return "CONNECTING";
+ case PCEP_PCC_SYNCHRONIZING:
+ return "SYNCHRONIZING";
+ case PCEP_PCC_OPERATING:
+ return "OPERATING";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_event_type_name(pcep_event_type event_type)
+{
+ switch (event_type) {
+ case MESSAGE_RECEIVED:
+ return "MESSAGE_RECEIVED";
+ case PCE_CLOSED_SOCKET:
+ return "PCE_CLOSED_SOCKET";
+ case PCE_SENT_PCEP_CLOSE:
+ return "PCE_SENT_PCEP_CLOSE";
+ case PCE_DEAD_TIMER_EXPIRED:
+ return "PCE_DEAD_TIMER_EXPIRED";
+ case PCE_OPEN_KEEP_WAIT_TIMER_EXPIRED:
+ return "PCE_OPEN_KEEP_WAIT_TIMER_EXPIRED";
+ case PCC_CONNECTED_TO_PCE:
+ return "PCC_CONNECTED_TO_PCE";
+ case PCC_PCEP_SESSION_CLOSED:
+ return "PCC_PCEP_SESSION_CLOSED";
+ case PCC_RCVD_INVALID_OPEN:
+ return "PCC_RCVD_INVALID_OPEN";
+ case PCC_RCVD_MAX_INVALID_MSGS:
+ return "PCC_RCVD_MAX_INVALID_MSGS";
+ case PCC_RCVD_MAX_UNKOWN_MSGS:
+ return "PCC_RCVD_MAX_UNKOWN_MSGS";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_error_type_name(enum pcep_error_type error_type)
+{
+ switch (error_type) {
+
+ case PCEP_ERRT_SESSION_FAILURE:
+ return "SESSION_FAILURE";
+ case PCEP_ERRT_CAPABILITY_NOT_SUPPORTED:
+ return "CAPABILITY_NOT_SUPPORTED";
+ case PCEP_ERRT_UNKNOW_OBJECT:
+ return "UNKNOW_OBJECT";
+ case PCEP_ERRT_NOT_SUPPORTED_OBJECT:
+ return "NOT_SUPPORTED_OBJECT";
+ case PCEP_ERRT_POLICY_VIOLATION:
+ return "POLICY_VIOLATION";
+ case PCEP_ERRT_MANDATORY_OBJECT_MISSING:
+ return "MANDATORY_OBJECT_MISSING";
+ case PCEP_ERRT_SYNC_PC_REQ_MISSING:
+ return "SYNC_PC_REQ_MISSING";
+ case PCEP_ERRT_UNKNOWN_REQ_REF:
+ return "UNKNOWN_REQ_REF";
+ case PCEP_ERRT_ATTEMPT_TO_ESTABLISH_2ND_PCEP_SESSION:
+ return "ATTEMPT_TO_ESTABLISH_2ND_PCEP_SESSION";
+ case PCEP_ERRT_RECEPTION_OF_INV_OBJECT:
+ return "RECEPTION_OF_INV_OBJECT";
+ case PCEP_ERRT_UNRECOGNIZED_EXRS_SUBOBJ:
+ return "UNRECOGNIZED_EXRS_SUBOBJ";
+ case PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR:
+ return "DIFFSERV_AWARE_TE_ERROR";
+ case PCEP_ERRT_BRPC_PROC_COMPLETION_ERROR:
+ return "BRPC_PROC_COMPLETION_ERROR";
+ case PCEP_ERRT_UNASSIGNED14:
+ return "UNASSIGNED14";
+ case PCEP_ERRT_GLOBAL_CONCURRENT_ERROR:
+ return "GLOBAL_CONCURRENT_ERROR";
+ case PCEP_ERRT_P2PMP_CAP_ERROR:
+ return "P2PMP_CAP_ERROR";
+ case PCEP_ERRT_P2P_ENDPOINTS_ERROR:
+ return "P2P_ENDPOINTS_ERROR";
+ case PCEP_ERRT_P2P_FRAGMENTATION_ERROR:
+ return "P2P_FRAGMENTATION_ERROR";
+ case PCEP_ERRT_INVALID_OPERATION:
+ return "INVALID_OPERATION";
+ case PCEP_ERRT_LSP_STATE_SYNC_ERROR:
+ return "LSP_STATE_SYNC_ERROR";
+ case PCEP_ERRT_INVALID_TE_PATH_SETUP_TYPE:
+ return "INVALID_TE_PATH_SETUP_TYPE";
+ case PCEP_ERRT_UNASSIGNED22:
+ return "UNASSIGNED22";
+ case PCEP_ERRT_BAD_PARAMETER_VALUE:
+ return "BAD_PARAMETER_VALUE";
+ case PCEP_ERRT_LSP_INSTANTIATE_ERROR:
+ return "LSP_INSTANTIATE_ERROR";
+ case PCEP_ERRT_START_TLS_FAILURE:
+ return "START_TLS_FAILURE";
+ case PCEP_ERRT_ASSOCIATION_ERROR:
+ return "ASSOCIATION_ERROR";
+ case PCEP_ERRT_WSON_RWA_ERROR:
+ return "WSON_RWA_ERROR";
+ case PCEP_ERRT_H_PCE_ERROR:
+ return "H_PCE_ERROR";
+ case PCEP_ERRT_PATH_COMP_FAILURE:
+ return "PATH_COMP_FAILURE";
+ case PCEP_ERRT_UNASSIGNED30:
+ return "UNASSIGNED30";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_error_value_name(enum pcep_error_type error_type,
+ enum pcep_error_value error_value)
+{
+ switch (TUP(error_type, error_value)) {
+
+ case TUP(PCEP_ERRT_CAPABILITY_NOT_SUPPORTED, PCEP_ERRV_UNASSIGNED):
+ case TUP(PCEP_ERRT_SYNC_PC_REQ_MISSING, PCEP_ERRV_UNASSIGNED):
+ case TUP(PCEP_ERRT_UNKNOWN_REQ_REF, PCEP_ERRV_UNASSIGNED):
+ case TUP(PCEP_ERRT_ATTEMPT_TO_ESTABLISH_2ND_PCEP_SESSION,
+ PCEP_ERRV_UNASSIGNED):
+ case TUP(PCEP_ERRT_UNRECOGNIZED_EXRS_SUBOBJ, PCEP_ERRV_UNASSIGNED):
+ return "UNASSIGNED";
+
+ case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_RECVD_INVALID_OPEN_MSG):
+ return "RECVD_INVALID_OPEN_MSG";
+ case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_OPENWAIT_TIMED_OUT):
+ return "OPENWAIT_TIMED_OUT";
+ case TUP(PCEP_ERRT_SESSION_FAILURE,
+ PCEP_ERRV_UNACCEPTABLE_OPEN_MSG_NO_NEG):
+ return "UNACCEPTABLE_OPEN_MSG_NO_NEG";
+ case TUP(PCEP_ERRT_SESSION_FAILURE,
+ PCEP_ERRV_UNACCEPTABLE_OPEN_MSG_NEG):
+ return "UNACCEPTABLE_OPEN_MSG_NEG";
+ case TUP(PCEP_ERRT_SESSION_FAILURE,
+ PCEP_ERRV_RECVD_SECOND_OPEN_MSG_UNACCEPTABLE):
+ return "RECVD_SECOND_OPEN_MSG_UNACCEPTABLE";
+ case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_RECVD_PCERR):
+ return "RECVD_PCERR";
+ case TUP(PCEP_ERRT_SESSION_FAILURE, PCEP_ERRV_KEEPALIVEWAIT_TIMED_OUT):
+ return "KEEPALIVEWAIT_TIMED_OUT";
+ case TUP(PCEP_ERRT_SESSION_FAILURE,
+ PCEP_ERRV_PCEP_VERSION_NOT_SUPPORTED):
+ return "PCEP_VERSION_NOT_SUPPORTED";
+
+ case TUP(PCEP_ERRT_UNKNOW_OBJECT, PCEP_ERRV_UNREC_OBJECT_CLASS):
+ return "UNREC_OBJECT_CLASS";
+ case TUP(PCEP_ERRT_UNKNOW_OBJECT, PCEP_ERRV_UNREC_OBJECT_TYPE):
+ return "UNREC_OBJECT_TYPE";
+
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_NOT_SUPPORTED_OBJECT_CLASS):
+ return "NOT_SUPPORTED_OBJECT_CLASS";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_NOT_SUPPORTED_OBJECT_TYPE):
+ return "NOT_SUPPORTED_OBJECT_TYPE";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT, PCEP_ERRV_UNSUPPORTED_PARAM):
+ return "UNSUPPORTED_PARAM";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_NW_PERF_CONSTRAINT):
+ return "UNSUPPORTED_NW_PERF_CONSTRAINT";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_NOT_SUPPORTED_BW_OBJECT_3_4):
+ return "NOT_SUPPORTED_BW_OBJECT_3_4";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_ENDPOINT_TYPE):
+ return "UNSUPPORTED_ENDPOINT_TYPE";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_ENDPOINT_TLV):
+ return "UNSUPPORTED_ENDPOINT_TLV";
+ case TUP(PCEP_ERRT_NOT_SUPPORTED_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_RP_FLAG_GRANULARITY):
+ return "UNSUPPORTED_RP_FLAG_GRANULARITY";
+
+ case TUP(PCEP_ERRT_POLICY_VIOLATION,
+ PCEP_ERRV_C_BIT_SET_IN_METRIC_OBJECT):
+ return "C_BIT_SET_IN_METRIC_OBJECT";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION,
+ PCEP_ERRV_O_BIT_CLEARD_IN_RP_OBJECT):
+ return "O_BIT_CLEARD_IN_RP_OBJECT";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION,
+ PCEP_ERRV_OBJECTIVE_FUNC_NOT_ALLOWED):
+ return "OBJECTIVE_FUNC_NOT_ALLOWED";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION, PCEP_ERRV_RP_OF_BIT_SET):
+ return "RP_OF_BIT_SET";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION,
+ PCEP_ERRV_GLOBAL_CONCURRENCY_NOT_ALLOWED):
+ return "GLOBAL_CONCURRENCY_NOT_ALLOWED";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION, PCEP_ERRV_MONITORING_MSG_REJECTED):
+ return "MONITORING_MSG_REJECTED";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION,
+ PCEP_ERRV_P2MP_PATH_COMP_NOT_ALLOWED):
+ return "P2MP_PATH_COMP_NOT_ALLOWED";
+ case TUP(PCEP_ERRT_POLICY_VIOLATION,
+ PCEP_ERRV_UNALLOWED_NW_PERF_CONSTRAINT):
+ return "UNALLOWED_NW_PERF_CONSTRAINT";
+
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_RP_OBJECT_MISSING):
+ return "RP_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_RRO_OBJECT_MISSING_FOR_REOP):
+ return "RRO_OBJECT_MISSING_FOR_REOP";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_EP_OBJECT_MISSING):
+ return "EP_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_MONITOR_OBJECT_MISSING):
+ return "MONITOR_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_LSP_OBJECT_MISSING):
+ return "LSP_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_ERO_OBJECT_MISSING):
+ return "ERO_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_SRP_OBJECT_MISSING):
+ return "SRP_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_LSP_ID_TLV_MISSING):
+ return "LSP_ID_TLV_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_LSP_DB_TLV_MISSING):
+ return "LSP_DB_TLV_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_S2LS_OBJECT_MISSING):
+ return "S2LS_OBJECT_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_P2MP_LSP_ID_TLV_MISSING):
+ return "P2MP_LSP_ID_TLV_MISSING";
+ case TUP(PCEP_ERRT_MANDATORY_OBJECT_MISSING,
+ PCEP_ERRV_DISJOINTED_CONF_TLV_MISSING):
+ return "DISJOINTED_CONF_TLV_MISSING";
+
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_P_FLAG_NOT_CORRECT_IN_OBJECT):
+ return "P_FLAG_NOT_CORRECT_IN_OBJECT";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_BAD_LABEL_VALUE):
+ return "BAD_LABEL_VALUE";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_NUM_SR_ERO_SUBOBJECTS):
+ return "UNSUPPORTED_NUM_SR_ERO_SUBOBJECTS";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_BAD_LABEL_FORMAT):
+ return "BAD_LABEL_FORMAT";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_ERO_SR_ERO_MIX):
+ return "ERO_SR_ERO_MIX";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_SR_ERO_SID_NAI_ABSENT):
+ return "SR_ERO_SID_NAI_ABSENT";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_SR_RRO_SID_NAI_ABSENT):
+ return "SR_RRO_SID_NAI_ABSENT";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_SYMBOLIC_PATH_NAME_TLV_MISSING):
+ return "SYMBOLIC_PATH_NAME_TLV_MISSING";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_MSD_EXCEEDS_PCEP_SESSION_MAX):
+ return "MSD_EXCEEDS_PCEP_SESSION_MAX";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_RRO_SR_RRO_MIX):
+ return "RRO_SR_RRO_MIX";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_MALFORMED_OBJECT):
+ return "MALFORMED_OBJECT";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_MISSING_PCE_SR_CAP_TLV):
+ return "MISSING_PCE_SR_CAP_TLV";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_UNSUPPORTED_NAI):
+ return "UNSUPPORTED_NAI";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_UNKNOWN_SID):
+ return "UNKNOWN_SID";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_CANNOT_RESOLVE_NAI_TO_SID):
+ return "CANNOT_RESOLVE_NAI_TO_SID";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_COULD_NOT_FIND_SRGB):
+ return "COULD_NOT_FIND_SRGB";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_SID_EXCEEDS_SRGB):
+ return "SID_EXCEEDS_SRGB";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_COULD_NOT_FIND_SRLB):
+ return "COULD_NOT_FIND_SRLB";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_SID_EXCEEDS_SRLB):
+ return "SID_EXCEEDS_SRLB";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT, PCEP_ERRV_INCONSISTENT_SID):
+ return "INCONSISTENT_SID";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_MSD_MUST_BE_NONZERO):
+ return "MSD_MUST_BE_NONZERO";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_MISMATCH_O_S2LS_LSP):
+ return "MISMATCH_O_S2LS_LSP";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_INCOMPATIBLE_H_PCE_OF):
+ return "INCOMPATIBLE_H_PCE_OF";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_BAD_BANDWIDTH_TYPE_3_4):
+ return "BAD_BANDWIDTH_TYPE_3_4";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_LSP_PROT_FLAGS):
+ return "UNSUPPORTED_LSP_PROT_FLAGS";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_2ND_LSP_PROT_FLAGS):
+ return "UNSUPPORTED_2ND_LSP_PROT_FLAGS";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_UNSUPPORTED_LINK_PROT_TYPE):
+ return "UNSUPPORTED_LINK_PROT_TYPE";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_LABEL_SET_TLV_NO_RP_R):
+ return "LABEL_SET_TLV_NO_RP_R";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_WRONG_LABEL_SET_TLV_O_L_SET):
+ return "WRONG_LABEL_SET_TLV_O_L_SET";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_WRONG_LABEL_SET_O_SET):
+ return "WRONG_LABEL_SET_O_SET";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_MISSING_GMPLS_CAP_TLV):
+ return "MISSING_GMPLS_CAP_TLV";
+ case TUP(PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_INCOMPATIBLE_OF_CODE):
+ return "INCOMPATIBLE_OF_CODE";
+
+ case TUP(PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR,
+ PCEP_ERRV_UNSUPPORTED_CLASS_TYPE):
+ return "UNSUPPORTED_CLASS_TYPE";
+ case TUP(PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR,
+ PCEP_ERRV_INVALID_CLASS_TYPE):
+ return "INVALID_CLASS_TYPE";
+ case TUP(PCEP_ERRT_DIFFSERV_AWARE_TE_ERROR,
+ PCEP_ERRV_CLASS_SETUP_TYPE_NOT_TE_CLASS):
+ return "CLASS_SETUP_TYPE_NOT_TE_CLASS";
+
+ case TUP(PCEP_ERRT_BRPC_PROC_COMPLETION_ERROR,
+ PCEP_ERRV_BRPC_PROC_NOT_SUPPORTED):
+ return "BRPC_PROC_NOT_SUPPORTED";
+
+ case TUP(PCEP_ERRT_GLOBAL_CONCURRENT_ERROR,
+ PCEP_ERRV_INSUFFICIENT_MEMORY):
+ return "INSUFFICIENT_MEMORY";
+ case TUP(PCEP_ERRT_GLOBAL_CONCURRENT_ERROR,
+ PCEP_ERRV_GLOBAL_CONCURRENT_OPT_NOT_SUPPORTED):
+ return "GLOBAL_CONCURRENT_OPT_NOT_SUPPORTED";
+
+ case TUP(PCEP_ERRT_P2PMP_CAP_ERROR, PCEP_ERRV_PCE_INSUFFICIENT_MEMORY):
+ return "PCE_INSUFFICIENT_MEMORY";
+ case TUP(PCEP_ERRT_P2PMP_CAP_ERROR,
+ PCEP_ERRV_PCE_NOT_CAPABLE_P2MP_COMP):
+ return "PCE_NOT_CAPABLE_P2MP_COMP";
+
+ case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR,
+ PCEP_ERRV_NO_EP_WITH_LEAF_TYPE2):
+ return "NO_EP_WITH_LEAF_TYPE2";
+ case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR,
+ PCEP_ERRV_NO_EP_WITH_LEAF_TYPE3):
+ return "NO_EP_WITH_LEAF_TYPE3";
+ case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR,
+ PCEP_ERRV_NO_EP_WITH_LEAF_TYPE4):
+ return "NO_EP_WITH_LEAF_TYPE4";
+ case TUP(PCEP_ERRT_P2P_ENDPOINTS_ERROR, PCEP_ERRV_INCONSITENT_EP):
+ return "INCONSITENT_EP";
+
+ case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
+ PCEP_ERRV_FRAG_REQUEST_FAILURE):
+ return "FRAG_REQUEST_FAILURE";
+ case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
+ PCEP_ERRV_FRAG_REPORT_FAILURE):
+ return "FRAG_REPORT_FAILURE";
+ case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
+ PCEP_ERRV_FRAG_UPDATE_FAILURE):
+ return "FRAG_UPDATE_FAILURE";
+ case TUP(PCEP_ERRT_P2P_FRAGMENTATION_ERROR,
+ PCEP_ERRV_FRAG_INSTANTIATION_FAILURE):
+ return "FRAG_INSTANTIATION_FAILURE";
+
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_UPDATE_FOR_NON_DELEGATED_LSP):
+ return "LSP_UPDATE_FOR_NON_DELEGATED_LS";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_UPDATE_NON_ADVERTISED_PCE):
+ return "LSP_UPDATE_NON_ADVERTISED_PC";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_UPDATE_UNKNOWN_PLSP_ID):
+ return "LSP_UPDATE_UNKNOWN_PLSP_I";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_REPORT_NON_ADVERTISED_PCE):
+ return "LSP_REPORT_NON_ADVERTISED_PC";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_PCE_INIT_LSP_LIMIT_REACHED):
+ return "PCE_INIT_LSP_LIMIT_REACHE";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_PCE_INIT_LSP_DELEGATION_CANT_REVOKE):
+ return "PCE_INIT_LSP_DELEGATION_CANT_REVOK";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_INIT_NON_ZERO_PLSP_ID):
+ return "LSP_INIT_NON_ZERO_PLSP_I";
+ case TUP(PCEP_ERRT_INVALID_OPERATION, PCEP_ERRV_LSP_NOT_PCE_INITIATED):
+ return "LSP_NOT_PCE_INITIATE";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_PCE_INIT_OP_FREQ_LIMIT_REACHED):
+ return "PCE_INIT_OP_FREQ_LIMIT_REACHE";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_REPORT_P2MP_NOT_ADVERTISED):
+ return "LSP_REPORT_P2MP_NOT_ADVERTISE";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_UPDATE_P2MP_NOT_ADVERTISED):
+ return "LSP_UPDATE_P2MP_NOT_ADVERTISE";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_INSTANTIATION_P2MP_NOT_ADVERTISED):
+ return "LSP_INSTANTIATION_P2MP_NOT_ADVERTISE";
+ case TUP(PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_AUTO_BW_CAP_NOT_ADVERTISED):
+ return "AUTO_BW_CAP_NOT_ADVERTISE";
+
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_PCE_CANT_PROCESS_LSP_REPORT):
+ return "PCE_CANT_PROCESS_LSP_REPORT";
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_LSP_DB_VERSION_MISMATCH):
+ return "LSP_DB_VERSION_MISMATCH";
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_TRIGGER_ATTEMPT_BEFORE_PCE_TRIGGER):
+ return "TRIGGER_ATTEMPT_BEFORE_PCE_TRIGGER";
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_TRIGGER_ATTEMPT_NO_PCE_TRIGGER_CAP):
+ return "TRIGGER_ATTEMPT_NO_PCE_TRIGGER_CAP";
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_PCC_CANT_COMPLETE_STATE_SYNC):
+ return "PCC_CANT_COMPLETE_STATE_SYNC";
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_INVALID_LSP_DB_VERSION_NUMBER):
+ return "INVALID_LSP_DB_VERSION_NUMBER";
+ case TUP(PCEP_ERRT_LSP_STATE_SYNC_ERROR,
+ PCEP_ERRV_INVALID_SPEAKER_ENTITY_ID):
+ return "INVALID_SPEAKER_ENTITY_ID";
+
+ case TUP(PCEP_ERRT_INVALID_TE_PATH_SETUP_TYPE,
+ PCEP_ERRV_UNSUPPORTED_PATH_SETUP_TYPE):
+ return "UNSUPPORTED_PATH_SETUP_TYPE";
+ case TUP(PCEP_ERRT_INVALID_TE_PATH_SETUP_TYPE,
+ PCEP_ERRV_MISMATCHED_PATH_SETUP_TYPE):
+ return "MISMATCHED_PATH_SETUP_TYPE";
+
+ case TUP(PCEP_ERRT_BAD_PARAMETER_VALUE,
+ PCEP_ERRV_SYMBOLIC_PATH_NAME_IN_USE):
+ return "SYMBOLIC_PATH_NAME_IN_USE";
+ case TUP(PCEP_ERRT_BAD_PARAMETER_VALUE,
+ PCEP_ERRV_LSP_SPEAKER_ID_NOT_PCE_INITIATED):
+ return "LSP_SPEAKER_ID_NOT_PCE_INITIATED";
+
+ case TUP(PCEP_ERRT_LSP_INSTANTIATE_ERROR,
+ PCEP_ERRV_UNACCEPTABLE_INSTANTIATE_ERROR):
+ return "UNACCEPTABLE_INSTANTIATE_ERROR";
+ case TUP(PCEP_ERRT_LSP_INSTANTIATE_ERROR, PCEP_ERRV_INTERNAL_ERROR):
+ return "INTERNAL_ERROR";
+ case TUP(PCEP_ERRT_LSP_INSTANTIATE_ERROR, PCEP_ERRV_SIGNALLING_ERROR):
+ return "SIGNALLING_ERROR";
+
+ case TUP(PCEP_ERRT_START_TLS_FAILURE,
+ PCEP_ERRV_START_TLS_AFTER_PCEP_EXCHANGE):
+ return "START_TLS_AFTER_PCEP_EXCHANGE";
+ case TUP(PCEP_ERRT_START_TLS_FAILURE,
+ PCEP_ERRV_MSG_NOT_START_TLS_OPEN_ERROR):
+ return "MSG_NOT_START_TLS_OPEN_ERROR";
+ case TUP(PCEP_ERRT_START_TLS_FAILURE,
+ PCEP_ERRV_CONNECTION_WO_TLS_NOT_POSSIBLE):
+ return "CONNECTION_WO_TLS_NOT_POSSIBLE";
+ case TUP(PCEP_ERRT_START_TLS_FAILURE,
+ PCEP_ERRV_CONNECTION_WO_TLS_IS_POSSIBLE):
+ return "CONNECTION_WO_TLS_IS_POSSIBLE";
+ case TUP(PCEP_ERRT_START_TLS_FAILURE,
+ PCEP_ERRV_NO_START_TLS_BEFORE_START_TLS_WAIT_TIMER):
+ return "NO_START_TLS_BEFORE_START_TLS_WAIT_TIMER";
+
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_ASSOC_TYPE_NOT_SUPPORTED):
+ return "ASSOC_TYPE_NOT_SUPPORTED";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_TOO_MANY_LSPS_IN_ASSOC_GRP):
+ return "TOO_MANY_LSPS_IN_ASSOC_GRP";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_TOO_MANY_ASSOC_GROUPS):
+ return "TOO_MANY_ASSOC_GROUPS";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_ASSOCIATION_UNKNOWN):
+ return "ASSOCIATION_UNKNOWN";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_OP_CONF_ASSOC_INFO_MISMATCH):
+ return "OP_CONF_ASSOC_INFO_MISMATCH";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_ASSOC_INFO_MISMATCH):
+ return "ASSOC_INFO_MISMATCH";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_CANNOT_JOIN_ASSOC_GROUP):
+ return "CANNOT_JOIN_ASSOC_GROUP";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR, PCEP_ERRV_ASSOC_ID_NOT_IN_RANGE):
+ return "ASSOC_ID_NOT_IN_RANGE";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_TUNNEL_EP_MISMATCH_PATH_PROT_ASSOC):
+ return "TUNNEL_EP_MISMATCH_PATH_PROT_ASSOC";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_ATTEMPTED_ADD_LSP_PATH_PROT_ASSOC):
+ return "ATTEMPTED_ADD_LSP_PATH_PROT_ASSOC";
+ case TUP(PCEP_ERRT_ASSOCIATION_ERROR,
+ PCEP_ERRV_PROTECTION_TYPE_NOT_SUPPORTED):
+ return "PROTECTION_TYPE_NOT_SUPPORTED";
+
+ case TUP(PCEP_ERRT_WSON_RWA_ERROR, PCEP_ERRV_RWA_INSUFFICIENT_MEMORY):
+ return "RWA_INSUFFICIENT_MEMORY";
+ case TUP(PCEP_ERRT_WSON_RWA_ERROR, PCEP_ERRV_RWA_COMP_NOT_SUPPORTED):
+ return "RWA_COMP_NOT_SUPPORTED";
+ case TUP(PCEP_ERRT_WSON_RWA_ERROR, PCEP_ERRV_SYNTAX_ENC_ERROR):
+ return "SYNTAX_ENC_ERROR";
+
+ case TUP(PCEP_ERRT_H_PCE_ERROR, PCEP_ERRV_H_PCE_CAP_NOT_ADVERTISED):
+ return "H_PCE_CAP_NOT_ADVERTISED";
+ case TUP(PCEP_ERRT_H_PCE_ERROR,
+ PCEP_ERRV_PARENT_PCE_CAP_CANT_BE_PROVIDED):
+ return "PARENT_PCE_CAP_CANT_BE_PROVIDED";
+
+ case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
+ PCEP_ERRV_UNACCEPTABLE_REQUEST_MSG):
+ return "UNACCEPTABLE_REQUEST_MSG";
+ case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
+ PCEP_ERRV_GENERALIZED_BW_VAL_NOT_SUPPORTED):
+ return "GENERALIZED_BW_VAL_NOT_SUPPORTED";
+ case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
+ PCEP_ERRV_LABEL_SET_CONSTRAINT_COULD_NOT_BE_MET):
+ return "LABEL_SET_CONSTRAINT_COULD_NOT_BE_MET";
+ case TUP(PCEP_ERRT_PATH_COMP_FAILURE,
+ PCEP_ERRV_LABEL_CONSTRAINT_COULD_NOT_BE_MET):
+ return "LABEL_CONSTRAINT_COULD_NOT_BE_MET";
+
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_message_type_name(enum pcep_message_types pcep_message_type)
+{
+ switch (pcep_message_type) {
+
+ case PCEP_TYPE_OPEN:
+ return "OPEN";
+ case PCEP_TYPE_KEEPALIVE:
+ return "KEEPALIVE";
+ case PCEP_TYPE_PCREQ:
+ return "PCREQ";
+ case PCEP_TYPE_PCREP:
+ return "PCREP";
+ case PCEP_TYPE_PCNOTF:
+ return "PCNOTF";
+ case PCEP_TYPE_ERROR:
+ return "ERROR";
+ case PCEP_TYPE_CLOSE:
+ return "CLOSE";
+ case PCEP_TYPE_REPORT:
+ return "REPORT";
+ case PCEP_TYPE_UPDATE:
+ return "UPDATE";
+ case PCEP_TYPE_INITIATE:
+ return "INITIATE";
+ case PCEP_TYPE_START_TLS:
+ return "START_TLS";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_object_class_name(enum pcep_object_classes obj_class)
+{
+ switch (obj_class) {
+ case PCEP_OBJ_CLASS_OPEN:
+ return "OPEN";
+ case PCEP_OBJ_CLASS_RP:
+ return "RP";
+ case PCEP_OBJ_CLASS_NOPATH:
+ return "NOPATH";
+ case PCEP_OBJ_CLASS_ENDPOINTS:
+ return "ENDPOINTS";
+ case PCEP_OBJ_CLASS_BANDWIDTH:
+ return "BANDWIDTH";
+ case PCEP_OBJ_CLASS_METRIC:
+ return "METRIC";
+ case PCEP_OBJ_CLASS_ERO:
+ return "ERO";
+ case PCEP_OBJ_CLASS_RRO:
+ return "RRO";
+ case PCEP_OBJ_CLASS_LSPA:
+ return "LSPA";
+ case PCEP_OBJ_CLASS_IRO:
+ return "IRO";
+ case PCEP_OBJ_CLASS_SVEC:
+ return "SVEC";
+ case PCEP_OBJ_CLASS_NOTF:
+ return "NOTF";
+ case PCEP_OBJ_CLASS_ERROR:
+ return "ERROR";
+ case PCEP_OBJ_CLASS_CLOSE:
+ return "CLOSE";
+ case PCEP_OBJ_CLASS_OF:
+ return "OF";
+ case PCEP_OBJ_CLASS_LSP:
+ return "LSP";
+ case PCEP_OBJ_CLASS_SRP:
+ return "SRP";
+ case PCEP_OBJ_CLASS_VENDOR_INFO:
+ return "VENDOR_INFO";
+ case PCEP_OBJ_CLASS_INTER_LAYER:
+ return "INTER_LAYER";
+ case PCEP_OBJ_CLASS_SWITCH_LAYER:
+ return "SWITCH_LAYER";
+ case PCEP_OBJ_CLASS_REQ_ADAP_CAP:
+ return "REQ_ADAP_CAP";
+ case PCEP_OBJ_CLASS_SERVER_IND:
+ return "SERVER_IND";
+ case PCEP_OBJ_CLASS_ASSOCIATION:
+ return "ASSOCIATION";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_object_type_name(enum pcep_object_classes obj_class,
+ enum pcep_object_types obj_type)
+{
+ switch (TUP(obj_class, obj_type)) {
+ case TUP(PCEP_OBJ_CLASS_OPEN, PCEP_OBJ_TYPE_OPEN):
+ return "OPEN";
+ case TUP(PCEP_OBJ_CLASS_RP, PCEP_OBJ_TYPE_RP):
+ return "RP";
+ case TUP(PCEP_OBJ_CLASS_NOPATH, PCEP_OBJ_TYPE_NOPATH):
+ return "NOPATH";
+ case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV4):
+ return "ENDPOINT_IPV4";
+ case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV6):
+ return "ENDPOINT_IPV6";
+ case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_REQ):
+ return "BANDWIDTH_REQ";
+ case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_TELSP):
+ return "BANDWIDTH_TELSP";
+ case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_CISCO):
+ return "BANDWIDTH_CISCO";
+ case TUP(PCEP_OBJ_CLASS_METRIC, PCEP_OBJ_TYPE_METRIC):
+ return "METRIC";
+ case TUP(PCEP_OBJ_CLASS_ERO, PCEP_OBJ_TYPE_ERO):
+ return "ERO";
+ case TUP(PCEP_OBJ_CLASS_RRO, PCEP_OBJ_TYPE_RRO):
+ return "RRO";
+ case TUP(PCEP_OBJ_CLASS_LSPA, PCEP_OBJ_TYPE_LSPA):
+ return "LSPA";
+ case TUP(PCEP_OBJ_CLASS_IRO, PCEP_OBJ_TYPE_IRO):
+ return "IRO";
+ case TUP(PCEP_OBJ_CLASS_SVEC, PCEP_OBJ_TYPE_SVEC):
+ return "SVEC";
+ case TUP(PCEP_OBJ_CLASS_NOTF, PCEP_OBJ_TYPE_NOTF):
+ return "NOTF";
+ case TUP(PCEP_OBJ_CLASS_ERROR, PCEP_OBJ_TYPE_ERROR):
+ return "ERROR";
+ case TUP(PCEP_OBJ_CLASS_CLOSE, PCEP_OBJ_TYPE_CLOSE):
+ return "CLOSE";
+ case TUP(PCEP_OBJ_CLASS_INTER_LAYER, PCEP_OBJ_TYPE_INTER_LAYER):
+ return "INTER_LAYER";
+ case TUP(PCEP_OBJ_CLASS_SWITCH_LAYER, PCEP_OBJ_TYPE_SWITCH_LAYER):
+ return "SWITCH_LAYER";
+ case TUP(PCEP_OBJ_CLASS_REQ_ADAP_CAP, PCEP_OBJ_TYPE_REQ_ADAP_CAP):
+ return "REQ_ADAP_CAP";
+ case TUP(PCEP_OBJ_CLASS_SERVER_IND, PCEP_OBJ_TYPE_SERVER_IND):
+ return "SERVER_IND";
+ case TUP(PCEP_OBJ_CLASS_ASSOCIATION, PCEP_OBJ_TYPE_ASSOCIATION_IPV4):
+ return "ASSOCIATION_IPV4";
+ case TUP(PCEP_OBJ_CLASS_ASSOCIATION, PCEP_OBJ_TYPE_ASSOCIATION_IPV6):
+ return "ASSOCIATION_IPV6";
+ case TUP(PCEP_OBJ_CLASS_OF, PCEP_OBJ_TYPE_OF):
+ return "OF";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_lsp_status_name(enum pcep_lsp_operational_status status)
+{
+ switch (status) {
+ case PCEP_LSP_OPERATIONAL_DOWN:
+ return "DOWN";
+ case PCEP_LSP_OPERATIONAL_UP:
+ return "UP";
+ case PCEP_LSP_OPERATIONAL_ACTIVE:
+ return "ACTIVE";
+ case PCEP_LSP_OPERATIONAL_GOING_DOWN:
+ return "GOING_DOWN";
+ case PCEP_LSP_OPERATIONAL_GOING_UP:
+ return "GOING_UP";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+
+const char *pcep_tlv_type_name(enum pcep_object_tlv_types tlv_type)
+{
+ switch (tlv_type) {
+ case PCEP_OBJ_TLV_TYPE_NO_PATH_VECTOR:
+ return "NO_PATH_VECTOR";
+ case PCEP_OBJ_TLV_TYPE_OBJECTIVE_FUNCTION_LIST:
+ return "OBJECTIVE_FUNCTION_LIST";
+ case PCEP_OBJ_TLV_TYPE_VENDOR_INFO:
+ return "VENDOR_INFO";
+ case PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY:
+ return "STATEFUL_PCE_CAPABILITY";
+ case PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME:
+ return "SYMBOLIC_PATH_NAME";
+ case PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS:
+ return "IPV4_LSP_IDENTIFIERS";
+ case PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS:
+ return "IPV6_LSP_IDENTIFIERS";
+ case PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE:
+ return "LSP_ERROR_CODE";
+ case PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC:
+ return "RSVP_ERROR_SPEC";
+ case PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION:
+ return "LSP_DB_VERSION";
+ case PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID:
+ return "SPEAKER_ENTITY_ID";
+ case PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY:
+ return "SR_PCE_CAPABILITY";
+ case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
+ return "PATH_SETUP_TYPE";
+ case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE_CAPABILITY:
+ return "PATH_SETUP_TYPE_CAPABILITY";
+ case PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID:
+ return "SRPOLICY_POL_ID";
+ case PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_NAME:
+ return "SRPOLICY_POL_NAME";
+ case PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_ID:
+ return "SRPOLICY_CPATH_ID";
+ case PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_PREFERENCE:
+ return "SRPOLICY_CPATH_PREFERENCE";
+ case PCEP_OBJ_TLV_TYPE_UNKNOWN:
+ return "UNKNOWN";
+ case PCEP_OBJ_TLV_TYPE_ARBITRARY:
+ return "ARBITRARY";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_ro_type_name(enum pcep_ro_subobj_types ro_type)
+{
+ switch (ro_type) {
+
+ case RO_SUBOBJ_TYPE_IPV4:
+ return "IPV4";
+ case RO_SUBOBJ_TYPE_IPV6:
+ return "IPV6";
+ case RO_SUBOBJ_TYPE_LABEL:
+ return "LABEL";
+ case RO_SUBOBJ_TYPE_UNNUM:
+ return "UNNUM";
+ case RO_SUBOBJ_TYPE_ASN:
+ return "ASN";
+ case RO_SUBOBJ_TYPE_SR:
+ return "SR";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_nai_type_name(enum pcep_sr_subobj_nai nai_type)
+{
+ switch (nai_type) {
+ case PCEP_SR_SUBOBJ_NAI_ABSENT:
+ return "ABSENT";
+ case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
+ return "IPV4_NODE";
+ case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
+ return "IPV6_NODE";
+ case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
+ return "IPV4_ADJACENCY";
+ case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
+ return "IPV6_ADJACENCY";
+ case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
+ return "UNNUMBERED_IPV4_ADJACENCY";
+ case PCEP_SR_SUBOBJ_NAI_LINK_LOCAL_IPV6_ADJACENCY:
+ return "LINK_LOCAL_IPV6_ADJACENCY";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_metric_type_name(enum pcep_metric_types type)
+{
+ switch (type) {
+ case PCEP_METRIC_IGP:
+ return "IGP";
+ case PCEP_METRIC_TE:
+ return "TE";
+ case PCEP_METRIC_HOP_COUNT:
+ return "HOP_COUNT";
+ case PCEP_METRIC_AGGREGATE_BW:
+ return "AGGREGATE_BW";
+ case PCEP_METRIC_MOST_LOADED_LINK:
+ return "MOST_LOADED_LINK";
+ case PCEP_METRIC_CUMULATIVE_IGP:
+ return "CUMULATIVE_IGP";
+ case PCEP_METRIC_CUMULATIVE_TE:
+ return "CUMULATIVE_TE";
+ case PCEP_METRIC_P2MP_IGP:
+ return "P2MP_IGP";
+ case PCEP_METRIC_P2MP_TE:
+ return "P2MP_TE";
+ case PCEP_METRIC_P2MP_HOP_COUNT:
+ return "P2MP_HOP_COUNT";
+ case PCEP_METRIC_SEGMENT_ID_DEPTH:
+ return "SEGMENT_ID_DEPTH";
+ case PCEP_METRIC_PATH_DELAY:
+ return "PATH_DELAY";
+ case PCEP_METRIC_PATH_DELAY_VARIATION:
+ return "PATH_DELAY_VARIATION";
+ case PCEP_METRIC_PATH_LOSS:
+ return "PATH_LOSS";
+ case PCEP_METRIC_P2MP_PATH_DELAY:
+ return "P2MP_PATH_DELAY";
+ case PCEP_METRIC_P2MP_PATH_DELAY_VARIATION:
+ return "P2MP_PATH_DELAY_VARIATION";
+ case PCEP_METRIC_P2MP_PATH_LOSS:
+ return "P2MP_PATH_LOSS";
+ case PCEP_METRIC_NUM_PATH_ADAPTATIONS:
+ return "NUM_PATH_ADAPTATIONS";
+ case PCEP_METRIC_NUM_PATH_LAYERS:
+ return "NUM_PATH_LAYERS";
+ case PCEP_METRIC_DOMAIN_COUNT:
+ return "DOMAIN_COUNT";
+ case PCEP_METRIC_BORDER_NODE_COUNT:
+ return "BORDER_NODE_COUNT";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *pcep_nopath_tlv_err_code_name(enum pcep_nopath_tlv_err_codes type)
+{
+ switch (type) {
+ case PCEP_NOPATH_TLV_ERR_NO_TLV:
+ return "NO_TLV";
+ case PCEP_NOPATH_TLV_ERR_PCE_UNAVAILABLE:
+ return "PCE_UNAVAILABLE";
+ case PCEP_NOPATH_TLV_ERR_UNKNOWN_DST:
+ return "UNKNOWN_DST";
+ case PCEP_NOPATH_TLV_ERR_UNKNOWN_SRC:
+ return "UNKNOWN_SRC";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *format_objfun_set(uint32_t flags)
+{
+ int i, c;
+ PATHD_FORMAT_INIT();
+ for (i = 1, c = 0; i <= MAX_OBJFUN_TYPE; i++) {
+ if (CHECK_FLAG(flags, i)) {
+ if (c > 0)
+ PATHD_FORMAT(", %s", objfun_type_name(i));
+ else
+ PATHD_FORMAT("%s", objfun_type_name(i));
+ c++;
+ }
+ }
+ return PATHD_FORMAT_FINI();
+}
+
+
+const char *format_pcc_opts(struct pcc_opts *opts)
+{
+ PATHD_FORMAT_INIT();
+ _format_pcc_opts(0, opts);
+ return PATHD_FORMAT_FINI();
+}
+
+const char *format_pcc_state(struct pcc_state *state)
+{
+ PATHD_FORMAT_INIT();
+ _format_pcc_state(0, state);
+ return PATHD_FORMAT_FINI();
+}
+
+const char *format_ctrl_state(struct ctrl_state *state)
+{
+ PATHD_FORMAT_INIT();
+ _format_ctrl_state(0, state);
+ return PATHD_FORMAT_FINI();
+}
+
+const char *format_path(struct path *path)
+{
+ PATHD_FORMAT_INIT();
+ _format_path(0, path);
+ return PATHD_FORMAT_FINI();
+}
+
+const char *format_pcep_event(pcep_event *event)
+{
+ PATHD_FORMAT_INIT();
+ _format_pcep_event(0, event);
+ return PATHD_FORMAT_FINI();
+}
+
+const char *format_pcep_message(struct pcep_message *msg)
+{
+ PATHD_FORMAT_INIT();
+ _format_pcep_message(0, msg);
+ return PATHD_FORMAT_FINI();
+}
+
+void _format_pcc_opts(int ps, struct pcc_opts *opts)
+{
+ if (opts == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ if (IS_IPADDR_V4(&opts->addr)) {
+ PATHD_FORMAT("%*saddr_v4: %pI4\n", ps2, "",
+ &opts->addr.ipaddr_v4);
+ } else {
+ PATHD_FORMAT("%*saddr_v4: undefined", ps2, "");
+ }
+ if (IS_IPADDR_V6(&opts->addr)) {
+ PATHD_FORMAT("%*saddr_v6: %pI6\n", ps2, "",
+ &opts->addr.ipaddr_v6);
+ } else {
+ PATHD_FORMAT("%*saddr_v6: undefined", ps2, "");
+ }
+ PATHD_FORMAT("%*sport: %i\n", ps2, "", opts->port);
+ PATHD_FORMAT("%*smsd: %i\n", ps2, "", opts->msd);
+ }
+}
+
+void _format_pce_opts(int ps, struct pce_opts *opts)
+{
+ if (opts == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ if (IS_IPADDR_V6(&opts->addr)) {
+ PATHD_FORMAT("%*saddr: %pI6\n", ps2, "",
+ &opts->addr.ipaddr_v6);
+ } else {
+ PATHD_FORMAT("%*saddr: %pI4\n", ps2, "",
+ &opts->addr.ipaddr_v4);
+ }
+ PATHD_FORMAT("%*sport: %i\n", ps2, "", opts->port);
+ }
+}
+
+void _format_pcc_caps(int ps, struct pcep_caps *caps)
+{
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ PATHD_FORMAT("%*sis_stateful: %d\n", ps2, "", caps->is_stateful);
+}
+
+void _format_pcc_state(int ps, struct pcc_state *state)
+{
+ if (state == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ PATHD_FORMAT("%*sstatus: %s\n", ps2, "",
+ pcc_status_name(state->status));
+ PATHD_FORMAT("%*spcc_opts: ", ps2, "");
+ _format_pcc_opts(ps2, state->pcc_opts);
+ PATHD_FORMAT("%*spce_opts: ", ps2, "");
+ _format_pce_opts(ps2, state->pce_opts);
+ if (state->sess == NULL) {
+ PATHD_FORMAT("%*ssess: NULL\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*ssess: <PCC SESSION %p>\n", ps2, "",
+ state->sess);
+ }
+ PATHD_FORMAT("%*scaps: ", ps2, "");
+ _format_pcc_caps(ps2, &state->caps);
+ }
+}
+
+void _format_ctrl_state(int ps, struct ctrl_state *state)
+{
+ if (state == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int i;
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ int ps3 = ps2 + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ if (state->main == NULL) {
+ PATHD_FORMAT("%*smain: NULL\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*smain: <THREAD MASTER %p>\n", ps2, "",
+ state->main);
+ }
+ if (state->self == NULL) {
+ PATHD_FORMAT("%*sself: NULL\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*sself: <THREAD MASTER %p>\n", ps2, "",
+ state->self);
+ }
+ PATHD_FORMAT("%*spcc_count: %d\n", ps2, "", state->pcc_count);
+ PATHD_FORMAT("%*spcc:\n", ps2, "");
+ for (i = 0; i < MAX_PCC; i++) {
+ if (state->pcc[i]) {
+ PATHD_FORMAT("%*s- ", ps3 - 2, "");
+ _format_pcc_state(ps3, state->pcc[i]);
+ }
+ }
+ }
+}
+
+void _format_path(int ps, struct path *path)
+{
+ if (path == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ int ps3 = ps2 + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ PATHD_FORMAT("%*snbkey: \n", ps2, "");
+ PATHD_FORMAT("%*scolor: %u\n", ps3, "", path->nbkey.color);
+ switch (path->nbkey.endpoint.ipa_type) {
+ case IPADDR_V4:
+ PATHD_FORMAT("%*sendpoint: %pI4\n", ps3, "",
+ &path->nbkey.endpoint.ipaddr_v4);
+ break;
+ case IPADDR_V6:
+ PATHD_FORMAT("%*sendpoint: %pI6\n", ps3, "",
+ &path->nbkey.endpoint.ipaddr_v6);
+ break;
+ default:
+ PATHD_FORMAT("%*sendpoint: NONE\n", ps3, "");
+ break;
+ }
+ PATHD_FORMAT("%*spreference: %u\n", ps3, "",
+ path->nbkey.preference);
+
+ if (path->sender.ipa_type == IPADDR_V4) {
+ PATHD_FORMAT("%*ssender: %pI4\n", ps2, "",
+ &path->sender.ipaddr_v4);
+ } else if (path->sender.ipa_type == IPADDR_V6) {
+ PATHD_FORMAT("%*ssender: %pI6\n", ps2, "",
+ &path->sender.ipaddr_v6);
+ } else {
+ PATHD_FORMAT("%*ssender: UNDEFINED\n", ps2, "");
+ }
+ if (path->pcc_addr.ipa_type == IPADDR_V4) {
+ PATHD_FORMAT("%*spcc_addr: %pI4\n", ps2, "",
+ &path->pcc_addr.ipaddr_v4);
+ } else if (path->pcc_addr.ipa_type == IPADDR_V6) {
+ PATHD_FORMAT("%*spcc_addr: %pI6\n", ps2, "",
+ &path->pcc_addr.ipaddr_v6);
+ } else {
+ PATHD_FORMAT("%*spcc_addr: UNDEFINED\n", ps2, "");
+ }
+ PATHD_FORMAT("%*spcc_id: %u\n", ps2, "", path->pcc_id);
+ PATHD_FORMAT("%*screate_origin: %s (%u)\n", ps2, "",
+ srte_protocol_origin_name(path->create_origin),
+ path->create_origin);
+ PATHD_FORMAT("%*supdate_origin: %s (%u)\n", ps2, "",
+ srte_protocol_origin_name(path->update_origin),
+ path->update_origin);
+ if (path->originator != NULL) {
+ PATHD_FORMAT("%*soriginator: %s\n", ps2, "",
+ path->originator);
+ } else {
+ PATHD_FORMAT("%*soriginator: UNDEFINED\n", ps2, "");
+ }
+ PATHD_FORMAT("%*stype: %s (%u)\n", ps2, "",
+ srte_candidate_type_name(path->type), path->type);
+ PATHD_FORMAT("%*splsp_id: %u\n", ps2, "", path->plsp_id);
+ if (path->name == NULL) {
+ PATHD_FORMAT("%*sname: NULL\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*sname: %s\n", ps2, "", path->name);
+ }
+ PATHD_FORMAT("%*ssrp_id: %u\n", ps2, "", path->srp_id);
+ PATHD_FORMAT("%*sreq_id: %u\n", ps2, "", path->req_id);
+ PATHD_FORMAT("%*sstatus: %s (%u)\n", ps2, "",
+ pcep_lsp_status_name(path->status), path->status);
+ PATHD_FORMAT("%*sdo_remove: %u\n", ps2, "", path->do_remove);
+ PATHD_FORMAT("%*sgo_active: %u\n", ps2, "", path->go_active);
+ PATHD_FORMAT("%*swas_created: %u\n", ps2, "",
+ path->was_created);
+ PATHD_FORMAT("%*swas_removed: %u\n", ps2, "",
+ path->was_removed);
+ PATHD_FORMAT("%*sis_synching: %u\n", ps2, "",
+ path->is_synching);
+ PATHD_FORMAT("%*sis_delegated: %u\n", ps2, "",
+ path->is_delegated);
+ PATHD_FORMAT("%*shas_bandwidth: %u\n", ps2, "",
+ path->has_bandwidth);
+ if (path->has_bandwidth) {
+ PATHD_FORMAT("%*senforce_bandwidth: %u\n", ps2, "",
+ path->enforce_bandwidth);
+ PATHD_FORMAT("%*sbandwidth: %f\n", ps2, "",
+ path->bandwidth);
+ }
+ PATHD_FORMAT("%*shas_pcc_objfun: %u\n", ps2, "",
+ path->has_pcc_objfun);
+ if (path->has_pcc_objfun) {
+ PATHD_FORMAT("%*senforce_pcc_objfun: %d\n", ps2, "",
+ path->enforce_pcc_objfun);
+ PATHD_FORMAT("%*spcc_objfun: %s (%u)\n", ps2, "",
+ objfun_type_name(path->pcc_objfun),
+ path->pcc_objfun);
+ }
+ PATHD_FORMAT("%*shas_pce_objfun: %u\n", ps2, "",
+ path->has_pce_objfun);
+ if (path->has_pce_objfun)
+ PATHD_FORMAT("%*spce_objfun: %s (%u)\n", ps2, "",
+ objfun_type_name(path->pce_objfun),
+ path->pce_objfun);
+ PATHD_FORMAT("%*shas_affinity_filters: %u\n", ps2, "",
+ path->has_affinity_filters);
+ if (path->has_affinity_filters) {
+ PATHD_FORMAT("%*sexclude_any: 0x%08x\n", ps2, "",
+ path->affinity_filters
+ [AFFINITY_FILTER_EXCLUDE_ANY - 1]);
+ PATHD_FORMAT("%*sinclude_any: 0x%08x\n", ps2, "",
+ path->affinity_filters
+ [AFFINITY_FILTER_INCLUDE_ANY - 1]);
+ PATHD_FORMAT("%*sinclude_all: 0x%08x\n", ps2, "",
+ path->affinity_filters
+ [AFFINITY_FILTER_INCLUDE_ALL - 1]);
+ }
+
+ if (path->first_hop == NULL) {
+ PATHD_FORMAT("%*shops: []\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*shops: \n", ps2, "");
+ for (struct path_hop *hop = path->first_hop;
+ hop != NULL; hop = hop->next) {
+ PATHD_FORMAT("%*s- ", ps3 - 2, "");
+ _format_path_hop(ps3, hop);
+ }
+ }
+ if (path->first_metric == NULL) {
+ PATHD_FORMAT("%*smetrics: []\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*smetrics: \n", ps2, "");
+ for (struct path_metric *metric = path->first_metric;
+ NULL != metric; metric = metric->next) {
+ PATHD_FORMAT("%*s- ", ps3 - 2, "");
+ _format_path_metric(ps3, metric);
+ }
+ }
+ }
+}
+
+void _format_path_metric(int ps, struct path_metric *metric)
+{
+ PATHD_FORMAT("type: %s (%u)\n", pcep_metric_type_name(metric->type),
+ metric->type);
+ PATHD_FORMAT("%*senforce: %u\n", ps, "", metric->enforce);
+ PATHD_FORMAT("%*sis_bound: %u\n", ps, "", metric->is_bound);
+ PATHD_FORMAT("%*sis_computed: %u\n", ps, "", metric->is_computed);
+ PATHD_FORMAT("%*svalue: %f\n", ps, "", metric->value);
+}
+
+void _format_path_hop(int ps, struct path_hop *hop)
+{
+ PATHD_FORMAT("is_loose: %u\n", hop->is_loose);
+ PATHD_FORMAT("%*shas_sid: %u\n", ps, "", hop->has_sid);
+
+ if (hop->has_sid) {
+ PATHD_FORMAT("%*sis_mpls: %u\n", ps, "", hop->is_mpls);
+ if (hop->is_mpls) {
+ PATHD_FORMAT("%*shas_attribs: %u\n", ps, "",
+ hop->has_attribs);
+ PATHD_FORMAT("%*slabel: %u\n", ps, "",
+ hop->sid.mpls.label);
+ if (hop->has_attribs) {
+ PATHD_FORMAT("%*straffic_class: %u\n", ps, "",
+ hop->sid.mpls.traffic_class);
+ PATHD_FORMAT("%*sis_bottom: %u\n", ps, "",
+ hop->sid.mpls.is_bottom);
+ PATHD_FORMAT("%*sttl: %u\n", ps, "",
+ hop->sid.mpls.ttl);
+ }
+ } else {
+ PATHD_FORMAT("%*sSID: %u\n", ps, "", hop->sid.value);
+ }
+ }
+
+ PATHD_FORMAT("%*shas_nai: %u\n", ps, "", hop->has_nai);
+ if (hop->has_nai) {
+ PATHD_FORMAT("%*snai_type: %s (%u)\n", ps, "",
+ pcep_nai_type_name(hop->nai.type), hop->nai.type);
+ switch (hop->nai.type) {
+ case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
+ PATHD_FORMAT("%*sNAI: %pI4\n", ps, "",
+ &hop->nai.local_addr.ipaddr_v4);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
+ PATHD_FORMAT("%*sNAI: %pI6\n", ps, "",
+ &hop->nai.local_addr.ipaddr_v6);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
+ PATHD_FORMAT("%*sNAI: %pI4/%pI4\n", ps, "",
+ &hop->nai.local_addr.ipaddr_v4,
+ &hop->nai.remote_addr.ipaddr_v4);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
+ PATHD_FORMAT("%*sNAI: %pI6/%pI6\n", ps, "",
+ &hop->nai.local_addr.ipaddr_v6,
+ &hop->nai.remote_addr.ipaddr_v6);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
+ PATHD_FORMAT("%*sNAI: %pI6(%u)/%pI6(%u)\n", ps, "",
+ &hop->nai.local_addr.ipaddr_v6,
+ hop->nai.local_iface,
+ &hop->nai.remote_addr.ipaddr_v6,
+ hop->nai.remote_iface);
+ break;
+ default:
+ PATHD_FORMAT("%*sNAI: UNSUPPORTED\n", ps, "");
+ break;
+ }
+ }
+}
+
+void _format_pcep_event(int ps, pcep_event *event)
+{
+ if (event == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ PATHD_FORMAT("%*sevent_type: %s\n", ps2, "",
+ pcep_event_type_name(event->event_type));
+ PATHD_FORMAT("%*sevent_time: %s", ps2, "",
+ ctime(&event->event_time));
+ if (event->session == NULL) {
+ PATHD_FORMAT("%*ssession: NULL\n", ps2, "");
+ } else {
+ PATHD_FORMAT("%*ssession: <PCC SESSION %p>\n", ps2, "",
+ event->session);
+ }
+ PATHD_FORMAT("%*smessage: ", ps2, "");
+ _format_pcep_message(ps2, event->message);
+ }
+}
+
+void _format_pcep_message(int ps, struct pcep_message *msg)
+{
+ if (msg == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ PATHD_FORMAT("\n");
+ PATHD_FORMAT("%*spcep_version: %u\n", ps2, "",
+ msg->msg_header->pcep_version);
+ PATHD_FORMAT("%*stype: %s (%u)\n", ps2, "",
+ pcep_message_type_name(msg->msg_header->type),
+ msg->msg_header->type);
+ PATHD_FORMAT("%*sobjects: ", ps2, "");
+ _format_pcep_objects(ps2, msg->obj_list);
+ }
+}
+
+void _format_pcep_objects(int ps, double_linked_list *objs)
+{
+ if (objs == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ double_linked_list_node *node;
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ int i;
+
+ if (objs->num_entries == 0) {
+ PATHD_FORMAT("[]\n");
+ return;
+ }
+
+ PATHD_FORMAT("\n");
+ for (node = objs->head, i = 0; node != NULL;
+ node = node->next_node, i++) {
+ struct pcep_object_header *obj =
+ (struct pcep_object_header *)node->data;
+ PATHD_FORMAT("%*s- ", ps2 - 2, "");
+ _format_pcep_object(ps2, obj);
+ }
+ }
+}
+
+void _format_pcep_object(int ps, struct pcep_object_header *obj)
+{
+ if (obj == NULL) {
+ PATHD_FORMAT("NULL\n");
+ } else {
+ PATHD_FORMAT("object_class: %s (%u)\n",
+ pcep_object_class_name(obj->object_class),
+ obj->object_class);
+ PATHD_FORMAT("%*sobject_type: %s (%u)\n", ps, "",
+ pcep_object_type_name(obj->object_class,
+ obj->object_type),
+ obj->object_type);
+ PATHD_FORMAT("%*sflag_p: %u\n", ps, "", obj->flag_p);
+ PATHD_FORMAT("%*sflag_i: %u\n", ps, "", obj->flag_i);
+ _format_pcep_object_details(ps, obj);
+ _format_pcep_object_tlvs(ps, obj);
+ }
+}
+
+void _format_pcep_object_details(int ps, struct pcep_object_header *obj)
+{
+ switch (TUP(obj->object_class, obj->object_type)) {
+ case TUP(PCEP_OBJ_CLASS_ERROR, PCEP_OBJ_TYPE_ERROR):
+ _format_pcep_object_error(ps, (struct pcep_object_error *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_OPEN, PCEP_OBJ_TYPE_OPEN):
+ _format_pcep_object_open(ps, (struct pcep_object_open *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_RP, PCEP_OBJ_TYPE_RP):
+ _format_pcep_object_rp(ps, (struct pcep_object_rp *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_SRP, PCEP_OBJ_TYPE_SRP):
+ _format_pcep_object_srp(ps, (struct pcep_object_srp *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_LSP, PCEP_OBJ_TYPE_LSP):
+ _format_pcep_object_lsp(ps, (struct pcep_object_lsp *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_LSPA, PCEP_OBJ_TYPE_LSPA):
+ _format_pcep_object_lspa(ps, (struct pcep_object_lspa *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_ENDPOINTS, PCEP_OBJ_TYPE_ENDPOINT_IPV4):
+ _format_pcep_object_ipv4_endpoint(
+ ps, (struct pcep_object_endpoints_ipv4 *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_ERO, PCEP_OBJ_TYPE_ERO):
+ _format_pcep_object_ro(ps, (struct pcep_object_ro *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_METRIC, PCEP_OBJ_TYPE_METRIC):
+ _format_pcep_object_metric(ps,
+ (struct pcep_object_metric *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_REQ):
+ case TUP(PCEP_OBJ_CLASS_BANDWIDTH, PCEP_OBJ_TYPE_BANDWIDTH_CISCO):
+ _format_pcep_object_bandwidth(
+ ps, (struct pcep_object_bandwidth *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_NOPATH, PCEP_OBJ_TYPE_NOPATH):
+ _format_pcep_object_nopath(ps,
+ (struct pcep_object_nopath *)obj);
+ break;
+ case TUP(PCEP_OBJ_CLASS_OF, PCEP_OBJ_TYPE_OF):
+ _format_pcep_object_objfun(
+ ps, (struct pcep_object_objective_function *)obj);
+ break;
+ default:
+ PATHD_FORMAT("%*s...\n", ps, "");
+ break;
+ }
+}
+
+void _format_pcep_object_error(int ps, struct pcep_object_error *obj)
+{
+ PATHD_FORMAT("%*serror_type: %s (%u)\n", ps, "",
+ pcep_error_type_name(obj->error_type), obj->error_type);
+ PATHD_FORMAT("%*serror_value: %s (%u)\n", ps, "",
+ pcep_error_value_name(obj->error_type, obj->error_value),
+ obj->error_value);
+}
+
+
+void _format_pcep_object_open(int ps, struct pcep_object_open *obj)
+{
+ PATHD_FORMAT("%*sopen_version: %u\n", ps, "", obj->open_version);
+ PATHD_FORMAT("%*sopen_keepalive: %u\n", ps, "", obj->open_keepalive);
+ PATHD_FORMAT("%*sopen_deadtimer: %u\n", ps, "", obj->open_deadtimer);
+ PATHD_FORMAT("%*sopen_sid: %u\n", ps, "", obj->open_sid);
+}
+
+void _format_pcep_object_rp(int ps, struct pcep_object_rp *obj)
+{
+ PATHD_FORMAT("%*spriority: %u\n", ps, "", obj->priority);
+ PATHD_FORMAT("%*sflag_reoptimization: %u\n", ps, "",
+ obj->flag_reoptimization);
+ PATHD_FORMAT("%*sflag_bidirectional: %u\n", ps, "",
+ obj->flag_bidirectional);
+ PATHD_FORMAT("%*sflag_strict: %u\n", ps, "", obj->flag_strict);
+ PATHD_FORMAT("%*sflag_of: %u\n", ps, "", obj->flag_of);
+ PATHD_FORMAT("%*srequest_id: %u\n", ps, "", obj->request_id);
+}
+
+
+void _format_pcep_object_srp(int ps, struct pcep_object_srp *obj)
+{
+ PATHD_FORMAT("%*sflag_lsp_remove: %u\n", ps, "", obj->flag_lsp_remove);
+ PATHD_FORMAT("%*ssrp_id_number: %u\n", ps, "", obj->srp_id_number);
+}
+
+void _format_pcep_object_lsp(int ps, struct pcep_object_lsp *obj)
+{
+ PATHD_FORMAT("%*splsp_id: %u\n", ps, "", obj->plsp_id);
+ PATHD_FORMAT("%*sstatus: %s\n", ps, "",
+ pcep_lsp_status_name(obj->operational_status));
+ PATHD_FORMAT("%*sflag_d: %u\n", ps, "", obj->flag_d);
+ PATHD_FORMAT("%*sflag_s: %u\n", ps, "", obj->flag_s);
+ PATHD_FORMAT("%*sflag_r: %u\n", ps, "", obj->flag_r);
+ PATHD_FORMAT("%*sflag_a: %u\n", ps, "", obj->flag_a);
+ PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
+}
+
+void _format_pcep_object_lspa(int ps, struct pcep_object_lspa *obj)
+{
+ PATHD_FORMAT("%*slspa_exclude_any: 0x%08x\n", ps, "",
+ obj->lspa_exclude_any);
+ PATHD_FORMAT("%*slspa_include_any: 0x%08x\n", ps, "",
+ obj->lspa_include_any);
+ PATHD_FORMAT("%*slspa_include_all: 0x%08x\n", ps, "",
+ obj->lspa_include_all);
+ PATHD_FORMAT("%*ssetup_priority: %u\n", ps, "", obj->setup_priority);
+ PATHD_FORMAT("%*sholding_priority: %u\n", ps, "",
+ obj->holding_priority);
+ PATHD_FORMAT("%*sflag_local_protection: %u\n", ps, "",
+ obj->flag_local_protection);
+}
+
+void _format_pcep_object_ipv4_endpoint(int ps,
+ struct pcep_object_endpoints_ipv4 *obj)
+{
+ PATHD_FORMAT("%*ssrc_ipv4: %pI4\n", ps, "", &obj->src_ipv4);
+ PATHD_FORMAT("%*sdst_ipv4: %pI4\n", ps, "", &obj->dst_ipv4);
+}
+
+void _format_pcep_object_metric(int ps, struct pcep_object_metric *obj)
+{
+ PATHD_FORMAT("%*stype: %s (%u)\n", ps, "",
+ pcep_metric_type_name(obj->type), obj->type);
+ PATHD_FORMAT("%*sflag_b: %u\n", ps, "", obj->flag_b);
+ PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
+ PATHD_FORMAT("%*svalue: %f\n", ps, "", obj->value);
+}
+
+void _format_pcep_object_bandwidth(int ps, struct pcep_object_bandwidth *obj)
+{
+ PATHD_FORMAT("%*sbandwidth: %f\n", ps, "", obj->bandwidth);
+}
+
+void _format_pcep_object_nopath(int ps, struct pcep_object_nopath *obj)
+{
+ PATHD_FORMAT("%*sni: %u\n", ps, "", obj->ni);
+ PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
+ PATHD_FORMAT("%*serr_code: %s (%u)\n", ps, "",
+ pcep_nopath_tlv_err_code_name(obj->err_code),
+ obj->err_code);
+}
+
+void _format_pcep_object_objfun(int ps,
+ struct pcep_object_objective_function *obj)
+{
+ PATHD_FORMAT("%*sof_code: %s (%u)\n", ps, "",
+ objfun_type_name(obj->of_code), obj->of_code);
+}
+
+void _format_pcep_object_ro(int ps, struct pcep_object_ro *obj)
+{
+ double_linked_list *obj_list = obj->sub_objects;
+ double_linked_list_node *node;
+ struct pcep_object_ro_subobj *sub_obj;
+
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ int i;
+
+ if ((obj_list == NULL) || (obj_list->num_entries == 0)) {
+ PATHD_FORMAT("%*ssub_objects: []\n", ps, "");
+ return;
+ }
+
+ PATHD_FORMAT("%*ssub_objects:\n", ps, "");
+
+ for (node = obj_list->head, i = 0; node != NULL;
+ node = node->next_node, i++) {
+ sub_obj = (struct pcep_object_ro_subobj *)node->data;
+ PATHD_FORMAT("%*s- flag_subobj_loose_hop: %u\n", ps2 - 2, "",
+ sub_obj->flag_subobj_loose_hop);
+ PATHD_FORMAT("%*sro_subobj_type: %s (%u)\n", ps2, "",
+ pcep_ro_type_name(sub_obj->ro_subobj_type),
+ sub_obj->ro_subobj_type);
+ _format_pcep_object_ro_details(ps2, sub_obj);
+ }
+}
+
+void _format_pcep_object_ro_details(int ps, struct pcep_object_ro_subobj *ro)
+{
+ switch (ro->ro_subobj_type) {
+ case RO_SUBOBJ_TYPE_IPV4:
+ _format_pcep_object_ro_ipv4(ps,
+ (struct pcep_ro_subobj_ipv4 *)ro);
+ break;
+ case RO_SUBOBJ_TYPE_SR:
+ _format_pcep_object_ro_sr(ps, (struct pcep_ro_subobj_sr *)ro);
+ break;
+ default:
+ PATHD_FORMAT("%*s...\n", ps, "");
+ break;
+ }
+}
+
+void _format_pcep_object_ro_ipv4(int ps, struct pcep_ro_subobj_ipv4 *obj)
+{
+ PATHD_FORMAT("%*sip_addr: %pI4\n", ps, "", &obj->ip_addr);
+ PATHD_FORMAT("%*sprefix_length: %u\n", ps, "", obj->prefix_length);
+ PATHD_FORMAT("%*sflag_local_protection: %u\n", ps, "",
+ obj->flag_local_protection);
+}
+
+void _format_pcep_object_ro_sr(int ps, struct pcep_ro_subobj_sr *obj)
+{
+ PATHD_FORMAT("%*snai_type = %s (%u)\n", ps, "",
+ pcep_nai_type_name(obj->nai_type), obj->nai_type);
+ PATHD_FORMAT("%*sflag_f: %u\n", ps, "", obj->flag_f);
+ PATHD_FORMAT("%*sflag_s: %u\n", ps, "", obj->flag_s);
+ PATHD_FORMAT("%*sflag_c: %u\n", ps, "", obj->flag_c);
+ PATHD_FORMAT("%*sflag_m: %u\n", ps, "", obj->flag_m);
+
+ if (!obj->flag_s) {
+ PATHD_FORMAT("%*sSID: %u\n", ps, "", obj->sid);
+ if (obj->flag_m) {
+ PATHD_FORMAT("%*slabel: %u\n", ps, "",
+ GET_SR_ERO_SID_LABEL(obj->sid));
+ if (obj->flag_c) {
+ PATHD_FORMAT("%*sTC: %u\n", ps, "",
+ GET_SR_ERO_SID_TC(obj->sid));
+ PATHD_FORMAT("%*sS: %u\n", ps, "",
+ GET_SR_ERO_SID_S(obj->sid));
+ PATHD_FORMAT("%*sTTL: %u\n", ps, "",
+ GET_SR_ERO_SID_TTL(obj->sid));
+ }
+ }
+ }
+
+ if (!obj->flag_f) {
+ struct in_addr *laddr4, *raddr4;
+ struct in6_addr *laddr6, *raddr6;
+ uint32_t *liface, *riface;
+ assert(obj->nai_list != NULL);
+ double_linked_list_node *n = obj->nai_list->head;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ switch (obj->nai_type) {
+ case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
+ laddr4 = (struct in_addr *)n->data;
+ PATHD_FORMAT("%*sNAI: %pI4\n", ps, "", laddr4);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
+ laddr6 = (struct in6_addr *)n->data;
+ PATHD_FORMAT("%*sNAI: %pI6\n", ps, "", laddr6);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
+ assert(n->next_node != NULL);
+ assert(n->next_node->data != NULL);
+ laddr4 = (struct in_addr *)n->data;
+ raddr4 = (struct in_addr *)n->next_node->data;
+ PATHD_FORMAT("%*sNAI: %pI4/%pI4\n", ps, "", laddr4,
+ raddr4);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
+ assert(n->next_node != NULL);
+ assert(n->next_node->data != NULL);
+ laddr6 = (struct in6_addr *)n->data;
+ raddr6 = (struct in6_addr *)n->next_node->data;
+ PATHD_FORMAT("%*sNAI: %pI6/%pI6\n", ps, "", laddr6,
+ raddr6);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
+ laddr4 = (struct in_addr *)n->data;
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ liface = (uint32_t *)n->data;
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ raddr4 = (struct in_addr *)n->data;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ riface = (uint32_t *)n->data;
+ PATHD_FORMAT("%*sNAI: %pI4(%u)/%pI4(%u)\n", ps, "",
+ laddr4, *liface, raddr4, *riface);
+ break;
+ default:
+ PATHD_FORMAT("%*sNAI: UNSUPPORTED\n", ps, "");
+ break;
+ }
+ }
+}
+
+void _format_pcep_object_tlvs(int ps, struct pcep_object_header *obj)
+{
+ double_linked_list *tlv_list = obj->tlv_list;
+ struct pcep_object_tlv_header *tlv;
+ double_linked_list_node *node;
+ int ps2 = ps + DEBUG_IDENT_SIZE;
+ int i = 0;
+
+ if (tlv_list == NULL)
+ return;
+ if (tlv_list->num_entries == 0) {
+ PATHD_FORMAT("%*stlvs: []\n", ps, "");
+ return;
+ }
+
+ PATHD_FORMAT("%*stlvs:\n", ps, "");
+
+ for (node = tlv_list->head, i = 0; node != NULL;
+ node = node->next_node, i++) {
+ tlv = (struct pcep_object_tlv_header *)node->data;
+ PATHD_FORMAT("%*s- ", ps2 - 2, "");
+ _format_pcep_object_tlv(ps2, tlv);
+ }
+}
+
+void _format_pcep_object_tlv(int ps, struct pcep_object_tlv_header *tlv_header)
+{
+ PATHD_FORMAT("type: %s (%u)\n", pcep_tlv_type_name(tlv_header->type),
+ tlv_header->type);
+ _format_pcep_object_tlv_details(ps, tlv_header);
+}
+
+void _format_pcep_object_tlv_details(int ps,
+ struct pcep_object_tlv_header *tlv_header)
+{
+ switch (tlv_header->type) {
+ case PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME:
+ _format_pcep_object_tlv_symbolic_path_name(
+ ps, (struct pcep_object_tlv_symbolic_path_name *)
+ tlv_header);
+ break;
+ case PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY:
+ _format_pcep_object_tlv_stateful_pce_capability(
+ ps, (struct pcep_object_tlv_stateful_pce_capability *)
+ tlv_header);
+ break;
+ case PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY:
+ _format_pcep_object_tlv_sr_pce_capability(
+ ps,
+ (struct pcep_object_tlv_sr_pce_capability *)tlv_header);
+ break;
+ case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
+ _format_pcep_object_tlv_path_setup_type(
+ ps,
+ (struct pcep_object_tlv_path_setup_type *)tlv_header);
+ break;
+ default:
+ PATHD_FORMAT("%*s...\n", ps, "");
+ break;
+ }
+}
+
+void _format_pcep_object_tlv_symbolic_path_name(
+ int ps, struct pcep_object_tlv_symbolic_path_name *tlv)
+{
+ PATHD_FORMAT("%*ssymbolic_path_name: %.*s\n", ps, "",
+ tlv->symbolic_path_name_length, tlv->symbolic_path_name);
+}
+
+void _format_pcep_object_tlv_stateful_pce_capability(
+ int ps, struct pcep_object_tlv_stateful_pce_capability *tlv)
+{
+ PATHD_FORMAT("%*sflag_u_lsp_update_capability: %u\n", ps, "",
+ tlv->flag_u_lsp_update_capability);
+ PATHD_FORMAT("%*sflag_s_include_db_version: %u\n", ps, "",
+ tlv->flag_s_include_db_version);
+ PATHD_FORMAT("%*sflag_i_lsp_instantiation_capability: %u\n", ps, "",
+ tlv->flag_i_lsp_instantiation_capability);
+ PATHD_FORMAT("%*sflag_t_triggered_resync: %u\n", ps, "",
+ tlv->flag_t_triggered_resync);
+ PATHD_FORMAT("%*sflag_d_delta_lsp_sync: %u\n", ps, "",
+ tlv->flag_d_delta_lsp_sync);
+ PATHD_FORMAT("%*sflag_f_triggered_initial_sync: %u\n", ps, "",
+ tlv->flag_f_triggered_initial_sync);
+}
+
+void _format_pcep_object_tlv_sr_pce_capability(
+ int ps, struct pcep_object_tlv_sr_pce_capability *tlv)
+{
+
+ PATHD_FORMAT("%*sflag_n: %u\n", ps, "", tlv->flag_n);
+ PATHD_FORMAT("%*sflag_x: %u\n", ps, "", tlv->flag_x);
+ PATHD_FORMAT("%*smax_sid_depth: %u\n", ps, "", tlv->max_sid_depth);
+}
+
+void _format_pcep_object_tlv_path_setup_type(
+ int ps, struct pcep_object_tlv_path_setup_type *tlv)
+{
+ PATHD_FORMAT("%*spath_setup_type: %u\n", ps, "", tlv->path_setup_type);
+}
diff --git a/pathd/path_pcep_debug.h b/pathd/path_pcep_debug.h
new file mode 100644
index 0000000..bc78c21
--- /dev/null
+++ b/pathd/path_pcep_debug.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_DEBUG_H_
+#define _PATH_PCEP_DEBUG_H_
+
+#include "pathd/path_debug.h"
+#include "pceplib/pcep_pcc_api.h"
+#include "pceplib/pcep_msg_objects.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_controller.h"
+#include "pathd/path_pcep_pcc.h"
+#include "pathd/path_pcep_lib.h"
+
+const char *pcc_status_name(enum pcc_status status);
+
+const char *pcep_error_type_name(enum pcep_error_type error_type);
+const char *pcep_error_value_name(enum pcep_error_type error_type,
+ enum pcep_error_value error_value);
+const char *pcep_event_type_name(pcep_event_type event_type);
+const char *pcep_message_type_name(enum pcep_message_types pcep_message_type);
+const char *pcep_object_class_name(enum pcep_object_classes obj_class);
+const char *pcep_object_type_name(enum pcep_object_classes obj_class,
+ enum pcep_object_types obj_type);
+const char *pcep_lsp_status_name(enum pcep_lsp_operational_status status);
+const char *pcep_tlv_type_name(enum pcep_object_tlv_types tlv_type);
+const char *pcep_ro_type_name(enum pcep_ro_subobj_types ro_type);
+const char *pcep_nai_type_name(enum pcep_sr_subobj_nai nai_type);
+const char *pcep_metric_type_name(enum pcep_metric_types type);
+const char *pcep_nopath_tlv_err_code_name(enum pcep_nopath_tlv_err_codes code);
+
+const char *format_objfun_set(uint32_t flags);
+const char *format_pcc_opts(struct pcc_opts *ops);
+const char *format_pcc_state(struct pcc_state *state);
+const char *format_ctrl_state(struct ctrl_state *state);
+const char *format_path(struct path *path);
+const char *format_pcep_event(pcep_event *event);
+const char *format_pcep_message(struct pcep_message *msg);
+
+#endif // _PATH_PCEP_DEBUG_H_
diff --git a/pathd/path_pcep_lib.c b/pathd/path_pcep_lib.c
new file mode 100644
index 0000000..8e3565d
--- /dev/null
+++ b/pathd/path_pcep_lib.c
@@ -0,0 +1,1266 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "memory.h"
+
+#include <debug.h>
+#include "pceplib/pcep_utils_counters.h"
+#include "pceplib/pcep_timers.h"
+#include "pathd/path_errors.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_lib.h"
+#include "pathd/path_pcep_debug.h"
+
+DEFINE_MTYPE_STATIC(PATHD, PCEPLIB_INFRA, "PCEPlib Infrastructure");
+DEFINE_MTYPE_STATIC(PATHD, PCEPLIB_MESSAGES, "PCEPlib PCEP Messages");
+
+#define CLASS_TYPE(CLASS, TYPE) (((CLASS) << 16) | (TYPE))
+#define DEFAULT_LSAP_SETUP_PRIO 4
+#define DEFAULT_LSAP_HOLDING_PRIO 4
+#define DEFAULT_LSAP_LOCAL_PRETECTION false
+#define MAX_PATH_NAME_SIZE 255
+
+/* pceplib logging callback */
+static int pceplib_logging_cb(int level, const char *fmt, va_list args);
+
+/* Socket callbacks */
+static int pcep_lib_pceplib_socket_read_cb(void *fpt, void **thread, int fd,
+ void *payload);
+static int pcep_lib_pceplib_socket_write_cb(void *fpt, void **thread, int fd,
+ void *payload);
+static void pcep_lib_socket_read_ready(struct thread *thread);
+static void pcep_lib_socket_write_ready(struct thread *thread);
+
+/* pceplib pcep_event callbacks */
+static void pcep_lib_pceplib_event_cb(void *fpt, pcep_event *event);
+
+/* pceplib pthread creation callback */
+static int pcep_lib_pthread_create_cb(pthread_t *pthread_id,
+ const pthread_attr_t *attr,
+ void *(*start_routine)(void *),
+ void *data, const char *thread_name);
+void *pcep_lib_pthread_start_passthrough(void *data);
+int pcep_lib_pthread_stop_cb(struct frr_pthread *, void **);
+
+/* Internal functions */
+static double_linked_list *pcep_lib_format_path(struct pcep_caps *caps,
+ struct path *path);
+static void pcep_lib_format_constraints(struct path *path,
+ double_linked_list *objs);
+static void pcep_lib_parse_open(struct pcep_caps *caps,
+ struct pcep_object_open *open);
+static void
+pcep_lib_parse_open_pce_capability(struct pcep_caps *caps,
+ struct pcep_object_tlv_header *tlv_header);
+static void
+pcep_lib_parse_open_objfun_list(struct pcep_caps *caps,
+ struct pcep_object_tlv_header *tlv_header);
+static void pcep_lib_parse_rp(struct path *path, struct pcep_object_rp *rp);
+static void pcep_lib_parse_srp(struct path *path, struct pcep_object_srp *srp);
+static void pcep_lib_parse_lsp(struct path *path, struct pcep_object_lsp *lsp);
+static void pcep_lib_parse_lspa(struct path *path,
+ struct pcep_object_lspa *lspa);
+static void pcep_lib_parse_lsp_symbolic_name(
+ struct path *path, struct pcep_object_tlv_symbolic_path_name *tlv);
+static void pcep_lib_parse_metric(struct path *path,
+ struct pcep_object_metric *obj);
+static void
+pcep_lib_parse_endpoints_ipv4(struct path *path,
+ struct pcep_object_endpoints_ipv4 *obj);
+static void
+pcep_lib_parse_endpoints_ipv6(struct path *path,
+ struct pcep_object_endpoints_ipv6 *obj);
+static void pcep_lib_parse_vendor_info(struct path *path,
+ struct pcep_object_vendor_info *obj);
+static void pcep_lib_parse_ero(struct path *path, struct pcep_object_ro *ero);
+static struct path_hop *pcep_lib_parse_ero_sr(struct path_hop *next,
+ struct pcep_ro_subobj_sr *sr);
+static struct counters_group *copy_counter_group(struct counters_group *from);
+static struct counters_subgroup *
+copy_counter_subgroup(struct counters_subgroup *from);
+static struct counter *copy_counter(struct counter *from);
+static void free_counter_group(struct counters_group *group);
+static void free_counter_subgroup(struct counters_subgroup *subgroup);
+static void free_counter(struct counter *counter);
+
+struct pcep_lib_pthread_passthrough_data {
+ void *(*start_routine)(void *data);
+ void *data;
+};
+
+/* ------------ API Functions ------------ */
+
+int pcep_lib_initialize(struct frr_pthread *fpt)
+{
+ PCEP_DEBUG("Initializing pceplib");
+
+ /* Register pceplib logging callback */
+ register_logger(pceplib_logging_cb);
+
+ /* Its ok that this object goes out of scope, as it
+ * wont be stored, and its values will be copied */
+ struct pceplib_infra_config infra = {
+ /* Memory infrastructure */
+ .pceplib_infra_mt = MTYPE_PCEPLIB_INFRA,
+ .pceplib_messages_mt = MTYPE_PCEPLIB_MESSAGES,
+ .malloc_func = (pceplib_malloc_func)qmalloc,
+ .calloc_func = (pceplib_calloc_func)qcalloc,
+ .realloc_func = (pceplib_realloc_func)qrealloc,
+ .strdup_func = (pceplib_strdup_func)qstrdup,
+ .free_func = (pceplib_free_func)qfree,
+ /* Timers infrastructure */
+ .external_infra_data = fpt,
+ .socket_read_func = pcep_lib_pceplib_socket_read_cb,
+ .socket_write_func = pcep_lib_pceplib_socket_write_cb,
+ /* PCEP events */
+ .pcep_event_func = pcep_lib_pceplib_event_cb,
+ /* PCEPlib pthread creation callback */
+ .pthread_create_func = pcep_lib_pthread_create_cb};
+ if (!initialize_pcc_infra(&infra)) {
+ flog_err(EC_PATH_PCEP_PCC_INIT, "failed to initialize pceplib");
+ return 1;
+ }
+
+ return 0;
+}
+
+void pcep_lib_finalize(void)
+{
+ PCEP_DEBUG("Finalizing pceplib");
+ if (!destroy_pcc()) {
+ flog_err(EC_PATH_PCEP_PCC_FINI, "failed to finalize pceplib");
+ }
+}
+
+
+pcep_session *
+pcep_lib_connect(struct ipaddr *src_addr, int src_port, struct ipaddr *dst_addr,
+ int dst_port, short msd,
+ const struct pcep_config_group_opts *pcep_options)
+{
+ pcep_configuration *config;
+ pcep_session *sess;
+
+ config = create_default_pcep_configuration();
+ config->dst_pcep_port = dst_port;
+ config->src_pcep_port = src_port;
+ if (IS_IPADDR_V6(src_addr)) {
+ config->is_src_ipv6 = true;
+ memcpy(&config->src_ip.src_ipv6, &src_addr->ipaddr_v6,
+ sizeof(struct in6_addr));
+ } else {
+ config->is_src_ipv6 = false;
+ config->src_ip.src_ipv4 = src_addr->ipaddr_v4;
+ }
+
+ config->support_stateful_pce_lsp_update = true;
+ config->support_pce_lsp_instantiation = pcep_options->pce_initiated;
+ config->support_include_db_version = false;
+ config->support_lsp_triggered_resync = false;
+ config->support_lsp_delta_sync = false;
+ config->support_pce_triggered_initial_sync = false;
+ config->support_sr_te_pst = true;
+ config->pcc_can_resolve_nai_to_sid = false;
+
+ config->max_sid_depth = msd;
+ config->pcep_msg_versioning->draft_ietf_pce_segment_routing_07 =
+ pcep_options->draft07;
+ config->keep_alive_seconds = pcep_options->keep_alive_seconds;
+ config->min_keep_alive_seconds = pcep_options->min_keep_alive_seconds;
+ config->max_keep_alive_seconds = pcep_options->max_keep_alive_seconds;
+ config->dead_timer_seconds = pcep_options->dead_timer_seconds;
+ config->min_dead_timer_seconds = pcep_options->min_dead_timer_seconds;
+ config->max_dead_timer_seconds = pcep_options->max_dead_timer_seconds;
+ config->request_time_seconds = pcep_options->pcep_request_time_seconds;
+ /* TODO when available in the pceplib, set it here
+ pcep_options->state_timeout_inteval_seconds;*/
+
+ if (pcep_options->tcp_md5_auth[0] != '\0') {
+ config->is_tcp_auth_md5 = true;
+ strlcpy(config->tcp_authentication_str,
+ pcep_options->tcp_md5_auth,
+ sizeof(config->tcp_authentication_str));
+ } else {
+ config->is_tcp_auth_md5 = false;
+ }
+
+ if (IS_IPADDR_V6(dst_addr)) {
+ sess = connect_pce_ipv6(config, &dst_addr->ipaddr_v6);
+ } else {
+ sess = connect_pce(config, &dst_addr->ipaddr_v4);
+ }
+ destroy_pcep_configuration(config);
+ return sess;
+}
+
+void pcep_lib_disconnect(pcep_session *sess)
+{
+ assert(sess != NULL);
+ disconnect_pce(sess);
+}
+
+/* Callback passed to pceplib to write to a socket.
+ * When the socket is ready to be written to,
+ * pcep_lib_socket_write_ready() will be called */
+
+int pcep_lib_pceplib_socket_write_cb(void *fpt, void **thread, int fd,
+ void *payload)
+{
+ return pcep_thread_socket_write(fpt, thread, fd, payload,
+ pcep_lib_socket_write_ready);
+}
+
+/* Callback passed to pceplib to read from a socket.
+ * When the socket is ready to be read from,
+ * pcep_lib_socket_read_ready() will be called */
+
+int pcep_lib_pceplib_socket_read_cb(void *fpt, void **thread, int fd,
+ void *payload)
+{
+ return pcep_thread_socket_read(fpt, thread, fd, payload,
+ pcep_lib_socket_read_ready);
+}
+
+/* Callbacks called by path_pcep_controller when a socket is ready to read/write
+ */
+
+void pcep_lib_socket_write_ready(struct thread *thread)
+{
+ struct pcep_ctrl_socket_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+
+ pceplib_external_socket_write(data->fd, data->payload);
+ XFREE(MTYPE_PCEP, data);
+}
+
+void pcep_lib_socket_read_ready(struct thread *thread)
+{
+ struct pcep_ctrl_socket_data *data = THREAD_ARG(thread);
+ assert(data != NULL);
+
+ pceplib_external_socket_read(data->fd, data->payload);
+ XFREE(MTYPE_PCEP, data);
+}
+
+/* Callback passed to pceplib when a pcep_event is ready */
+void pcep_lib_pceplib_event_cb(void *fpt, pcep_event *event)
+{
+ pcep_thread_send_ctrl_event(fpt, event, pcep_thread_pcep_event);
+}
+
+/* Wrapper function around the actual pceplib thread start function */
+void *pcep_lib_pthread_start_passthrough(void *data)
+{
+ struct frr_pthread *fpt = data;
+ struct pcep_lib_pthread_passthrough_data *passthrough_data = fpt->data;
+ void *start_routine_data = passthrough_data->data;
+ void *(*start_routine)(void *) = passthrough_data->start_routine;
+ XFREE(MTYPE_PCEP, passthrough_data);
+
+ if (start_routine != NULL) {
+ return start_routine(start_routine_data);
+ }
+
+ return NULL;
+}
+
+int pcep_lib_pthread_create_cb(pthread_t *thread_id, const pthread_attr_t *attr,
+ void *(*start_routine)(void *), void *data,
+ const char *thread_name)
+{
+ /* Since FRR calls the start_routine with a struct frr_pthread,
+ * we have to store the real data and callback in a passthrough
+ * and pass the actual data the start_routine needs */
+ struct pcep_lib_pthread_passthrough_data *passthrough_data = XMALLOC(
+ MTYPE_PCEP, sizeof(struct pcep_lib_pthread_passthrough_data));
+ passthrough_data->data = data;
+ passthrough_data->start_routine = start_routine;
+
+ struct frr_pthread_attr fpt_attr = {
+ .start = pcep_lib_pthread_start_passthrough,
+ .stop = pcep_lib_pthread_stop_cb};
+ struct frr_pthread *fpt =
+ frr_pthread_new(&fpt_attr, thread_name, "pcep_lib");
+ if (fpt == NULL) {
+ return 1;
+ }
+
+ fpt->data = passthrough_data;
+ int retval = frr_pthread_run(fpt, attr);
+ if (retval) {
+ return retval;
+ }
+
+ *thread_id = fpt->thread;
+
+ return 0;
+}
+
+int pcep_lib_pthread_stop_cb(struct frr_pthread *fpt, void **res)
+{
+ pcep_lib_finalize();
+ frr_pthread_destroy(fpt);
+
+ return 0;
+}
+
+struct pcep_message *pcep_lib_format_report(struct pcep_caps *caps,
+ struct path *path)
+{
+ double_linked_list *objs = pcep_lib_format_path(caps, path);
+ return pcep_msg_create_report(objs);
+}
+
+static struct pcep_object_rp *create_rp(uint32_t reqid)
+{
+ double_linked_list *rp_tlvs;
+ struct pcep_object_tlv_path_setup_type *setup_type_tlv;
+ struct pcep_object_rp *rp;
+
+ rp_tlvs = dll_initialize();
+ setup_type_tlv = pcep_tlv_create_path_setup_type(SR_TE_PST);
+ dll_append(rp_tlvs, setup_type_tlv);
+
+ rp = pcep_obj_create_rp(0, false, false, false, true, reqid, rp_tlvs);
+
+ return rp;
+}
+
+struct pcep_message *pcep_lib_format_request(struct pcep_caps *caps,
+ struct path *path)
+{
+ struct ipaddr *src = &path->pcc_addr;
+ struct ipaddr *dst = &path->nbkey.endpoint;
+ double_linked_list *objs;
+ struct pcep_object_rp *rp;
+ struct pcep_object_endpoints_ipv4 *endpoints_ipv4;
+ struct pcep_object_endpoints_ipv6 *endpoints_ipv6;
+ struct pcep_object_objective_function *of = NULL;
+ enum objfun_type objfun = OBJFUN_UNDEFINED;
+
+ assert(src->ipa_type == dst->ipa_type);
+
+ objs = dll_initialize();
+ rp = create_rp(path->req_id);
+ rp->header.flag_p = true;
+
+ pcep_lib_format_constraints(path, objs);
+
+ /* Objective Function */
+ if (path->has_pcc_objfun) {
+ objfun = path->pcc_objfun;
+ }
+
+ if (objfun != OBJFUN_UNDEFINED) {
+ of = pcep_obj_create_objective_function(objfun, NULL);
+ assert(of != NULL);
+ of->header.flag_p = path->enforce_pcc_objfun;
+ dll_append(objs, of);
+ }
+
+ if (IS_IPADDR_V6(src)) {
+ endpoints_ipv6 = pcep_obj_create_endpoint_ipv6(&src->ipaddr_v6,
+ &dst->ipaddr_v6);
+ endpoints_ipv6->header.flag_p = true;
+ return pcep_msg_create_request_ipv6(rp, endpoints_ipv6, objs);
+ } else {
+ endpoints_ipv4 = pcep_obj_create_endpoint_ipv4(&src->ipaddr_v4,
+ &dst->ipaddr_v4);
+ endpoints_ipv4->header.flag_p = true;
+ return pcep_msg_create_request(rp, endpoints_ipv4, objs);
+ }
+}
+
+struct pcep_message *pcep_lib_format_error(int error_type, int error_value,
+ struct path *path)
+{
+ double_linked_list *objs, *srp_tlvs;
+ struct pcep_object_srp *srp;
+ struct pcep_object_tlv_header *tlv;
+
+ if ((path == NULL) || (path->srp_id == 0))
+ return pcep_msg_create_error(error_type, error_value);
+
+ objs = dll_initialize();
+ srp_tlvs = dll_initialize();
+ tlv = (struct pcep_object_tlv_header *)pcep_tlv_create_path_setup_type(
+ SR_TE_PST);
+ dll_append(srp_tlvs, tlv);
+ srp = pcep_obj_create_srp(path->do_remove, path->srp_id, srp_tlvs);
+ dll_append(objs, srp);
+ return pcep_msg_create_error_with_objects(error_type, error_value,
+ objs);
+}
+
+struct pcep_message *pcep_lib_format_request_cancelled(uint32_t reqid)
+{
+ struct pcep_object_notify *notify;
+ double_linked_list *objs;
+ struct pcep_object_rp *rp;
+
+ notify = pcep_obj_create_notify(
+ PCEP_NOTIFY_TYPE_PENDING_REQUEST_CANCELLED,
+ PCEP_NOTIFY_VALUE_PCC_CANCELLED_REQUEST);
+ objs = dll_initialize();
+ rp = create_rp(reqid);
+ dll_append(objs, rp);
+
+ return pcep_msg_create_notify(notify, objs);
+}
+
+struct path *pcep_lib_parse_path(struct pcep_message *msg)
+{
+ struct path *path;
+ double_linked_list *objs = msg->obj_list;
+ double_linked_list_node *node;
+
+ struct pcep_object_header *obj;
+ struct pcep_object_rp *rp = NULL;
+ struct pcep_object_srp *srp = NULL;
+ struct pcep_object_lsp *lsp = NULL;
+ struct pcep_object_lspa *lspa = NULL;
+ struct pcep_object_ro *ero = NULL;
+ struct pcep_object_metric *metric = NULL;
+ struct pcep_object_bandwidth *bandwidth = NULL;
+ struct pcep_object_objective_function *of = NULL;
+ struct pcep_object_endpoints_ipv4 *epv4 = NULL;
+ struct pcep_object_endpoints_ipv6 *epv6 = NULL;
+ struct pcep_object_vendor_info *vendor_info = NULL;
+
+ path = pcep_new_path();
+
+ for (node = objs->head; node != NULL; node = node->next_node) {
+ obj = (struct pcep_object_header *)node->data;
+ switch (CLASS_TYPE(obj->object_class, obj->object_type)) {
+ case CLASS_TYPE(PCEP_OBJ_CLASS_RP, PCEP_OBJ_TYPE_RP):
+ assert(rp == NULL);
+ rp = (struct pcep_object_rp *)obj;
+ pcep_lib_parse_rp(path, rp);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_SRP, PCEP_OBJ_TYPE_SRP):
+ assert(srp == NULL);
+ srp = (struct pcep_object_srp *)obj;
+ pcep_lib_parse_srp(path, srp);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_LSP, PCEP_OBJ_TYPE_LSP):
+ /* Only support single LSP per message */
+ assert(lsp == NULL);
+ lsp = (struct pcep_object_lsp *)obj;
+ pcep_lib_parse_lsp(path, lsp);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_LSPA, PCEP_OBJ_TYPE_LSPA):
+ assert(lspa == NULL);
+ lspa = (struct pcep_object_lspa *)obj;
+ pcep_lib_parse_lspa(path, lspa);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_ERO, PCEP_OBJ_TYPE_ERO):
+ /* Only support single ERO per message */
+ assert(ero == NULL);
+ ero = (struct pcep_object_ro *)obj;
+ pcep_lib_parse_ero(path, ero);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_METRIC, PCEP_OBJ_TYPE_METRIC):
+ metric = (struct pcep_object_metric *)obj;
+ pcep_lib_parse_metric(path, metric);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_BANDWIDTH,
+ PCEP_OBJ_TYPE_BANDWIDTH_REQ):
+ case CLASS_TYPE(PCEP_OBJ_CLASS_BANDWIDTH,
+ PCEP_OBJ_TYPE_BANDWIDTH_CISCO):
+ bandwidth = (struct pcep_object_bandwidth *)obj;
+ path->has_bandwidth = true;
+ path->bandwidth = bandwidth->bandwidth;
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_NOPATH, PCEP_OBJ_TYPE_NOPATH):
+ path->no_path = true;
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_OF, PCEP_OBJ_TYPE_OF):
+ of = (struct pcep_object_objective_function *)obj;
+ path->has_pce_objfun = true;
+ path->pce_objfun = of->of_code;
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_ENDPOINTS,
+ PCEP_OBJ_TYPE_ENDPOINT_IPV4):
+ epv4 = (struct pcep_object_endpoints_ipv4 *)obj;
+ pcep_lib_parse_endpoints_ipv4(path, epv4);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_ENDPOINTS,
+ PCEP_OBJ_TYPE_ENDPOINT_IPV6):
+ epv6 = (struct pcep_object_endpoints_ipv6 *)obj;
+ pcep_lib_parse_endpoints_ipv6(path, epv6);
+ break;
+ case CLASS_TYPE(PCEP_OBJ_CLASS_VENDOR_INFO,
+ PCEP_OBJ_TYPE_VENDOR_INFO):
+ vendor_info = (struct pcep_object_vendor_info *)obj;
+ pcep_lib_parse_vendor_info(path, vendor_info);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_OBJECT,
+ "Unexpected PCEP object %s (%u) / %s (%u)",
+ pcep_object_class_name(obj->object_class),
+ obj->object_class,
+ pcep_object_type_name(obj->object_class,
+ obj->object_type),
+ obj->object_type);
+ break;
+ }
+ }
+
+ return path;
+}
+
+void pcep_lib_parse_capabilities(struct pcep_message *msg,
+ struct pcep_caps *caps)
+{
+ double_linked_list *objs = msg->obj_list;
+ double_linked_list_node *node;
+
+ struct pcep_object_header *obj;
+ struct pcep_object_open *open = NULL;
+
+ for (node = objs->head; node != NULL; node = node->next_node) {
+ obj = (struct pcep_object_header *)node->data;
+ switch (CLASS_TYPE(obj->object_class, obj->object_type)) {
+ case CLASS_TYPE(PCEP_OBJ_CLASS_OPEN, PCEP_OBJ_TYPE_OPEN):
+ assert(open == NULL);
+ open = (struct pcep_object_open *)obj;
+ pcep_lib_parse_open(caps, open);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_OBJECT,
+ "Unexpected PCEP object %s (%u) / %s (%u)",
+ pcep_object_class_name(obj->object_class),
+ obj->object_class,
+ pcep_object_type_name(obj->object_class,
+ obj->object_type),
+ obj->object_type);
+ break;
+ }
+ }
+}
+
+struct counters_group *pcep_lib_copy_counters(pcep_session *sess)
+{
+ if (!sess || !sess->pcep_session_counters) {
+ return NULL;
+ }
+
+ return copy_counter_group(sess->pcep_session_counters);
+}
+
+void pcep_lib_free_counters(struct counters_group *counters)
+{
+ free_counter_group(counters);
+}
+
+pcep_session *pcep_lib_copy_pcep_session(pcep_session *sess)
+{
+ if (!sess) {
+ return NULL;
+ }
+
+ pcep_session *copy;
+ copy = XCALLOC(MTYPE_PCEP, sizeof(*copy));
+ memcpy(copy, sess, sizeof(*copy));
+ /* These fields should not be accessed */
+ copy->num_unknown_messages_time_queue = NULL;
+ copy->socket_comm_session = NULL;
+ copy->pcep_session_counters = NULL;
+
+ return copy;
+}
+
+/* ------------ pceplib logging callback ------------ */
+
+int pceplib_logging_cb(int priority, const char *fmt, va_list args)
+{
+ char buffer[1024];
+ vsnprintf(buffer, sizeof(buffer), fmt, args);
+ PCEP_DEBUG_PCEPLIB(priority, "pceplib: %s", buffer);
+ return 0;
+}
+
+/* ------------ Internal Functions ------------ */
+
+double_linked_list *pcep_lib_format_path(struct pcep_caps *caps,
+ struct path *path)
+{
+ struct in_addr addr_null;
+ double_linked_list *objs, *srp_tlvs, *lsp_tlvs, *ero_objs;
+ struct pcep_object_tlv_header *tlv;
+ struct pcep_object_ro_subobj *ero_obj;
+ struct pcep_object_srp *srp;
+ struct pcep_object_lsp *lsp;
+ struct pcep_object_ro *ero;
+ uint32_t encoded_binding_sid;
+ char binding_sid_lsp_tlv_data[6];
+
+ memset(&addr_null, 0, sizeof(addr_null));
+
+ objs = dll_initialize();
+
+ if (path->plsp_id != 0) {
+ /* SRP object */
+ srp_tlvs = dll_initialize();
+ tlv = (struct pcep_object_tlv_header *)
+ pcep_tlv_create_path_setup_type(SR_TE_PST);
+ assert(tlv != NULL);
+ dll_append(srp_tlvs, tlv);
+ srp = pcep_obj_create_srp(path->do_remove, path->srp_id,
+ srp_tlvs);
+ assert(srp != NULL);
+ srp->header.flag_p = true;
+ dll_append(objs, srp);
+ }
+
+ /* LSP object */
+ lsp_tlvs = dll_initialize();
+
+ if (path->plsp_id == 0 || IS_IPADDR_NONE(&path->nbkey.endpoint)
+ || IS_IPADDR_NONE(&path->pcc_addr)) {
+ tlv = (struct pcep_object_tlv_header *)
+ pcep_tlv_create_ipv4_lsp_identifiers(
+ &addr_null, &addr_null, 0, 0, &addr_null);
+ } else {
+ assert(path->pcc_addr.ipa_type
+ == path->nbkey.endpoint.ipa_type);
+ if (IS_IPADDR_V4(&path->pcc_addr)) {
+ tlv = (struct pcep_object_tlv_header *)
+ pcep_tlv_create_ipv4_lsp_identifiers(
+ &path->pcc_addr.ipaddr_v4,
+ &path->nbkey.endpoint.ipaddr_v4, 0, 0,
+ &path->pcc_addr.ipaddr_v4);
+ } else {
+ tlv = (struct pcep_object_tlv_header *)
+ pcep_tlv_create_ipv6_lsp_identifiers(
+ &path->pcc_addr.ipaddr_v6,
+ &path->nbkey.endpoint.ipaddr_v6, 0, 0,
+ &path->pcc_addr.ipaddr_v6);
+ }
+ }
+ assert(tlv != NULL);
+ dll_append(lsp_tlvs, tlv);
+ if (path->name != NULL) {
+ tlv = (struct pcep_object_tlv_header *)
+ /*FIXME: Remove the typecasty when pceplib is changed
+ to take a const char* */
+ pcep_tlv_create_symbolic_path_name((char *)path->name,
+ strlen(path->name));
+ assert(tlv != NULL);
+ dll_append(lsp_tlvs, tlv);
+ }
+ if ((path->plsp_id != 0) && (path->binding_sid != MPLS_LABEL_NONE)) {
+ memset(binding_sid_lsp_tlv_data, 0, 2);
+ encoded_binding_sid = htonl(path->binding_sid << 12);
+ memcpy(binding_sid_lsp_tlv_data + 2, &encoded_binding_sid, 4);
+ tlv = (struct pcep_object_tlv_header *)
+ pcep_tlv_create_tlv_arbitrary(
+ binding_sid_lsp_tlv_data,
+ sizeof(binding_sid_lsp_tlv_data),
+ PCEP_OBJ_TYPE_CISCO_BSID);
+ assert(tlv != NULL);
+ dll_append(lsp_tlvs, tlv);
+ }
+ lsp = pcep_obj_create_lsp(
+ path->plsp_id, path->status, path->was_created /* C Flag */,
+ path->go_active /* A Flag */, path->was_removed /* R Flag */,
+ path->is_synching /* S Flag */, path->is_delegated /* D Flag */,
+ lsp_tlvs);
+ assert(lsp != NULL);
+ lsp->header.flag_p = true;
+ dll_append(objs, lsp);
+ /* ERO object */
+ ero_objs = dll_initialize();
+ for (struct path_hop *hop = path->first_hop; hop != NULL;
+ hop = hop->next) {
+ uint32_t sid;
+
+ /* Only supporting MPLS hops with both sid and nai */
+ assert(hop->is_mpls);
+ assert(hop->has_sid);
+
+ if (hop->has_attribs) {
+ sid = ENCODE_SR_ERO_SID(hop->sid.mpls.label,
+ hop->sid.mpls.traffic_class,
+ hop->sid.mpls.is_bottom,
+ hop->sid.mpls.ttl);
+ } else {
+ sid = ENCODE_SR_ERO_SID(hop->sid.mpls.label, 0, 0, 0);
+ }
+
+ ero_obj = NULL;
+ if (hop->has_nai) {
+ assert(hop->nai.type != PCEP_SR_SUBOBJ_NAI_ABSENT);
+ assert(hop->nai.type
+ != PCEP_SR_SUBOBJ_NAI_LINK_LOCAL_IPV6_ADJACENCY);
+ assert(hop->nai.type != PCEP_SR_SUBOBJ_NAI_UNKNOWN);
+ switch (hop->nai.type) {
+ case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
+ ero_obj = (struct pcep_object_ro_subobj *)
+ pcep_obj_create_ro_subobj_sr_ipv4_node(
+ hop->is_loose, !hop->has_sid,
+ hop->has_attribs, /* C Flag */
+ hop->is_mpls, /* M Flag */
+ sid,
+ &hop->nai.local_addr.ipaddr_v4);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
+ ero_obj = (struct pcep_object_ro_subobj *)
+ pcep_obj_create_ro_subobj_sr_ipv6_node(
+ hop->is_loose, !hop->has_sid,
+ hop->has_attribs, /* C Flag */
+ hop->is_mpls, /* M Flag */
+ sid,
+ &hop->nai.local_addr.ipaddr_v6);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
+ ero_obj = (struct pcep_object_ro_subobj *)
+ pcep_obj_create_ro_subobj_sr_ipv4_adj(
+ hop->is_loose, !hop->has_sid,
+ hop->has_attribs, /* C Flag */
+ hop->is_mpls, /* M Flag */
+ sid,
+ &hop->nai.local_addr.ipaddr_v4,
+ &hop->nai.remote_addr
+ .ipaddr_v4);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
+ ero_obj = (struct pcep_object_ro_subobj *)
+ pcep_obj_create_ro_subobj_sr_ipv6_adj(
+ hop->is_loose, !hop->has_sid,
+ hop->has_attribs, /* C Flag */
+ hop->is_mpls, /* M Flag */
+ sid,
+ &hop->nai.local_addr.ipaddr_v6,
+ &hop->nai.remote_addr
+ .ipaddr_v6);
+ break;
+ case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
+ ero_obj = (struct pcep_object_ro_subobj *)
+ pcep_obj_create_ro_subobj_sr_unnumbered_ipv4_adj(
+ hop->is_loose, !hop->has_sid,
+ hop->has_attribs, /* C Flag */
+ hop->is_mpls, /* M Flag */
+ sid,
+ hop->nai.local_addr.ipaddr_v4
+ .s_addr,
+ hop->nai.local_iface,
+ hop->nai.remote_addr.ipaddr_v4
+ .s_addr,
+ hop->nai.remote_iface);
+ break;
+ default:
+ break;
+ }
+ }
+ if (ero_obj == NULL) {
+ ero_obj = (struct pcep_object_ro_subobj *)
+ pcep_obj_create_ro_subobj_sr_nonai(
+ hop->is_loose, sid,
+ hop->has_attribs, /* C Flag */
+ hop->is_mpls); /* M Flag */
+ }
+ dll_append(ero_objs, ero_obj);
+ }
+ ero = pcep_obj_create_ero(ero_objs);
+ assert(ero != NULL);
+ ero->header.flag_p = true;
+ dll_append(objs, ero);
+
+ if (path->plsp_id == 0) {
+ return objs;
+ }
+
+ pcep_lib_format_constraints(path, objs);
+
+ return objs;
+}
+
+void pcep_lib_format_constraints(struct path *path, double_linked_list *objs)
+{
+ struct pcep_object_metric *metric;
+ struct pcep_object_bandwidth *bandwidth;
+ struct pcep_object_lspa *lspa;
+
+ /* LSPA object */
+ if (path->has_affinity_filters) {
+ lspa = pcep_obj_create_lspa(
+ path->affinity_filters[AFFINITY_FILTER_EXCLUDE_ANY - 1],
+ path->affinity_filters[AFFINITY_FILTER_INCLUDE_ANY - 1],
+ path->affinity_filters[AFFINITY_FILTER_INCLUDE_ALL - 1],
+ DEFAULT_LSAP_SETUP_PRIO, DEFAULT_LSAP_HOLDING_PRIO,
+ DEFAULT_LSAP_LOCAL_PRETECTION);
+ assert(lspa != NULL);
+ lspa->header.flag_p = true;
+ dll_append(objs, lspa);
+ }
+
+ /* Bandwidth Objects */
+ if (path->has_bandwidth) {
+ /* Requested Bandwidth */
+ bandwidth = pcep_obj_create_bandwidth(path->bandwidth);
+ assert(bandwidth != NULL);
+ bandwidth->header.flag_p = path->enforce_bandwidth;
+ dll_append(objs, bandwidth);
+ }
+
+ /* Metric Objects */
+ for (struct path_metric *m = path->first_metric; m != NULL;
+ m = m->next) {
+ metric = pcep_obj_create_metric(m->type, m->is_bound,
+ m->is_computed, m->value);
+ assert(metric != NULL);
+ metric->header.flag_p = m->enforce;
+ dll_append(objs, metric);
+ }
+}
+
+void pcep_lib_parse_open(struct pcep_caps *caps, struct pcep_object_open *open)
+{
+ double_linked_list *tlvs = open->header.tlv_list;
+ double_linked_list_node *node;
+ struct pcep_object_tlv_header *tlv_header;
+
+ caps->is_stateful = false;
+ caps->supported_ofs_are_known = false;
+ caps->supported_ofs = 0;
+
+ for (node = tlvs->head; node != NULL; node = node->next_node) {
+ tlv_header = (struct pcep_object_tlv_header *)node->data;
+ switch (tlv_header->type) {
+ case PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY:
+ pcep_lib_parse_open_pce_capability(caps, tlv_header);
+ break;
+ case PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY:
+ break;
+ case PCEP_OBJ_TLV_TYPE_OBJECTIVE_FUNCTION_LIST:
+ pcep_lib_parse_open_objfun_list(caps, tlv_header);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected OPEN's TLV %s (%u)",
+ pcep_tlv_type_name(tlv_header->type),
+ tlv_header->type);
+ break;
+ }
+ }
+}
+
+void pcep_lib_parse_open_pce_capability(
+ struct pcep_caps *caps, struct pcep_object_tlv_header *tlv_header)
+{
+ struct pcep_object_tlv_stateful_pce_capability *tlv;
+ tlv = (struct pcep_object_tlv_stateful_pce_capability *)tlv_header;
+ caps->is_stateful = tlv->flag_u_lsp_update_capability;
+}
+
+void pcep_lib_parse_open_objfun_list(struct pcep_caps *caps,
+ struct pcep_object_tlv_header *tlv_header)
+{
+ double_linked_list_node *node;
+ struct pcep_object_tlv_of_list *tlv;
+ tlv = (struct pcep_object_tlv_of_list *)tlv_header;
+ uint16_t of_code;
+ caps->supported_ofs_are_known = true;
+ for (node = tlv->of_list->head; node != NULL; node = node->next_node) {
+ of_code = *(uint16_t *)node->data;
+ if (of_code >= 32) {
+ zlog_warn(
+ "Ignoring unexpected objective function with code %u",
+ of_code);
+ continue;
+ }
+ SET_FLAG(caps->supported_ofs, of_code);
+ }
+}
+
+void pcep_lib_parse_rp(struct path *path, struct pcep_object_rp *rp)
+{
+ double_linked_list *tlvs = rp->header.tlv_list;
+ double_linked_list_node *node;
+ struct pcep_object_tlv_header *tlv;
+
+ if (tlvs == NULL) {
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected Empty RP's TLV plsp-id:(%d)",
+ path ? (int32_t)path->plsp_id : -1);
+ return;
+ }
+ /* We ignore the other flags and priority for now */
+ path->req_id = rp->request_id;
+ path->has_pce_objfun = false;
+ path->pce_objfun = OBJFUN_UNDEFINED;
+
+ for (node = tlvs->head; node != NULL; node = node->next_node) {
+ tlv = (struct pcep_object_tlv_header *)node->data;
+ switch (tlv->type) {
+ case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
+ // TODO: enforce the path setup type is SR_TE_PST
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected RP's TLV %s (%u)",
+ pcep_tlv_type_name(tlv->type), tlv->type);
+ break;
+ }
+ }
+}
+
+void pcep_lib_parse_srp(struct path *path, struct pcep_object_srp *srp)
+{
+ double_linked_list *tlvs = srp->header.tlv_list;
+ double_linked_list_node *node;
+ struct pcep_object_tlv_header *tlv;
+
+ path->do_remove = srp->flag_lsp_remove;
+ path->srp_id = srp->srp_id_number;
+
+ if (tlvs == NULL) {
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected Empty SRP's TLV plsp-id:(%d)",
+ path ? (int32_t)path->plsp_id : -1);
+ return;
+ }
+ for (node = tlvs->head; node != NULL; node = node->next_node) {
+ tlv = (struct pcep_object_tlv_header *)node->data;
+ switch (tlv->type) {
+ case PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE:
+ // TODO: enforce the path setup type is SR_TE_PST
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected SRP's TLV %s (%u)",
+ pcep_tlv_type_name(tlv->type), tlv->type);
+ break;
+ }
+ }
+}
+
+void pcep_lib_parse_lsp(struct path *path, struct pcep_object_lsp *lsp)
+{
+ double_linked_list *tlvs = lsp->header.tlv_list;
+ double_linked_list_node *node;
+ struct pcep_object_tlv_header *tlv;
+ struct pcep_object_tlv_symbolic_path_name *name;
+ struct pcep_object_tlv_arbitrary *arb_tlv;
+
+ path->plsp_id = lsp->plsp_id;
+ path->status = lsp->operational_status;
+ path->go_active = lsp->flag_a;
+ path->was_created = lsp->flag_c;
+ path->was_removed = lsp->flag_r;
+ path->is_synching = lsp->flag_s;
+ path->is_delegated = lsp->flag_d;
+
+ if (tlvs == NULL) {
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected Empty LSP's TLV plsp-id:(%d)",
+ path ? (int32_t)path->plsp_id : -1);
+ return;
+ }
+
+ for (node = tlvs->head; node != NULL; node = node->next_node) {
+ tlv = (struct pcep_object_tlv_header *)node->data;
+ switch (tlv->type) {
+ case PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME:
+ name = (struct pcep_object_tlv_symbolic_path_name *)tlv;
+ pcep_lib_parse_lsp_symbolic_name(path, name);
+ break;
+ case PCEP_OBJ_TYPE_CISCO_BSID:
+ arb_tlv = (struct pcep_object_tlv_arbitrary *)tlv;
+ memcpy(&path->binding_sid, arb_tlv->data + 2,
+ sizeof(path->binding_sid));
+ path->binding_sid = ntohl(path->binding_sid);
+ path->binding_sid = (path->binding_sid >> 12);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected LSP TLV %s (%u)",
+ pcep_tlv_type_name(tlv->type), tlv->type);
+ break;
+ }
+ }
+}
+
+void pcep_lib_parse_lsp_symbolic_name(
+ struct path *path, struct pcep_object_tlv_symbolic_path_name *tlv)
+{
+ uint16_t size = tlv->symbolic_path_name_length;
+ assert(path->name == NULL);
+ size = size > MAX_PATH_NAME_SIZE ? MAX_PATH_NAME_SIZE : size;
+ path->name = XCALLOC(MTYPE_PCEP, size);
+ strlcpy((char *)path->name, tlv->symbolic_path_name, size + 1);
+}
+
+void pcep_lib_parse_lspa(struct path *path, struct pcep_object_lspa *lspa)
+{
+ path->has_affinity_filters = true;
+ path->affinity_filters[AFFINITY_FILTER_EXCLUDE_ANY - 1] =
+ lspa->lspa_exclude_any;
+ path->affinity_filters[AFFINITY_FILTER_INCLUDE_ANY - 1] =
+ lspa->lspa_include_any;
+ path->affinity_filters[AFFINITY_FILTER_INCLUDE_ALL - 1] =
+ lspa->lspa_include_all;
+}
+
+void pcep_lib_parse_metric(struct path *path, struct pcep_object_metric *obj)
+{
+ struct path_metric *metric;
+
+ metric = pcep_new_metric();
+ metric->type = obj->type;
+ metric->is_bound = obj->flag_b;
+ metric->is_computed = obj->flag_c;
+ metric->value = obj->value;
+ metric->next = path->first_metric;
+ path->first_metric = metric;
+}
+
+void pcep_lib_parse_endpoints_ipv4(struct path *path,
+ struct pcep_object_endpoints_ipv4 *obj)
+{
+ SET_IPADDR_V4(&path->pcc_addr);
+ path->pcc_addr.ipaddr_v4 = obj->src_ipv4;
+ SET_IPADDR_V4(&path->nbkey.endpoint);
+ path->nbkey.endpoint.ipaddr_v4 = obj->dst_ipv4;
+}
+
+void pcep_lib_parse_endpoints_ipv6(struct path *path,
+ struct pcep_object_endpoints_ipv6 *obj)
+{
+ SET_IPADDR_V6(&path->pcc_addr);
+ path->pcc_addr.ipaddr_v6 = obj->src_ipv6;
+ SET_IPADDR_V6(&path->nbkey.endpoint);
+ path->nbkey.endpoint.ipaddr_v6 = obj->dst_ipv6;
+}
+
+void pcep_lib_parse_vendor_info(struct path *path,
+ struct pcep_object_vendor_info *obj)
+{
+ if (obj->enterprise_number == ENTERPRISE_NUMBER_CISCO
+ && obj->enterprise_specific_info == ENTERPRISE_COLOR_CISCO)
+ path->nbkey.color = obj->enterprise_specific_info1;
+ else
+ path->nbkey.color = 0;
+}
+
+void pcep_lib_parse_ero(struct path *path, struct pcep_object_ro *ero)
+{
+ struct path_hop *hop = NULL;
+ double_linked_list *objs = ero->sub_objects;
+ double_linked_list_node *node;
+ struct pcep_object_ro_subobj *obj;
+
+ if (objs == NULL) {
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_TLV,
+ "Unexpected Empty ERO's sub_obj plsp-id:(%d)",
+ path ? (int32_t)path->plsp_id : -1);
+ return;
+ }
+ for (node = objs->tail; node != NULL; node = node->prev_node) {
+ obj = (struct pcep_object_ro_subobj *)node->data;
+ switch (obj->ro_subobj_type) {
+ case RO_SUBOBJ_TYPE_SR:
+ hop = pcep_lib_parse_ero_sr(
+ hop, (struct pcep_ro_subobj_sr *)obj);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_ERO_SUBOBJ,
+ "Unexpected ERO sub-object %s (%u)",
+ pcep_ro_type_name(obj->ro_subobj_type),
+ obj->ro_subobj_type);
+ break;
+ }
+ }
+
+ path->first_hop = hop;
+}
+
+struct path_hop *pcep_lib_parse_ero_sr(struct path_hop *next,
+ struct pcep_ro_subobj_sr *sr)
+{
+ struct path_hop *hop = NULL;
+ union sid sid;
+
+ /* Only support IPv4 node with SID */
+ assert(!sr->flag_s);
+
+ if (sr->flag_m) {
+ sid.mpls = (struct sid_mpls){
+ .label = GET_SR_ERO_SID_LABEL(sr->sid),
+ .traffic_class = GET_SR_ERO_SID_TC(sr->sid),
+ .is_bottom = GET_SR_ERO_SID_S(sr->sid),
+ .ttl = GET_SR_ERO_SID_TTL(sr->sid)};
+ } else {
+ sid.value = sr->sid;
+ }
+
+ hop = pcep_new_hop();
+ *hop = (struct path_hop){.next = next,
+ .is_loose =
+ sr->ro_subobj.flag_subobj_loose_hop,
+ .has_sid = !sr->flag_s,
+ .is_mpls = sr->flag_m,
+ .has_attribs = sr->flag_c,
+ .sid = sid,
+ .has_nai = !sr->flag_f,
+ .nai = {.type = sr->nai_type}};
+
+ if (!sr->flag_f) {
+ assert(sr->nai_list != NULL);
+ double_linked_list_node *n = sr->nai_list->head;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ switch (sr->nai_type) {
+ case PCEP_SR_SUBOBJ_NAI_IPV4_NODE:
+ hop->nai.local_addr.ipa_type = IPADDR_V4;
+ memcpy(&hop->nai.local_addr.ipaddr_v4, n->data,
+ sizeof(struct in_addr));
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_NODE:
+ hop->nai.local_addr.ipa_type = IPADDR_V6;
+ memcpy(&hop->nai.local_addr.ipaddr_v6, n->data,
+ sizeof(struct in6_addr));
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY:
+ hop->nai.local_addr.ipa_type = IPADDR_V4;
+ memcpy(&hop->nai.local_addr.ipaddr_v4, n->data,
+ sizeof(struct in_addr));
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ hop->nai.remote_addr.ipa_type = IPADDR_V4;
+ memcpy(&hop->nai.remote_addr.ipaddr_v4, n->data,
+ sizeof(struct in_addr));
+ break;
+ case PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY:
+ hop->nai.local_addr.ipa_type = IPADDR_V6;
+ memcpy(&hop->nai.local_addr.ipaddr_v6, n->data,
+ sizeof(struct in6_addr));
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ hop->nai.remote_addr.ipa_type = IPADDR_V6;
+ memcpy(&hop->nai.remote_addr.ipaddr_v6, n->data,
+ sizeof(struct in6_addr));
+ break;
+ case PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY:
+ hop->nai.local_addr.ipa_type = IPADDR_V4;
+ memcpy(&hop->nai.local_addr.ipaddr_v4, n->data,
+ sizeof(struct in_addr));
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ hop->nai.local_iface = *(uint32_t *)n->data;
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ hop->nai.remote_addr.ipa_type = IPADDR_V4;
+ memcpy(&hop->nai.remote_addr.ipaddr_v4, n->data,
+ sizeof(struct in_addr));
+ n = n->next_node;
+ assert(n != NULL);
+ assert(n->data != NULL);
+ hop->nai.remote_iface = *(uint32_t *)n->data;
+ break;
+ default:
+ hop->has_nai = false;
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_SR_NAI,
+ "Unexpected SR segment NAI type %s (%u)",
+ pcep_nai_type_name(sr->nai_type),
+ sr->nai_type);
+ break;
+ }
+ }
+
+ return hop;
+}
+
+struct counters_group *copy_counter_group(struct counters_group *from)
+{
+ int size, i;
+ struct counters_group *result;
+ if (from == NULL)
+ return NULL;
+ assert(from->max_subgroups >= from->num_subgroups);
+ result = XCALLOC(MTYPE_PCEP, sizeof(*result));
+ memcpy(result, from, sizeof(*result));
+ size = sizeof(struct counters_subgroup *) * (from->max_subgroups + 1);
+ result->subgroups = XCALLOC(MTYPE_PCEP, size);
+ for (i = 0; i <= from->max_subgroups; i++)
+ result->subgroups[i] =
+ copy_counter_subgroup(from->subgroups[i]);
+ return result;
+}
+
+struct counters_subgroup *copy_counter_subgroup(struct counters_subgroup *from)
+{
+ int size, i;
+ struct counters_subgroup *result;
+ if (from == NULL)
+ return NULL;
+ assert(from->max_counters >= from->num_counters);
+ result = XCALLOC(MTYPE_PCEP, sizeof(*result));
+ memcpy(result, from, sizeof(*result));
+ size = sizeof(struct counter *) * (from->max_counters + 1);
+ result->counters = XCALLOC(MTYPE_PCEP, size);
+ for (i = 0; i <= from->max_counters; i++)
+ result->counters[i] = copy_counter(from->counters[i]);
+ return result;
+}
+
+struct counter *copy_counter(struct counter *from)
+{
+ struct counter *result;
+ if (from == NULL)
+ return NULL;
+ result = XCALLOC(MTYPE_PCEP, sizeof(*result));
+ memcpy(result, from, sizeof(*result));
+ return result;
+}
+
+void free_counter_group(struct counters_group *group)
+{
+ int i;
+ if (group == NULL)
+ return;
+ for (i = 0; i <= group->max_subgroups; i++)
+ free_counter_subgroup(group->subgroups[i]);
+ XFREE(MTYPE_PCEP, group->subgroups);
+ XFREE(MTYPE_PCEP, group);
+}
+
+void free_counter_subgroup(struct counters_subgroup *subgroup)
+{
+ int i;
+ if (subgroup == NULL)
+ return;
+ for (i = 0; i <= subgroup->max_counters; i++)
+ free_counter(subgroup->counters[i]);
+ XFREE(MTYPE_PCEP, subgroup->counters);
+ XFREE(MTYPE_PCEP, subgroup);
+}
+
+void free_counter(struct counter *counter)
+{
+ if (counter == NULL)
+ return;
+ XFREE(MTYPE_PCEP, counter);
+}
diff --git a/pathd/path_pcep_lib.h b/pathd/path_pcep_lib.h
new file mode 100644
index 0000000..524f385
--- /dev/null
+++ b/pathd/path_pcep_lib.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_LIB_H_
+#define _PATH_PCEP_LIB_H_
+
+#include <stdbool.h>
+#include "pceplib/pcep_pcc_api.h"
+#include "frr_pthread.h"
+#include "pathd/path_pcep.h"
+
+int pcep_lib_initialize(struct frr_pthread *fpt);
+void pcep_lib_finalize(void);
+pcep_session *
+pcep_lib_connect(struct ipaddr *src_addr, int src_port, struct ipaddr *dst_addr,
+ int dst_port, short msd,
+ const struct pcep_config_group_opts *pcep_options);
+void pcep_lib_disconnect(pcep_session *sess);
+struct pcep_message *pcep_lib_format_report(struct pcep_caps *caps,
+ struct path *path);
+struct pcep_message *pcep_lib_format_request(struct pcep_caps *caps,
+ struct path *path);
+struct pcep_message *pcep_lib_format_request_cancelled(uint32_t reqid);
+
+struct pcep_message *pcep_lib_format_error(int error_type, int error_value,
+ struct path *path);
+struct path *pcep_lib_parse_path(struct pcep_message *msg);
+void pcep_lib_parse_capabilities(struct pcep_message *msg,
+ struct pcep_caps *caps);
+struct counters_group *pcep_lib_copy_counters(pcep_session *sess);
+void pcep_lib_free_counters(struct counters_group *counters);
+pcep_session *pcep_lib_copy_pcep_session(pcep_session *sess);
+
+#endif // _PATH_PCEP_LIB_H_
diff --git a/pathd/path_pcep_pcc.c b/pathd/path_pcep_pcc.c
new file mode 100644
index 0000000..a1c56f9
--- /dev/null
+++ b/pathd/path_pcep_pcc.c
@@ -0,0 +1,2002 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* TODOS AND KNOWN ISSUES:
+ - Delete mapping from NB keys to PLSPID when an LSP is deleted either
+ by the PCE or by NB.
+ - Revert the hacks to work around ODL requiring a report with
+ operational status DOWN when an LSP is activated.
+ - Enforce only the PCE a policy has been delegated to can update it.
+ - If the router-id is used because the PCC IP is not specified
+ (either IPv4 or IPv6), the connection to the PCE is not reset
+ when the router-id changes.
+*/
+
+#include <zebra.h>
+
+#include "log.h"
+#include "command.h"
+#include "libfrr.h"
+#include "printfrr.h"
+#include "lib/version.h"
+#include "northbound.h"
+#include "frr_pthread.h"
+#include "jhash.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_zebra.h"
+#include "pathd/path_errors.h"
+#include "pathd/path_pcep.h"
+#include "pathd/path_pcep_controller.h"
+#include "pathd/path_pcep_lib.h"
+#include "pathd/path_pcep_config.h"
+#include "pathd/path_pcep_debug.h"
+
+
+/* The number of time we will skip connecting if we are missing the PCC
+ * address for an inet family different from the selected transport one*/
+#define OTHER_FAMILY_MAX_RETRIES 4
+#define MAX_ERROR_MSG_SIZE 256
+#define MAX_COMPREQ_TRIES 3
+
+pthread_mutex_t g_pcc_info_mtx = PTHREAD_MUTEX_INITIALIZER;
+
+/* PCEP Event Handler */
+static void handle_pcep_open(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg);
+static void handle_pcep_message(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg);
+static void handle_pcep_lsp_initiate(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg);
+static void handle_pcep_lsp_update(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg);
+static void continue_pcep_lsp_update(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct path *path, void *payload);
+static void handle_pcep_comp_reply(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg);
+
+/* Internal Functions */
+static const char *ipaddr_type_name(struct ipaddr *addr);
+static bool filter_path(struct pcc_state *pcc_state, struct path *path);
+static void select_pcc_addresses(struct pcc_state *pcc_state);
+static void select_transport_address(struct pcc_state *pcc_state);
+static void update_tag(struct pcc_state *pcc_state);
+static void update_originator(struct pcc_state *pcc_state);
+static void schedule_reconnect(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+static void schedule_session_timeout(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+static void cancel_session_timeout(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+static void send_pcep_message(struct pcc_state *pcc_state,
+ struct pcep_message *msg);
+static void send_pcep_error(struct pcc_state *pcc_state,
+ enum pcep_error_type error_type,
+ enum pcep_error_value error_value,
+ struct path *trigger_path);
+static void send_report(struct pcc_state *pcc_state, struct path *path);
+static void send_comp_request(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct req_entry *req);
+static void cancel_comp_requests(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+static void cancel_comp_request(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct req_entry *req);
+static void specialize_outgoing_path(struct pcc_state *pcc_state,
+ struct path *path);
+static void specialize_incoming_path(struct pcc_state *pcc_state,
+ struct path *path);
+static bool validate_incoming_path(struct pcc_state *pcc_state,
+ struct path *path, char *errbuff,
+ size_t buffsize);
+static void set_pcc_address(struct pcc_state *pcc_state,
+ struct lsp_nb_key *nbkey, struct ipaddr *addr);
+static int compare_pcc_opts(struct pcc_opts *lhs, struct pcc_opts *rhs);
+static int compare_pce_opts(struct pce_opts *lhs, struct pce_opts *rhs);
+static int get_previous_best_pce(struct pcc_state **pcc);
+static int get_best_pce(struct pcc_state **pcc);
+static int get_pce_count_connected(struct pcc_state **pcc);
+static bool update_best_pce(struct pcc_state **pcc, int best);
+
+/* Data Structure Helper Functions */
+static void lookup_plspid(struct pcc_state *pcc_state, struct path *path);
+static void lookup_nbkey(struct pcc_state *pcc_state, struct path *path);
+static void free_req_entry(struct req_entry *req);
+static struct req_entry *push_new_req(struct pcc_state *pcc_state,
+ struct path *path);
+static void repush_req(struct pcc_state *pcc_state, struct req_entry *req);
+static struct req_entry *pop_req(struct pcc_state *pcc_state, uint32_t reqid);
+static struct req_entry *pop_req_no_reqid(struct pcc_state *pcc_state,
+ uint32_t reqid);
+static bool add_reqid_mapping(struct pcc_state *pcc_state, struct path *path);
+static void remove_reqid_mapping(struct pcc_state *pcc_state,
+ struct path *path);
+static uint32_t lookup_reqid(struct pcc_state *pcc_state, struct path *path);
+static bool has_pending_req_for(struct pcc_state *pcc_state, struct path *path);
+
+/* Data Structure Callbacks */
+static int plspid_map_cmp(const struct plspid_map_data *a,
+ const struct plspid_map_data *b);
+static uint32_t plspid_map_hash(const struct plspid_map_data *e);
+static int nbkey_map_cmp(const struct nbkey_map_data *a,
+ const struct nbkey_map_data *b);
+static uint32_t nbkey_map_hash(const struct nbkey_map_data *e);
+static int req_map_cmp(const struct req_map_data *a,
+ const struct req_map_data *b);
+static uint32_t req_map_hash(const struct req_map_data *e);
+
+/* Data Structure Declarations */
+DECLARE_HASH(plspid_map, struct plspid_map_data, mi, plspid_map_cmp,
+ plspid_map_hash);
+DECLARE_HASH(nbkey_map, struct nbkey_map_data, mi, nbkey_map_cmp,
+ nbkey_map_hash);
+DECLARE_HASH(req_map, struct req_map_data, mi, req_map_cmp, req_map_hash);
+
+static inline int req_entry_compare(const struct req_entry *a,
+ const struct req_entry *b)
+{
+ return a->path->req_id - b->path->req_id;
+}
+RB_GENERATE(req_entry_head, req_entry, entry, req_entry_compare)
+
+
+/* ------------ API Functions ------------ */
+
+struct pcc_state *pcep_pcc_initialize(struct ctrl_state *ctrl_state, int index)
+{
+ struct pcc_state *pcc_state = XCALLOC(MTYPE_PCEP, sizeof(*pcc_state));
+
+ pcc_state->id = index;
+ pcc_state->status = PCEP_PCC_DISCONNECTED;
+ pcc_state->next_reqid = 1;
+ pcc_state->next_plspid = 1;
+
+ RB_INIT(req_entry_head, &pcc_state->requests);
+
+ update_tag(pcc_state);
+ update_originator(pcc_state);
+
+ PCEP_DEBUG("%s PCC initialized", pcc_state->tag);
+
+ return pcc_state;
+}
+
+void pcep_pcc_finalize(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ PCEP_DEBUG("%s PCC finalizing...", pcc_state->tag);
+
+ pcep_pcc_disable(ctrl_state, pcc_state);
+
+ if (pcc_state->pcc_opts != NULL) {
+ XFREE(MTYPE_PCEP, pcc_state->pcc_opts);
+ pcc_state->pcc_opts = NULL;
+ }
+ if (pcc_state->pce_opts != NULL) {
+ XFREE(MTYPE_PCEP, pcc_state->pce_opts);
+ pcc_state->pce_opts = NULL;
+ }
+ if (pcc_state->originator != NULL) {
+ XFREE(MTYPE_PCEP, pcc_state->originator);
+ pcc_state->originator = NULL;
+ }
+
+ if (pcc_state->t_reconnect != NULL) {
+ thread_cancel(&pcc_state->t_reconnect);
+ pcc_state->t_reconnect = NULL;
+ }
+
+ if (pcc_state->t_update_best != NULL) {
+ thread_cancel(&pcc_state->t_update_best);
+ pcc_state->t_update_best = NULL;
+ }
+
+ if (pcc_state->t_session_timeout != NULL) {
+ thread_cancel(&pcc_state->t_session_timeout);
+ pcc_state->t_session_timeout = NULL;
+ }
+
+ XFREE(MTYPE_PCEP, pcc_state);
+}
+
+int compare_pcc_opts(struct pcc_opts *lhs, struct pcc_opts *rhs)
+{
+ int retval;
+
+ if (lhs == NULL) {
+ return 1;
+ }
+
+ if (rhs == NULL) {
+ return -1;
+ }
+
+ retval = lhs->port - rhs->port;
+ if (retval != 0) {
+ return retval;
+ }
+
+ retval = lhs->msd - rhs->msd;
+ if (retval != 0) {
+ return retval;
+ }
+
+ if (IS_IPADDR_V4(&lhs->addr)) {
+ retval = memcmp(&lhs->addr.ipaddr_v4, &rhs->addr.ipaddr_v4,
+ sizeof(lhs->addr.ipaddr_v4));
+ if (retval != 0) {
+ return retval;
+ }
+ } else if (IS_IPADDR_V6(&lhs->addr)) {
+ retval = memcmp(&lhs->addr.ipaddr_v6, &rhs->addr.ipaddr_v6,
+ sizeof(lhs->addr.ipaddr_v6));
+ if (retval != 0) {
+ return retval;
+ }
+ }
+
+ return 0;
+}
+
+int compare_pce_opts(struct pce_opts *lhs, struct pce_opts *rhs)
+{
+ if (lhs == NULL) {
+ return 1;
+ }
+
+ if (rhs == NULL) {
+ return -1;
+ }
+
+ int retval = lhs->port - rhs->port;
+ if (retval != 0) {
+ return retval;
+ }
+
+ retval = strcmp(lhs->pce_name, rhs->pce_name);
+ if (retval != 0) {
+ return retval;
+ }
+
+ retval = lhs->precedence - rhs->precedence;
+ if (retval != 0) {
+ return retval;
+ }
+
+ retval = memcmp(&lhs->addr, &rhs->addr, sizeof(lhs->addr));
+ if (retval != 0) {
+ return retval;
+ }
+
+ return 0;
+}
+
+int pcep_pcc_update(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state,
+ struct pcc_opts *pcc_opts, struct pce_opts *pce_opts)
+{
+ int ret = 0;
+
+ // If the options did not change, then there is nothing to do
+ if ((compare_pce_opts(pce_opts, pcc_state->pce_opts) == 0)
+ && (compare_pcc_opts(pcc_opts, pcc_state->pcc_opts) == 0)) {
+ return ret;
+ }
+
+ if ((ret = pcep_pcc_disable(ctrl_state, pcc_state))) {
+ XFREE(MTYPE_PCEP, pcc_opts);
+ XFREE(MTYPE_PCEP, pce_opts);
+ return ret;
+ }
+
+ if (pcc_state->pcc_opts != NULL) {
+ XFREE(MTYPE_PCEP, pcc_state->pcc_opts);
+ }
+ if (pcc_state->pce_opts != NULL) {
+ XFREE(MTYPE_PCEP, pcc_state->pce_opts);
+ }
+
+ pcc_state->pcc_opts = pcc_opts;
+ pcc_state->pce_opts = pce_opts;
+
+ if (IS_IPADDR_V4(&pcc_opts->addr)) {
+ pcc_state->pcc_addr_v4 = pcc_opts->addr.ipaddr_v4;
+ SET_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4);
+ } else {
+ UNSET_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4);
+ }
+
+ if (IS_IPADDR_V6(&pcc_opts->addr)) {
+ memcpy(&pcc_state->pcc_addr_v6, &pcc_opts->addr.ipaddr_v6,
+ sizeof(struct in6_addr));
+ SET_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6);
+ } else {
+ UNSET_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6);
+ }
+
+ update_tag(pcc_state);
+ update_originator(pcc_state);
+
+ return pcep_pcc_enable(ctrl_state, pcc_state);
+}
+
+void pcep_pcc_reconnect(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ if (pcc_state->status == PCEP_PCC_DISCONNECTED)
+ pcep_pcc_enable(ctrl_state, pcc_state);
+}
+
+int pcep_pcc_enable(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state)
+{
+ assert(pcc_state->status == PCEP_PCC_DISCONNECTED);
+ assert(pcc_state->sess == NULL);
+
+ if (pcc_state->t_reconnect != NULL) {
+ thread_cancel(&pcc_state->t_reconnect);
+ pcc_state->t_reconnect = NULL;
+ }
+
+ select_transport_address(pcc_state);
+
+ /* Even though we are connecting using IPv6. we want to have an IPv4
+ * address so we can handle candidate path with IPv4 endpoints */
+ if (!CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4)) {
+ if (pcc_state->retry_count < OTHER_FAMILY_MAX_RETRIES) {
+ flog_warn(EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ "skipping connection to PCE %pIA:%d due to missing PCC IPv4 address",
+ &pcc_state->pce_opts->addr,
+ pcc_state->pce_opts->port);
+ schedule_reconnect(ctrl_state, pcc_state);
+ return 0;
+ } else {
+ flog_warn(EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ "missing IPv4 PCC address, IPv4 candidate paths will be ignored");
+ }
+ }
+
+ /* Even though we are connecting using IPv4. we want to have an IPv6
+ * address so we can handle candidate path with IPv6 endpoints */
+ if (!CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6)) {
+ if (pcc_state->retry_count < OTHER_FAMILY_MAX_RETRIES) {
+ flog_warn(EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ "skipping connection to PCE %pIA:%d due to missing PCC IPv6 address",
+ &pcc_state->pce_opts->addr,
+ pcc_state->pce_opts->port);
+ schedule_reconnect(ctrl_state, pcc_state);
+ return 0;
+ } else {
+ flog_warn(EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ "missing IPv6 PCC address, IPv6 candidate paths will be ignored");
+ }
+ }
+
+ /* Even if the maximum retries to try to have all the familly addresses
+ * have been spent, we still need the one for the transport familly */
+ if (pcc_state->pcc_addr_tr.ipa_type == IPADDR_NONE) {
+ flog_warn(EC_PATH_PCEP_MISSING_SOURCE_ADDRESS,
+ "skipping connection to PCE %pIA:%d due to missing PCC address",
+ &pcc_state->pce_opts->addr,
+ pcc_state->pce_opts->port);
+ schedule_reconnect(ctrl_state, pcc_state);
+ return 0;
+ }
+
+ PCEP_DEBUG("%s PCC connecting", pcc_state->tag);
+ pcc_state->sess = pcep_lib_connect(
+ &pcc_state->pcc_addr_tr, pcc_state->pcc_opts->port,
+ &pcc_state->pce_opts->addr, pcc_state->pce_opts->port,
+ pcc_state->pcc_opts->msd, &pcc_state->pce_opts->config_opts);
+
+ if (pcc_state->sess == NULL) {
+ flog_warn(EC_PATH_PCEP_LIB_CONNECT,
+ "failed to connect to PCE %pIA:%d from %pIA:%d",
+ &pcc_state->pce_opts->addr,
+ pcc_state->pce_opts->port,
+ &pcc_state->pcc_addr_tr,
+ pcc_state->pcc_opts->port);
+ schedule_reconnect(ctrl_state, pcc_state);
+ return 0;
+ }
+
+ // In case some best pce alternative were waiting to activate
+ if (pcc_state->t_update_best != NULL) {
+ thread_cancel(&pcc_state->t_update_best);
+ pcc_state->t_update_best = NULL;
+ }
+
+ pcc_state->status = PCEP_PCC_CONNECTING;
+
+ return 0;
+}
+
+int pcep_pcc_disable(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state)
+{
+ switch (pcc_state->status) {
+ case PCEP_PCC_DISCONNECTED:
+ return 0;
+ case PCEP_PCC_CONNECTING:
+ case PCEP_PCC_SYNCHRONIZING:
+ case PCEP_PCC_OPERATING:
+ PCEP_DEBUG("%s Disconnecting PCC...", pcc_state->tag);
+ cancel_comp_requests(ctrl_state, pcc_state);
+ pcep_lib_disconnect(pcc_state->sess);
+ /* No need to remove if any PCEs is connected */
+ if (get_pce_count_connected(ctrl_state->pcc) == 0) {
+ pcep_thread_remove_candidate_path_segments(ctrl_state,
+ pcc_state);
+ }
+ pcc_state->sess = NULL;
+ pcc_state->status = PCEP_PCC_DISCONNECTED;
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+void pcep_pcc_sync_path(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct path *path)
+{
+ if (pcc_state->status == PCEP_PCC_SYNCHRONIZING) {
+ path->is_synching = true;
+ } else if (pcc_state->status == PCEP_PCC_OPERATING)
+ path->is_synching = false;
+ else
+ return;
+
+ path->go_active = true;
+
+ /* Accumulate the dynamic paths without any LSP so computation
+ * requests can be performed after synchronization */
+ if ((path->type == SRTE_CANDIDATE_TYPE_DYNAMIC)
+ && (path->first_hop == NULL)
+ && !has_pending_req_for(pcc_state, path)) {
+ PCEP_DEBUG("%s Scheduling computation request for path %s",
+ pcc_state->tag, path->name);
+ push_new_req(pcc_state, path);
+ return;
+ }
+
+ /* Synchronize the path if the PCE supports LSP updates and the
+ * endpoint address familly is supported */
+ if (pcc_state->caps.is_stateful) {
+ if (filter_path(pcc_state, path)) {
+ PCEP_DEBUG("%s Synchronizing path %s", pcc_state->tag,
+ path->name);
+ send_report(pcc_state, path);
+ } else {
+ PCEP_DEBUG(
+ "%s Skipping %s candidate path %s synchronization",
+ pcc_state->tag,
+ ipaddr_type_name(&path->nbkey.endpoint),
+ path->name);
+ }
+ }
+}
+
+void pcep_pcc_sync_done(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ struct req_entry *req;
+
+ if (pcc_state->status != PCEP_PCC_SYNCHRONIZING
+ && pcc_state->status != PCEP_PCC_OPERATING)
+ return;
+
+ if (pcc_state->caps.is_stateful
+ && pcc_state->status == PCEP_PCC_SYNCHRONIZING) {
+ struct path *path = pcep_new_path();
+ *path = (struct path){.name = NULL,
+ .srp_id = 0,
+ .plsp_id = 0,
+ .status = PCEP_LSP_OPERATIONAL_DOWN,
+ .do_remove = false,
+ .go_active = false,
+ .was_created = false,
+ .was_removed = false,
+ .is_synching = false,
+ .is_delegated = false,
+ .first_hop = NULL,
+ .first_metric = NULL};
+ send_report(pcc_state, path);
+ pcep_free_path(path);
+ }
+
+ pcc_state->synchronized = true;
+ pcc_state->status = PCEP_PCC_OPERATING;
+
+ PCEP_DEBUG("%s Synchronization done", pcc_state->tag);
+
+ /* Start the computation request accumulated during synchronization */
+ RB_FOREACH (req, req_entry_head, &pcc_state->requests) {
+ send_comp_request(ctrl_state, pcc_state, req);
+ }
+}
+
+void pcep_pcc_send_report(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct path *path,
+ bool is_stable)
+{
+ if ((pcc_state->status != PCEP_PCC_OPERATING)
+ || (!pcc_state->caps.is_stateful)) {
+ pcep_free_path(path);
+ return;
+ }
+
+ PCEP_DEBUG("(%s)%s Send report for candidate path %s", __func__,
+ pcc_state->tag, path->name);
+
+ /* ODL and Cisco requires the first reported
+ * LSP to have a DOWN status, the later status changes
+ * will be comunicated through hook calls.
+ */
+ enum pcep_lsp_operational_status real_status = path->status;
+ path->status = PCEP_LSP_OPERATIONAL_DOWN;
+ send_report(pcc_state, path);
+
+ /* If no update is expected and the real status wasn't down, we need to
+ * send a second report with the real status */
+ if (is_stable && (real_status != PCEP_LSP_OPERATIONAL_DOWN)) {
+ PCEP_DEBUG("(%s)%s Send report for candidate path (!DOWN) %s",
+ __func__, pcc_state->tag, path->name);
+ path->status = real_status;
+ send_report(pcc_state, path);
+ }
+
+ pcep_free_path(path);
+}
+
+
+void pcep_pcc_send_error(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct pcep_error *error,
+ bool sub_type)
+{
+
+ PCEP_DEBUG("(%s) Send error after PcInitiated ", __func__);
+
+
+ send_pcep_error(pcc_state, error->error_type, error->error_value,
+ error->path);
+ pcep_free_path(error->path);
+ XFREE(MTYPE_PCEP, error);
+}
+/* ------------ Timeout handler ------------ */
+
+void pcep_pcc_timeout_handler(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ enum pcep_ctrl_timeout_type type, void *param)
+{
+ struct req_entry *req;
+
+ switch (type) {
+ case TO_COMPUTATION_REQUEST:
+ assert(param != NULL);
+ req = (struct req_entry *)param;
+ pop_req(pcc_state, req->path->req_id);
+ flog_warn(EC_PATH_PCEP_COMPUTATION_REQUEST_TIMEOUT,
+ "Computation request %d timeout", req->path->req_id);
+ cancel_comp_request(ctrl_state, pcc_state, req);
+ if (req->retry_count++ < MAX_COMPREQ_TRIES) {
+ repush_req(pcc_state, req);
+ send_comp_request(ctrl_state, pcc_state, req);
+ return;
+ }
+ if (pcc_state->caps.is_stateful) {
+ struct path *path;
+ PCEP_DEBUG(
+ "%s Delegating undefined dynamic path %s to PCE %s",
+ pcc_state->tag, req->path->name,
+ pcc_state->originator);
+ path = pcep_copy_path(req->path);
+ path->is_delegated = true;
+ send_report(pcc_state, path);
+ free_req_entry(req);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+
+/* ------------ Pathd event handler ------------ */
+
+void pcep_pcc_pathd_event_handler(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ enum pcep_pathd_event_type type,
+ struct path *path)
+{
+ struct req_entry *req;
+
+ if (pcc_state->status != PCEP_PCC_OPERATING)
+ return;
+
+ /* Skipping candidate path with endpoint that do not match the
+ * configured or deduced PCC IP version */
+ if (!filter_path(pcc_state, path)) {
+ PCEP_DEBUG("%s Skipping %s candidate path %s event",
+ pcc_state->tag,
+ ipaddr_type_name(&path->nbkey.endpoint), path->name);
+ return;
+ }
+
+ switch (type) {
+ case PCEP_PATH_CREATED:
+ if (has_pending_req_for(pcc_state, path)) {
+ PCEP_DEBUG(
+ "%s Candidate path %s created, computation request already sent",
+ pcc_state->tag, path->name);
+ return;
+ }
+ PCEP_DEBUG("%s Candidate path %s created", pcc_state->tag,
+ path->name);
+ if ((path->first_hop == NULL)
+ && (path->type == SRTE_CANDIDATE_TYPE_DYNAMIC)) {
+ req = push_new_req(pcc_state, path);
+ send_comp_request(ctrl_state, pcc_state, req);
+ } else if (pcc_state->caps.is_stateful)
+ send_report(pcc_state, path);
+ return;
+ case PCEP_PATH_UPDATED:
+ PCEP_DEBUG("%s Candidate path %s updated", pcc_state->tag,
+ path->name);
+ if (pcc_state->caps.is_stateful)
+ send_report(pcc_state, path);
+ return;
+ case PCEP_PATH_REMOVED:
+ PCEP_DEBUG("%s Candidate path %s removed", pcc_state->tag,
+ path->name);
+ path->was_removed = true;
+ /* Removed as response to a PcInitiated 'R'emove*/
+ /* RFC 8281 #5.4 LSP Deletion*/
+ path->do_remove = path->was_removed;
+ if (pcc_state->caps.is_stateful)
+ send_report(pcc_state, path);
+ return;
+ default:
+ flog_warn(EC_PATH_PCEP_RECOVERABLE_INTERNAL_ERROR,
+ "Unexpected pathd event received by pcc %s: %u",
+ pcc_state->tag, type);
+ return;
+ }
+}
+
+
+/* ------------ PCEP event handler ------------ */
+
+void pcep_pcc_pcep_event_handler(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, pcep_event *event)
+{
+ PCEP_DEBUG("%s Received PCEP event: %s", pcc_state->tag,
+ pcep_event_type_name(event->event_type));
+ switch (event->event_type) {
+ case PCC_CONNECTED_TO_PCE:
+ assert(PCEP_PCC_CONNECTING == pcc_state->status);
+ PCEP_DEBUG("%s Connection established", pcc_state->tag);
+ pcc_state->status = PCEP_PCC_SYNCHRONIZING;
+ pcc_state->retry_count = 0;
+ pcc_state->synchronized = false;
+ PCEP_DEBUG("%s Starting PCE synchronization", pcc_state->tag);
+ cancel_session_timeout(ctrl_state, pcc_state);
+ pcep_pcc_calculate_best_pce(ctrl_state->pcc);
+ pcep_thread_start_sync(ctrl_state, pcc_state->id);
+ break;
+ case PCC_SENT_INVALID_OPEN:
+ PCEP_DEBUG("%s Sent invalid OPEN message", pcc_state->tag);
+ PCEP_DEBUG(
+ "%s Reconciling values: keep alive (%d) dead timer (%d) seconds ",
+ pcc_state->tag,
+ pcc_state->sess->pcc_config
+ .keep_alive_pce_negotiated_timer_seconds,
+ pcc_state->sess->pcc_config
+ .dead_timer_pce_negotiated_seconds);
+ pcc_state->pce_opts->config_opts.keep_alive_seconds =
+ pcc_state->sess->pcc_config
+ .keep_alive_pce_negotiated_timer_seconds;
+ pcc_state->pce_opts->config_opts.dead_timer_seconds =
+ pcc_state->sess->pcc_config
+ .dead_timer_pce_negotiated_seconds;
+ break;
+
+ case PCC_RCVD_INVALID_OPEN:
+ PCEP_DEBUG("%s Received invalid OPEN message", pcc_state->tag);
+ PCEP_DEBUG_PCEP("%s PCEP message: %s", pcc_state->tag,
+ format_pcep_message(event->message));
+ break;
+ case PCE_DEAD_TIMER_EXPIRED:
+ case PCE_CLOSED_SOCKET:
+ case PCE_SENT_PCEP_CLOSE:
+ case PCE_OPEN_KEEP_WAIT_TIMER_EXPIRED:
+ case PCC_PCEP_SESSION_CLOSED:
+ case PCC_RCVD_MAX_INVALID_MSGS:
+ case PCC_RCVD_MAX_UNKOWN_MSGS:
+ pcep_pcc_disable(ctrl_state, pcc_state);
+ schedule_reconnect(ctrl_state, pcc_state);
+ schedule_session_timeout(ctrl_state, pcc_state);
+ break;
+ case MESSAGE_RECEIVED:
+ PCEP_DEBUG_PCEP("%s Received PCEP message: %s", pcc_state->tag,
+ format_pcep_message(event->message));
+ if (pcc_state->status == PCEP_PCC_CONNECTING) {
+ if (event->message->msg_header->type == PCEP_TYPE_OPEN)
+ handle_pcep_open(ctrl_state, pcc_state,
+ event->message);
+ break;
+ }
+ assert(pcc_state->status == PCEP_PCC_SYNCHRONIZING
+ || pcc_state->status == PCEP_PCC_OPERATING);
+ handle_pcep_message(ctrl_state, pcc_state, event->message);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEPLIB_EVENT,
+ "Unexpected event from pceplib: %s",
+ format_pcep_event(event));
+ break;
+ }
+}
+
+
+/*------------------ Multi-PCE --------------------- */
+
+/* Internal util function, returns true if sync is necessary, false otherwise */
+bool update_best_pce(struct pcc_state **pcc, int best)
+{
+ PCEP_DEBUG(" recalculating pce precedence ");
+ if (best) {
+ struct pcc_state *best_pcc_state =
+ pcep_pcc_get_pcc_by_id(pcc, best);
+ if (best_pcc_state->previous_best != best_pcc_state->is_best) {
+ PCEP_DEBUG(" %s Resynch best (%i) previous best (%i)",
+ best_pcc_state->tag, best_pcc_state->id,
+ best_pcc_state->previous_best);
+ return true;
+ } else {
+ PCEP_DEBUG(
+ " %s No Resynch best (%i) previous best (%i)",
+ best_pcc_state->tag, best_pcc_state->id,
+ best_pcc_state->previous_best);
+ }
+ } else {
+ PCEP_DEBUG(" No best pce available, all pce seem disconnected");
+ }
+
+ return false;
+}
+
+int get_best_pce(struct pcc_state **pcc)
+{
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] && pcc[i]->pce_opts) {
+ if (pcc[i]->is_best == true) {
+ return pcc[i]->id;
+ }
+ }
+ }
+ return 0;
+}
+
+int get_pce_count_connected(struct pcc_state **pcc)
+{
+ int count = 0;
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] && pcc[i]->pce_opts
+ && pcc[i]->status != PCEP_PCC_DISCONNECTED) {
+ count++;
+ }
+ }
+ return count;
+}
+
+int get_previous_best_pce(struct pcc_state **pcc)
+{
+ int previous_best_pce = -1;
+
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] && pcc[i]->pce_opts && pcc[i]->previous_best == true
+ && pcc[i]->status != PCEP_PCC_DISCONNECTED) {
+ previous_best_pce = i;
+ break;
+ }
+ }
+ return previous_best_pce != -1 ? pcc[previous_best_pce]->id : 0;
+}
+
+/* Called by path_pcep_controller EV_REMOVE_PCC
+ * Event handler when a PCC is removed. */
+int pcep_pcc_multi_pce_remove_pcc(struct ctrl_state *ctrl_state,
+ struct pcc_state **pcc)
+{
+ int new_best_pcc_id = -1;
+ new_best_pcc_id = pcep_pcc_calculate_best_pce(pcc);
+ if (new_best_pcc_id) {
+ if (update_best_pce(ctrl_state->pcc, new_best_pcc_id) == true) {
+ pcep_thread_start_sync(ctrl_state, new_best_pcc_id);
+ }
+ }
+
+ return 0;
+}
+
+/* Called by path_pcep_controller EV_SYNC_PATH
+ * Event handler when a path is sync'd. */
+int pcep_pcc_multi_pce_sync_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct pcc_state **pcc)
+{
+ int previous_best_pcc_id = -1;
+
+ if (pcc_id == get_best_pce(pcc)) {
+ previous_best_pcc_id = get_previous_best_pce(pcc);
+ if (previous_best_pcc_id != 0) {
+ /* while adding new pce, path has to resync to the
+ * previous best. pcep_thread_start_sync() will be
+ * called by the calling function */
+ if (update_best_pce(ctrl_state->pcc,
+ previous_best_pcc_id)
+ == true) {
+ cancel_comp_requests(
+ ctrl_state,
+ pcep_pcc_get_pcc_by_id(
+ pcc, previous_best_pcc_id));
+ pcep_thread_start_sync(ctrl_state,
+ previous_best_pcc_id);
+ }
+ }
+ }
+
+ return 0;
+}
+
+/* Called by path_pcep_controller when the TM_CALCULATE_BEST_PCE
+ * timer expires */
+int pcep_pcc_timer_update_best_pce(struct ctrl_state *ctrl_state, int pcc_id)
+{
+ int ret = 0;
+ /* resync whatever was the new best */
+ int prev_best = get_best_pce(ctrl_state->pcc);
+ int best_id = pcep_pcc_calculate_best_pce(ctrl_state->pcc);
+ if (best_id && prev_best != best_id) { // Avoid Multiple call
+ struct pcc_state *pcc_state =
+ pcep_pcc_get_pcc_by_id(ctrl_state->pcc, best_id);
+ if (update_best_pce(ctrl_state->pcc, pcc_state->id) == true) {
+ pcep_thread_start_sync(ctrl_state, pcc_state->id);
+ }
+ }
+
+ return ret;
+}
+
+/* Called by path_pcep_controller::pcep_thread_event_update_pce_options()
+ * Returns the best PCE id */
+int pcep_pcc_calculate_best_pce(struct pcc_state **pcc)
+{
+ int best_precedence = 255; // DEFAULT_PCE_PRECEDENCE;
+ int best_pce = -1;
+ int one_connected_pce = -1;
+ int previous_best_pce = -1;
+ int step_0_best = -1;
+ int step_0_previous = -1;
+ int pcc_count = 0;
+
+ // Get state
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] && pcc[i]->pce_opts) {
+ zlog_debug(
+ "multi-pce: calculate all : i (%i) is_best (%i) previous_best (%i) ",
+ i, pcc[i]->is_best, pcc[i]->previous_best);
+ pcc_count++;
+
+ if (pcc[i]->is_best == true) {
+ step_0_best = i;
+ }
+ if (pcc[i]->previous_best == true) {
+ step_0_previous = i;
+ }
+ }
+ }
+
+ if (!pcc_count) {
+ return 0;
+ }
+
+ // Calculate best
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] && pcc[i]->pce_opts
+ && pcc[i]->status != PCEP_PCC_DISCONNECTED) {
+ one_connected_pce = i; // In case none better
+ if (pcc[i]->pce_opts->precedence <= best_precedence) {
+ if (best_pce != -1
+ && pcc[best_pce]->pce_opts->precedence
+ == pcc[i]->pce_opts
+ ->precedence) {
+ if (ipaddr_cmp(
+ &pcc[i]->pce_opts->addr,
+ &pcc[best_pce]
+ ->pce_opts->addr)
+ > 0)
+ // collide of precedences so
+ // compare ip
+ best_pce = i;
+ } else {
+ if (!pcc[i]->previous_best) {
+ best_precedence =
+ pcc[i]->pce_opts
+ ->precedence;
+ best_pce = i;
+ }
+ }
+ }
+ }
+ }
+
+ zlog_debug(
+ "multi-pce: calculate data : sb (%i) sp (%i) oc (%i) b (%i) ",
+ step_0_best, step_0_previous, one_connected_pce, best_pce);
+
+ // Changed of state so ...
+ if (step_0_best != best_pce) {
+ pthread_mutex_lock(&g_pcc_info_mtx);
+ // Calculate previous
+ previous_best_pce = step_0_best;
+ // Clean state
+ if (step_0_best != -1) {
+ pcc[step_0_best]->is_best = false;
+ }
+ if (step_0_previous != -1) {
+ pcc[step_0_previous]->previous_best = false;
+ }
+
+ // Set previous
+ if (previous_best_pce != -1
+ && pcc[previous_best_pce]->status
+ == PCEP_PCC_DISCONNECTED) {
+ pcc[previous_best_pce]->previous_best = true;
+ zlog_debug("multi-pce: previous best pce (%i) ",
+ previous_best_pce + 1);
+ }
+
+
+ // Set best
+ if (best_pce != -1) {
+ pcc[best_pce]->is_best = true;
+ zlog_debug("multi-pce: best pce (%i) ", best_pce + 1);
+ } else {
+ if (one_connected_pce != -1) {
+ best_pce = one_connected_pce;
+ pcc[one_connected_pce]->is_best = true;
+ zlog_debug(
+ "multi-pce: one connected best pce (default) (%i) ",
+ one_connected_pce + 1);
+ } else {
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] && pcc[i]->pce_opts) {
+ best_pce = i;
+ pcc[i]->is_best = true;
+ zlog_debug(
+ "(disconnected) best pce (default) (%i) ",
+ i + 1);
+ break;
+ }
+ }
+ }
+ }
+ pthread_mutex_unlock(&g_pcc_info_mtx);
+ }
+
+ return ((best_pce == -1) ? 0 : pcc[best_pce]->id);
+}
+
+int pcep_pcc_get_pcc_id_by_ip_port(struct pcc_state **pcc,
+ struct pce_opts *pce_opts)
+{
+ if (pcc == NULL) {
+ return 0;
+ }
+
+ for (int idx = 0; idx < MAX_PCC; idx++) {
+ if (pcc[idx]) {
+ if ((ipaddr_cmp((const struct ipaddr *)&pcc[idx]
+ ->pce_opts->addr,
+ (const struct ipaddr *)&pce_opts->addr)
+ == 0)
+ && pcc[idx]->pce_opts->port == pce_opts->port) {
+ zlog_debug("found pcc_id (%d) idx (%d)",
+ pcc[idx]->id, idx);
+ return pcc[idx]->id;
+ }
+ }
+ }
+ return 0;
+}
+
+int pcep_pcc_get_pcc_id_by_idx(struct pcc_state **pcc, int idx)
+{
+ if (pcc == NULL || idx < 0) {
+ return 0;
+ }
+
+ return pcc[idx] ? pcc[idx]->id : 0;
+}
+
+struct pcc_state *pcep_pcc_get_pcc_by_id(struct pcc_state **pcc, int id)
+{
+ if (pcc == NULL || id < 0) {
+ return NULL;
+ }
+
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i]) {
+ if (pcc[i]->id == id) {
+ zlog_debug("found id (%d) pcc_idx (%d)",
+ pcc[i]->id, i);
+ return pcc[i];
+ }
+ }
+ }
+
+ return NULL;
+}
+
+struct pcc_state *pcep_pcc_get_pcc_by_name(struct pcc_state **pcc,
+ const char *pce_name)
+{
+ if (pcc == NULL || pce_name == NULL) {
+ return NULL;
+ }
+
+ for (int i = 0; i < MAX_PCC; i++) {
+ if (pcc[i] == NULL) {
+ continue;
+ }
+
+ if (strcmp(pcc[i]->pce_opts->pce_name, pce_name) == 0) {
+ return pcc[i];
+ }
+ }
+
+ return NULL;
+}
+
+int pcep_pcc_get_pcc_idx_by_id(struct pcc_state **pcc, int id)
+{
+ if (pcc == NULL) {
+ return -1;
+ }
+
+ for (int idx = 0; idx < MAX_PCC; idx++) {
+ if (pcc[idx]) {
+ if (pcc[idx]->id == id) {
+ zlog_debug("found pcc_id (%d) array_idx (%d)",
+ pcc[idx]->id, idx);
+ return idx;
+ }
+ }
+ }
+
+ return -1;
+}
+
+int pcep_pcc_get_free_pcc_idx(struct pcc_state **pcc)
+{
+ assert(pcc != NULL);
+
+ for (int idx = 0; idx < MAX_PCC; idx++) {
+ if (pcc[idx] == NULL) {
+ zlog_debug("new pcc_idx (%d)", idx);
+ return idx;
+ }
+ }
+
+ return -1;
+}
+
+int pcep_pcc_get_pcc_id(struct pcc_state *pcc)
+{
+ return ((pcc == NULL) ? 0 : pcc->id);
+}
+
+void pcep_pcc_copy_pcc_info(struct pcc_state **pcc,
+ struct pcep_pcc_info *pcc_info)
+{
+ struct pcc_state *pcc_state =
+ pcep_pcc_get_pcc_by_name(pcc, pcc_info->pce_name);
+ if (!pcc_state) {
+ return;
+ }
+
+ pcc_info->ctrl_state = NULL;
+ if(pcc_state->pcc_opts){
+ pcc_info->msd = pcc_state->pcc_opts->msd;
+ pcc_info->pcc_port = pcc_state->pcc_opts->port;
+ }
+ pcc_info->next_plspid = pcc_state->next_plspid;
+ pcc_info->next_reqid = pcc_state->next_reqid;
+ pcc_info->status = pcc_state->status;
+ pcc_info->pcc_id = pcc_state->id;
+ pthread_mutex_lock(&g_pcc_info_mtx);
+ pcc_info->is_best_multi_pce = pcc_state->is_best;
+ pcc_info->previous_best = pcc_state->previous_best;
+ pthread_mutex_unlock(&g_pcc_info_mtx);
+ pcc_info->precedence =
+ pcc_state->pce_opts ? pcc_state->pce_opts->precedence : 0;
+ if(pcc_state->pcc_addr_tr.ipa_type != IPADDR_NONE){
+ memcpy(&pcc_info->pcc_addr, &pcc_state->pcc_addr_tr,
+ sizeof(struct ipaddr));
+ }
+}
+
+
+/*------------------ PCEP Message handlers --------------------- */
+
+void handle_pcep_open(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct pcep_message *msg)
+{
+ assert(msg->msg_header->type == PCEP_TYPE_OPEN);
+ pcep_lib_parse_capabilities(msg, &pcc_state->caps);
+ PCEP_DEBUG("PCE capabilities: %s, %s%s",
+ pcc_state->caps.is_stateful ? "stateful" : "stateless",
+ pcc_state->caps.supported_ofs_are_known
+ ? (pcc_state->caps.supported_ofs == 0
+ ? "no objective functions supported"
+ : "supported objective functions are ")
+ : "supported objective functions are unknown",
+ format_objfun_set(pcc_state->caps.supported_ofs));
+}
+
+void handle_pcep_message(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct pcep_message *msg)
+{
+ if (pcc_state->status != PCEP_PCC_OPERATING)
+ return;
+
+ switch (msg->msg_header->type) {
+ case PCEP_TYPE_INITIATE:
+ handle_pcep_lsp_initiate(ctrl_state, pcc_state, msg);
+ break;
+ case PCEP_TYPE_UPDATE:
+ handle_pcep_lsp_update(ctrl_state, pcc_state, msg);
+ break;
+ case PCEP_TYPE_PCREP:
+ handle_pcep_comp_reply(ctrl_state, pcc_state, msg);
+ break;
+ default:
+ flog_warn(EC_PATH_PCEP_UNEXPECTED_PCEP_MESSAGE,
+ "Unexpected pcep message from pceplib: %s",
+ format_pcep_message(msg));
+ break;
+ }
+}
+
+void handle_pcep_lsp_update(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg)
+{
+ struct path *path;
+ path = pcep_lib_parse_path(msg);
+ lookup_nbkey(pcc_state, path);
+ pcep_thread_refine_path(ctrl_state, pcc_state->id,
+ &continue_pcep_lsp_update, path, NULL);
+}
+
+void continue_pcep_lsp_update(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct path *path,
+ void *payload)
+{
+ char err[MAX_ERROR_MSG_SIZE] = {0};
+
+ specialize_incoming_path(pcc_state, path);
+ PCEP_DEBUG("%s Received LSP update", pcc_state->tag);
+ PCEP_DEBUG_PATH("%s", format_path(path));
+
+ if (validate_incoming_path(pcc_state, path, err, sizeof(err)))
+ pcep_thread_update_path(ctrl_state, pcc_state->id, path);
+ else {
+ /* FIXME: Monitor the amount of errors from the PCE and
+ * possibly disconnect and blacklist */
+ flog_warn(EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "Unsupported PCEP protocol feature: %s", err);
+ pcep_free_path(path);
+ }
+}
+
+void handle_pcep_lsp_initiate(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg)
+{
+ char err[MAX_ERROR_MSG_SIZE] = "";
+ struct path *path;
+
+ path = pcep_lib_parse_path(msg);
+
+ if (!pcc_state->pce_opts->config_opts.pce_initiated) {
+ /* PCE Initiated is not enabled */
+ flog_warn(EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "Not allowed PCE initiated path received: %s",
+ format_pcep_message(msg));
+ send_pcep_error(pcc_state, PCEP_ERRT_LSP_INSTANTIATE_ERROR,
+ PCEP_ERRV_UNACCEPTABLE_INSTANTIATE_ERROR, path);
+ return;
+ }
+
+ if (path->do_remove) {
+ // lookup in nbkey sequential as no endpoint
+ struct nbkey_map_data *key;
+ char endpoint[46];
+
+ frr_each (nbkey_map, &pcc_state->nbkey_map, key) {
+ ipaddr2str(&key->nbkey.endpoint, endpoint,
+ sizeof(endpoint));
+ flog_warn(
+ EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "FOR_EACH nbkey [color (%d) endpoint (%s)] path [plsp_id (%d)] ",
+ key->nbkey.color, endpoint, path->plsp_id);
+ if (path->plsp_id == key->plspid) {
+ flog_warn(
+ EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "FOR_EACH MATCH nbkey [color (%d) endpoint (%s)] path [plsp_id (%d)] ",
+ key->nbkey.color, endpoint,
+ path->plsp_id);
+ path->nbkey = key->nbkey;
+ break;
+ }
+ }
+ } else {
+ if (path->first_hop == NULL /*ero sets first_hop*/) {
+ /* If the PCC receives a PCInitiate message without an
+ * ERO and the R flag in the SRP object != zero, then it
+ * MUST send a PCErr message with Error-type=6
+ * (Mandatory Object missing) and Error-value=9 (ERO
+ * object missing). */
+ flog_warn(EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "ERO object missing or incomplete : %s",
+ format_pcep_message(msg));
+ send_pcep_error(pcc_state,
+ PCEP_ERRT_LSP_INSTANTIATE_ERROR,
+ PCEP_ERRV_INTERNAL_ERROR, path);
+ return;
+ }
+
+ if (path->plsp_id != 0) {
+ /* If the PCC receives a PCInitiate message with a
+ * non-zero PLSP-ID and the R flag in the SRP object set
+ * to zero, then it MUST send a PCErr message with
+ * Error-type=19 (Invalid Operation) and Error-value=8
+ * (Non-zero PLSP-ID in the LSP Initiate Request) */
+ flog_warn(
+ EC_PATH_PCEP_PROTOCOL_ERROR,
+ "PCE initiated path with non-zero PLSP ID: %s",
+ format_pcep_message(msg));
+ send_pcep_error(pcc_state, PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_INIT_NON_ZERO_PLSP_ID,
+ path);
+ return;
+ }
+
+ if (path->name == NULL) {
+ /* If the PCC receives a PCInitiate message without a
+ * SYMBOLIC-PATH-NAME TLV, then it MUST send a PCErr
+ * message with Error-type=10 (Reception of an invalid
+ * object) and Error-value=8 (SYMBOLIC-PATH-NAME TLV
+ * missing) */
+ flog_warn(
+ EC_PATH_PCEP_PROTOCOL_ERROR,
+ "PCE initiated path without symbolic name: %s",
+ format_pcep_message(msg));
+ send_pcep_error(
+ pcc_state, PCEP_ERRT_RECEPTION_OF_INV_OBJECT,
+ PCEP_ERRV_SYMBOLIC_PATH_NAME_TLV_MISSING, path);
+ return;
+ }
+ }
+
+ /* TODO: If there is a conflict with the symbolic path name of an
+ * existing LSP, the PCC MUST send a PCErr message with Error-type=23
+ * (Bad Parameter value) and Error-value=1 (SYMBOLIC-PATH-NAME in
+ * use) */
+
+ specialize_incoming_path(pcc_state, path);
+ /* TODO: Validate the PCC address received from the PCE is valid */
+ PCEP_DEBUG("%s Received LSP initiate", pcc_state->tag);
+ PCEP_DEBUG_PATH("%s", format_path(path));
+
+ if (validate_incoming_path(pcc_state, path, err, sizeof(err))) {
+ pcep_thread_initiate_path(ctrl_state, pcc_state->id, path);
+ } else {
+ /* FIXME: Monitor the amount of errors from the PCE and
+ * possibly disconnect and blacklist */
+ flog_warn(EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "Unsupported PCEP protocol feature: %s", err);
+ send_pcep_error(pcc_state, PCEP_ERRT_INVALID_OPERATION,
+ PCEP_ERRV_LSP_NOT_PCE_INITIATED, path);
+ pcep_free_path(path);
+ }
+}
+
+void handle_pcep_comp_reply(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ struct pcep_message *msg)
+{
+ char err[MAX_ERROR_MSG_SIZE] = "";
+ struct req_entry *req;
+ struct path *path;
+
+ path = pcep_lib_parse_path(msg);
+ if (path->no_path) {
+ req = pop_req_no_reqid(pcc_state, path->req_id);
+ } else {
+ req = pop_req(pcc_state, path->req_id);
+ }
+ if (req == NULL) {
+ /* TODO: check the rate of bad computation reply and close
+ * the connection if more that a given rate.
+ */
+ PCEP_DEBUG(
+ "%s Received computation reply for unknown request %d",
+ pcc_state->tag, path->req_id);
+ PCEP_DEBUG_PATH("%s", format_path(path));
+ send_pcep_error(pcc_state, PCEP_ERRT_UNKNOWN_REQ_REF,
+ PCEP_ERRV_UNASSIGNED, NULL);
+ return;
+ }
+
+ /* Cancel the computation request timeout */
+ pcep_thread_cancel_timer(&req->t_retry);
+
+ /* Transfer relevent metadata from the request to the response */
+ path->nbkey = req->path->nbkey;
+ path->plsp_id = req->path->plsp_id;
+ path->type = req->path->type;
+ path->name = XSTRDUP(MTYPE_PCEP, req->path->name);
+ specialize_incoming_path(pcc_state, path);
+
+ PCEP_DEBUG("%s Received computation reply %d (no-path: %s)",
+ pcc_state->tag, path->req_id,
+ path->no_path ? "true" : "false");
+ PCEP_DEBUG_PATH("%s", format_path(path));
+
+ if (path->no_path) {
+ PCEP_DEBUG("%s Computation for path %s did not find any result",
+ pcc_state->tag, path->name);
+ free_req_entry(req);
+ pcep_free_path(path);
+ return;
+ } else if (validate_incoming_path(pcc_state, path, err, sizeof(err))) {
+ /* Updating a dynamic path will automatically delegate it */
+ pcep_thread_update_path(ctrl_state, pcc_state->id, path);
+ free_req_entry(req);
+ return;
+ } else {
+ /* FIXME: Monitor the amount of errors from the PCE and
+ * possibly disconnect and blacklist */
+ flog_warn(EC_PATH_PCEP_UNSUPPORTED_PCEP_FEATURE,
+ "Unsupported PCEP protocol feature: %s", err);
+ }
+
+ pcep_free_path(path);
+
+ /* Delegate the path regardless of the outcome */
+ /* TODO: For now we are using the path from the request, when
+ * pathd API is thread safe, we could get a new path */
+ if (pcc_state->caps.is_stateful) {
+ PCEP_DEBUG("%s Delegating undefined dynamic path %s to PCE %s",
+ pcc_state->tag, req->path->name,
+ pcc_state->originator);
+ path = pcep_copy_path(req->path);
+ path->is_delegated = true;
+ send_report(pcc_state, path);
+ pcep_free_path(path);
+ }
+
+ free_req_entry(req);
+}
+
+
+/* ------------ Internal Functions ------------ */
+
+const char *ipaddr_type_name(struct ipaddr *addr)
+{
+ if (IS_IPADDR_V4(addr))
+ return "IPv4";
+ if (IS_IPADDR_V6(addr))
+ return "IPv6";
+ return "undefined";
+}
+
+bool filter_path(struct pcc_state *pcc_state, struct path *path)
+{
+ return (IS_IPADDR_V4(&path->nbkey.endpoint)
+ && CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4))
+ || (IS_IPADDR_V6(&path->nbkey.endpoint)
+ && CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6));
+}
+
+void select_pcc_addresses(struct pcc_state *pcc_state)
+{
+ /* If no IPv4 address was specified, try to get one from zebra */
+ if (!CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4)) {
+ if (get_ipv4_router_id(&pcc_state->pcc_addr_v4)) {
+ SET_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4);
+ }
+ }
+
+ /* If no IPv6 address was specified, try to get one from zebra */
+ if (!CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6)) {
+ if (get_ipv6_router_id(&pcc_state->pcc_addr_v6)) {
+ SET_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6);
+ }
+ }
+}
+
+void select_transport_address(struct pcc_state *pcc_state)
+{
+ struct ipaddr *taddr = &pcc_state->pcc_addr_tr;
+
+ select_pcc_addresses(pcc_state);
+
+ taddr->ipa_type = IPADDR_NONE;
+
+ /* Select a transport source address in function of the configured PCE
+ * address */
+ if (IS_IPADDR_V4(&pcc_state->pce_opts->addr)) {
+ if (CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4)) {
+ taddr->ipaddr_v4 = pcc_state->pcc_addr_v4;
+ taddr->ipa_type = IPADDR_V4;
+ }
+ } else {
+ if (CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6)) {
+ taddr->ipaddr_v6 = pcc_state->pcc_addr_v6;
+ taddr->ipa_type = IPADDR_V6;
+ }
+ }
+}
+
+void update_tag(struct pcc_state *pcc_state)
+{
+ if (pcc_state->pce_opts != NULL) {
+ assert(!IS_IPADDR_NONE(&pcc_state->pce_opts->addr));
+ if (IS_IPADDR_V6(&pcc_state->pce_opts->addr)) {
+ snprintfrr(pcc_state->tag, sizeof(pcc_state->tag),
+ "%pI6:%i (%u)",
+ &pcc_state->pce_opts->addr.ipaddr_v6,
+ pcc_state->pce_opts->port, pcc_state->id);
+ } else {
+ snprintfrr(pcc_state->tag, sizeof(pcc_state->tag),
+ "%pI4:%i (%u)",
+ &pcc_state->pce_opts->addr.ipaddr_v4,
+ pcc_state->pce_opts->port, pcc_state->id);
+ }
+ } else {
+ snprintfrr(pcc_state->tag, sizeof(pcc_state->tag), "(%u)",
+ pcc_state->id);
+ }
+}
+
+void update_originator(struct pcc_state *pcc_state)
+{
+ char *originator;
+ if (pcc_state->originator != NULL) {
+ XFREE(MTYPE_PCEP, pcc_state->originator);
+ pcc_state->originator = NULL;
+ }
+ if (pcc_state->pce_opts == NULL)
+ return;
+ originator = XCALLOC(MTYPE_PCEP, 52);
+ assert(!IS_IPADDR_NONE(&pcc_state->pce_opts->addr));
+ if (IS_IPADDR_V6(&pcc_state->pce_opts->addr)) {
+ snprintfrr(originator, 52, "%pI6:%i",
+ &pcc_state->pce_opts->addr.ipaddr_v6,
+ pcc_state->pce_opts->port);
+ } else {
+ snprintfrr(originator, 52, "%pI4:%i",
+ &pcc_state->pce_opts->addr.ipaddr_v4,
+ pcc_state->pce_opts->port);
+ }
+ pcc_state->originator = originator;
+}
+
+void schedule_reconnect(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ pcc_state->retry_count++;
+ pcep_thread_schedule_reconnect(ctrl_state, pcc_state->id,
+ pcc_state->retry_count,
+ &pcc_state->t_reconnect);
+ if (pcc_state->retry_count == 1) {
+ pcep_thread_schedule_sync_best_pce(
+ ctrl_state, pcc_state->id,
+ pcc_state->pce_opts->config_opts
+ .delegation_timeout_seconds,
+ &pcc_state->t_update_best);
+ }
+}
+
+void schedule_session_timeout(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ /* No need to schedule timeout if multiple PCEs are connected */
+ if (get_pce_count_connected(ctrl_state->pcc)) {
+ PCEP_DEBUG_PCEP(
+ "schedule_session_timeout not setting timer for multi-pce mode");
+
+ return;
+ }
+
+ pcep_thread_schedule_session_timeout(
+ ctrl_state, pcep_pcc_get_pcc_id(pcc_state),
+ pcc_state->pce_opts->config_opts
+ .session_timeout_inteval_seconds,
+ &pcc_state->t_session_timeout);
+}
+
+void cancel_session_timeout(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ /* No need to schedule timeout if multiple PCEs are connected */
+ if (pcc_state->t_session_timeout == NULL) {
+ PCEP_DEBUG_PCEP("cancel_session_timeout timer thread NULL");
+ return;
+ }
+
+ PCEP_DEBUG_PCEP("Cancel session_timeout timer");
+ pcep_thread_cancel_timer(&pcc_state->t_session_timeout);
+ pcc_state->t_session_timeout = NULL;
+}
+
+void send_pcep_message(struct pcc_state *pcc_state, struct pcep_message *msg)
+{
+ if (pcc_state->sess != NULL) {
+ PCEP_DEBUG_PCEP("%s Sending PCEP message: %s", pcc_state->tag,
+ format_pcep_message(msg));
+ send_message(pcc_state->sess, msg, true);
+ }
+}
+
+void send_pcep_error(struct pcc_state *pcc_state,
+ enum pcep_error_type error_type,
+ enum pcep_error_value error_value,
+ struct path *trigger_path)
+{
+ struct pcep_message *msg;
+ PCEP_DEBUG("%s Sending PCEP error type %s (%d) value %s (%d)",
+ pcc_state->tag, pcep_error_type_name(error_type), error_type,
+ pcep_error_value_name(error_type, error_value), error_value);
+ msg = pcep_lib_format_error(error_type, error_value, trigger_path);
+ send_pcep_message(pcc_state, msg);
+}
+
+void send_report(struct pcc_state *pcc_state, struct path *path)
+{
+ struct pcep_message *report;
+
+ path->req_id = 0;
+ specialize_outgoing_path(pcc_state, path);
+ PCEP_DEBUG_PATH("%s Sending path %s: %s", pcc_state->tag, path->name,
+ format_path(path));
+ report = pcep_lib_format_report(&pcc_state->caps, path);
+ send_pcep_message(pcc_state, report);
+}
+
+/* Updates the path for the PCE, updating the delegation and creation flags */
+void specialize_outgoing_path(struct pcc_state *pcc_state, struct path *path)
+{
+ bool is_delegated = false;
+ bool was_created = false;
+
+ lookup_plspid(pcc_state, path);
+
+ set_pcc_address(pcc_state, &path->nbkey, &path->pcc_addr);
+ path->sender = pcc_state->pcc_addr_tr;
+
+ /* TODO: When the pathd API have a way to mark a path as
+ * delegated, use it instead of considering all dynamic path
+ * delegated. We need to disable the originator check for now,
+ * because path could be delegated without having any originator yet */
+ // if ((path->originator == NULL)
+ // || (strcmp(path->originator, pcc_state->originator) == 0)) {
+ // is_delegated = (path->type == SRTE_CANDIDATE_TYPE_DYNAMIC)
+ // && (path->first_hop != NULL);
+ // /* it seems the PCE consider updating an LSP a creation ?!?
+ // at least Cisco does... */
+ // was_created = path->update_origin == SRTE_ORIGIN_PCEP;
+ // }
+ is_delegated = (path->type == SRTE_CANDIDATE_TYPE_DYNAMIC);
+ was_created = path->update_origin == SRTE_ORIGIN_PCEP;
+
+ path->pcc_id = pcc_state->id;
+ path->go_active = is_delegated && pcc_state->is_best;
+ path->is_delegated = is_delegated && pcc_state->is_best;
+ path->was_created = was_created;
+}
+
+/* Updates the path for the PCC */
+void specialize_incoming_path(struct pcc_state *pcc_state, struct path *path)
+{
+ if (IS_IPADDR_NONE(&path->pcc_addr))
+ set_pcc_address(pcc_state, &path->nbkey, &path->pcc_addr);
+ path->sender = pcc_state->pce_opts->addr;
+ path->pcc_id = pcc_state->id;
+ path->update_origin = SRTE_ORIGIN_PCEP;
+ path->originator = XSTRDUP(MTYPE_PCEP, pcc_state->originator);
+}
+
+/* Ensure the path can be handled by the PCC and if not, sends an error */
+bool validate_incoming_path(struct pcc_state *pcc_state, struct path *path,
+ char *errbuff, size_t buffsize)
+{
+ struct path_hop *hop;
+ enum pcep_error_type err_type = 0;
+ enum pcep_error_value err_value = PCEP_ERRV_UNASSIGNED;
+
+ for (hop = path->first_hop; hop != NULL; hop = hop->next) {
+ /* Hops without SID are not supported */
+ if (!hop->has_sid) {
+ snprintfrr(errbuff, buffsize, "SR segment without SID");
+ err_type = PCEP_ERRT_RECEPTION_OF_INV_OBJECT;
+ err_value = PCEP_ERRV_DISJOINTED_CONF_TLV_MISSING;
+ break;
+ }
+ /* Hops with non-MPLS SID are not supported */
+ if (!hop->is_mpls) {
+ snprintfrr(errbuff, buffsize,
+ "SR segment with non-MPLS SID");
+ err_type = PCEP_ERRT_RECEPTION_OF_INV_OBJECT;
+ err_value = PCEP_ERRV_UNSUPPORTED_NAI;
+ break;
+ }
+ }
+
+ if (err_type != 0) {
+ send_pcep_error(pcc_state, err_type, err_value, NULL);
+ return false;
+ }
+
+ return true;
+}
+
+void send_comp_request(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct req_entry *req)
+{
+ assert(req != NULL);
+
+ if (req->t_retry)
+ return;
+
+ assert(req->path != NULL);
+ assert(req->path->req_id > 0);
+ assert(RB_FIND(req_entry_head, &pcc_state->requests, req) == req);
+ assert(lookup_reqid(pcc_state, req->path) == req->path->req_id);
+
+ int timeout;
+ struct pcep_message *msg;
+
+ if (!pcc_state->is_best) {
+ return;
+ }
+
+ specialize_outgoing_path(pcc_state, req->path);
+
+ PCEP_DEBUG(
+ "%s Sending computation request %d for path %s to %pIA (retry %d)",
+ pcc_state->tag, req->path->req_id, req->path->name,
+ &req->path->nbkey.endpoint, req->retry_count);
+ PCEP_DEBUG_PATH("%s Computation request path %s: %s", pcc_state->tag,
+ req->path->name, format_path(req->path));
+
+ msg = pcep_lib_format_request(&pcc_state->caps, req->path);
+ send_pcep_message(pcc_state, msg);
+ req->was_sent = true;
+
+ timeout = pcc_state->pce_opts->config_opts.pcep_request_time_seconds;
+ pcep_thread_schedule_timeout(ctrl_state, pcc_state->id,
+ TO_COMPUTATION_REQUEST, timeout,
+ (void *)req, &req->t_retry);
+}
+
+void cancel_comp_requests(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state)
+{
+ struct req_entry *req, *safe_req;
+
+ RB_FOREACH_SAFE (req, req_entry_head, &pcc_state->requests, safe_req) {
+ cancel_comp_request(ctrl_state, pcc_state, req);
+ RB_REMOVE(req_entry_head, &pcc_state->requests, req);
+ remove_reqid_mapping(pcc_state, req->path);
+ free_req_entry(req);
+ }
+}
+
+void cancel_comp_request(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct req_entry *req)
+{
+ struct pcep_message *msg;
+
+ if (req->was_sent) {
+ /* TODO: Send a computation request cancelation
+ * notification to the PCE */
+ pcep_thread_cancel_timer(&req->t_retry);
+ }
+
+ PCEP_DEBUG(
+ "%s Canceling computation request %d for path %s to %pIA (retry %d)",
+ pcc_state->tag, req->path->req_id, req->path->name,
+ &req->path->nbkey.endpoint, req->retry_count);
+ PCEP_DEBUG_PATH("%s Canceled computation request path %s: %s",
+ pcc_state->tag, req->path->name,
+ format_path(req->path));
+
+ msg = pcep_lib_format_request_cancelled(req->path->req_id);
+ send_pcep_message(pcc_state, msg);
+}
+
+void set_pcc_address(struct pcc_state *pcc_state, struct lsp_nb_key *nbkey,
+ struct ipaddr *addr)
+{
+ select_pcc_addresses(pcc_state);
+ if (IS_IPADDR_V6(&nbkey->endpoint)) {
+ assert(CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV6));
+ addr->ipa_type = IPADDR_V6;
+ addr->ipaddr_v6 = pcc_state->pcc_addr_v6;
+ } else if (IS_IPADDR_V4(&nbkey->endpoint)) {
+ assert(CHECK_FLAG(pcc_state->flags, F_PCC_STATE_HAS_IPV4));
+ addr->ipa_type = IPADDR_V4;
+ addr->ipaddr_v4 = pcc_state->pcc_addr_v4;
+ } else {
+ addr->ipa_type = IPADDR_NONE;
+ }
+}
+
+/* ------------ Data Structure Helper Functions ------------ */
+
+void lookup_plspid(struct pcc_state *pcc_state, struct path *path)
+{
+ struct plspid_map_data key, *plspid_mapping;
+ struct nbkey_map_data *nbkey_mapping;
+
+ if (path->nbkey.color != 0) {
+ key.nbkey = path->nbkey;
+ plspid_mapping = plspid_map_find(&pcc_state->plspid_map, &key);
+ if (plspid_mapping == NULL) {
+ plspid_mapping =
+ XCALLOC(MTYPE_PCEP, sizeof(*plspid_mapping));
+ plspid_mapping->nbkey = key.nbkey;
+ plspid_mapping->plspid = pcc_state->next_plspid;
+ plspid_map_add(&pcc_state->plspid_map, plspid_mapping);
+ nbkey_mapping =
+ XCALLOC(MTYPE_PCEP, sizeof(*nbkey_mapping));
+ nbkey_mapping->nbkey = key.nbkey;
+ nbkey_mapping->plspid = pcc_state->next_plspid;
+ nbkey_map_add(&pcc_state->nbkey_map, nbkey_mapping);
+ pcc_state->next_plspid++;
+ // FIXME: Send some error to the PCE isntead of crashing
+ assert(pcc_state->next_plspid <= 1048576);
+ }
+ path->plsp_id = plspid_mapping->plspid;
+ }
+}
+
+void lookup_nbkey(struct pcc_state *pcc_state, struct path *path)
+{
+ struct nbkey_map_data key, *mapping;
+ // TODO: Should give an error to the PCE instead of crashing
+ assert(path->plsp_id != 0);
+ key.plspid = path->plsp_id;
+ mapping = nbkey_map_find(&pcc_state->nbkey_map, &key);
+ assert(mapping != NULL);
+ path->nbkey = mapping->nbkey;
+}
+
+void free_req_entry(struct req_entry *req)
+{
+ pcep_free_path(req->path);
+ XFREE(MTYPE_PCEP, req);
+}
+
+struct req_entry *push_new_req(struct pcc_state *pcc_state, struct path *path)
+{
+ struct req_entry *req;
+
+ req = XCALLOC(MTYPE_PCEP, sizeof(*req));
+ req->retry_count = 0;
+ req->path = pcep_copy_path(path);
+ repush_req(pcc_state, req);
+
+ return req;
+}
+
+void repush_req(struct pcc_state *pcc_state, struct req_entry *req)
+{
+ uint32_t reqid = pcc_state->next_reqid;
+ void *res;
+
+ req->was_sent = false;
+ req->path->req_id = reqid;
+ res = RB_INSERT(req_entry_head, &pcc_state->requests, req);
+ assert(res == NULL);
+ assert(add_reqid_mapping(pcc_state, req->path) == true);
+
+ pcc_state->next_reqid += 1;
+ /* Wrapping is allowed, but 0 is not a valid id */
+ if (pcc_state->next_reqid == 0)
+ pcc_state->next_reqid = 1;
+}
+
+struct req_entry *pop_req(struct pcc_state *pcc_state, uint32_t reqid)
+{
+ struct path path = {.req_id = reqid};
+ struct req_entry key = {.path = &path};
+ struct req_entry *req;
+
+ req = RB_FIND(req_entry_head, &pcc_state->requests, &key);
+ if (req == NULL)
+ return NULL;
+ RB_REMOVE(req_entry_head, &pcc_state->requests, req);
+ remove_reqid_mapping(pcc_state, req->path);
+
+ return req;
+}
+
+struct req_entry *pop_req_no_reqid(struct pcc_state *pcc_state, uint32_t reqid)
+{
+ struct path path = {.req_id = reqid};
+ struct req_entry key = {.path = &path};
+ struct req_entry *req;
+
+ req = RB_FIND(req_entry_head, &pcc_state->requests, &key);
+ if (req == NULL)
+ return NULL;
+ RB_REMOVE(req_entry_head, &pcc_state->requests, req);
+
+ return req;
+}
+
+bool add_reqid_mapping(struct pcc_state *pcc_state, struct path *path)
+{
+ struct req_map_data *mapping;
+ mapping = XCALLOC(MTYPE_PCEP, sizeof(*mapping));
+ mapping->nbkey = path->nbkey;
+ mapping->reqid = path->req_id;
+ if (req_map_add(&pcc_state->req_map, mapping) != NULL) {
+ XFREE(MTYPE_PCEP, mapping);
+ return false;
+ }
+ return true;
+}
+
+void remove_reqid_mapping(struct pcc_state *pcc_state, struct path *path)
+{
+ struct req_map_data key, *mapping;
+ key.nbkey = path->nbkey;
+ mapping = req_map_find(&pcc_state->req_map, &key);
+ if (mapping != NULL) {
+ req_map_del(&pcc_state->req_map, mapping);
+ XFREE(MTYPE_PCEP, mapping);
+ }
+}
+
+uint32_t lookup_reqid(struct pcc_state *pcc_state, struct path *path)
+{
+ struct req_map_data key, *mapping;
+ key.nbkey = path->nbkey;
+ mapping = req_map_find(&pcc_state->req_map, &key);
+ if (mapping != NULL)
+ return mapping->reqid;
+ return 0;
+}
+
+bool has_pending_req_for(struct pcc_state *pcc_state, struct path *path)
+{
+ struct req_entry key = {.path = path};
+ struct req_entry *req;
+
+
+ PCEP_DEBUG_PATH("(%s) %s", format_path(path), __func__);
+ /* Looking for request without result */
+ if (path->no_path || !path->first_hop) {
+ PCEP_DEBUG_PATH("%s Path : no_path|!first_hop", __func__);
+ /* ...and already was handle */
+ req = RB_FIND(req_entry_head, &pcc_state->requests, &key);
+ if (!req) {
+ /* we must purge remaining reqid */
+ PCEP_DEBUG_PATH("%s Purge pending reqid: no_path(%s)",
+ __func__,
+ path->no_path ? "TRUE" : "FALSE");
+ if (lookup_reqid(pcc_state, path) != 0) {
+ PCEP_DEBUG_PATH("%s Purge pending reqid: DONE ",
+ __func__);
+ remove_reqid_mapping(pcc_state, path);
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+
+
+ return lookup_reqid(pcc_state, path) != 0;
+}
+
+
+/* ------------ Data Structure Callbacks ------------ */
+
+#define CMP_RETURN(A, B) \
+ if (A != B) \
+ return (A < B) ? -1 : 1
+
+static uint32_t hash_nbkey(const struct lsp_nb_key *nbkey)
+{
+ uint32_t hash;
+ hash = jhash_2words(nbkey->color, nbkey->preference, 0x55aa5a5a);
+ switch (nbkey->endpoint.ipa_type) {
+ case IPADDR_V4:
+ return jhash(&nbkey->endpoint.ipaddr_v4,
+ sizeof(nbkey->endpoint.ipaddr_v4), hash);
+ case IPADDR_V6:
+ return jhash(&nbkey->endpoint.ipaddr_v6,
+ sizeof(nbkey->endpoint.ipaddr_v6), hash);
+ default:
+ return hash;
+ }
+}
+
+static int cmp_nbkey(const struct lsp_nb_key *a, const struct lsp_nb_key *b)
+{
+ CMP_RETURN(a->color, b->color);
+ int cmp = ipaddr_cmp(&a->endpoint, &b->endpoint);
+ if (cmp != 0)
+ return cmp;
+ CMP_RETURN(a->preference, b->preference);
+ return 0;
+}
+
+int plspid_map_cmp(const struct plspid_map_data *a,
+ const struct plspid_map_data *b)
+{
+ return cmp_nbkey(&a->nbkey, &b->nbkey);
+}
+
+uint32_t plspid_map_hash(const struct plspid_map_data *e)
+{
+ return hash_nbkey(&e->nbkey);
+}
+
+int nbkey_map_cmp(const struct nbkey_map_data *a,
+ const struct nbkey_map_data *b)
+{
+ CMP_RETURN(a->plspid, b->plspid);
+ return 0;
+}
+
+uint32_t nbkey_map_hash(const struct nbkey_map_data *e)
+{
+ return e->plspid;
+}
+
+int req_map_cmp(const struct req_map_data *a, const struct req_map_data *b)
+{
+ return cmp_nbkey(&a->nbkey, &b->nbkey);
+}
+
+uint32_t req_map_hash(const struct req_map_data *e)
+{
+ return hash_nbkey(&e->nbkey);
+}
diff --git a/pathd/path_pcep_pcc.h b/pathd/path_pcep_pcc.h
new file mode 100644
index 0000000..9e712ba
--- /dev/null
+++ b/pathd/path_pcep_pcc.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _PATH_PCEP_PCC_H_
+#define _PATH_PCEP_PCC_H_
+
+#include "typesafe.h"
+#include "pathd/path_pcep.h"
+
+enum pcc_status {
+ PCEP_PCC_INITIALIZED = 0,
+ PCEP_PCC_DISCONNECTED,
+ PCEP_PCC_CONNECTING,
+ PCEP_PCC_SYNCHRONIZING,
+ PCEP_PCC_OPERATING
+};
+
+PREDECL_HASH(plspid_map);
+PREDECL_HASH(nbkey_map);
+PREDECL_HASH(req_map);
+
+struct plspid_map_data {
+ struct plspid_map_item mi;
+ struct lsp_nb_key nbkey;
+ uint32_t plspid;
+};
+
+struct nbkey_map_data {
+ struct nbkey_map_item mi;
+ struct lsp_nb_key nbkey;
+ uint32_t plspid;
+};
+
+struct req_map_data {
+ struct req_map_item mi;
+ struct lsp_nb_key nbkey;
+ uint32_t reqid;
+};
+
+struct req_entry {
+ RB_ENTRY(req_entry) entry;
+ struct thread *t_retry;
+ int retry_count;
+ bool was_sent;
+ struct path *path;
+};
+RB_HEAD(req_entry_head, req_entry);
+RB_PROTOTYPE(req_entry_head, req_entry, entry, req_entry_compare);
+
+struct pcc_state {
+ int id;
+ char tag[MAX_TAG_SIZE];
+ enum pcc_status status;
+ uint16_t flags;
+#define F_PCC_STATE_HAS_IPV4 0x0002
+#define F_PCC_STATE_HAS_IPV6 0x0004
+ struct pcc_opts *pcc_opts;
+ struct pce_opts *pce_opts;
+ struct in_addr pcc_addr_v4;
+ struct in6_addr pcc_addr_v6;
+ /* PCC transport source address */
+ struct ipaddr pcc_addr_tr;
+ char *originator;
+ pcep_session *sess;
+ uint32_t retry_count;
+ bool synchronized;
+ struct thread *t_reconnect;
+ struct thread *t_update_best;
+ struct thread *t_session_timeout;
+ uint32_t next_reqid;
+ uint32_t next_plspid;
+ struct plspid_map_head plspid_map;
+ struct nbkey_map_head nbkey_map;
+ struct req_map_head req_map;
+ struct req_entry_head requests;
+ struct pcep_caps caps;
+ bool is_best;
+ bool previous_best;
+};
+
+struct pcc_state *pcep_pcc_initialize(struct ctrl_state *ctrl_state,
+ int pcc_id);
+void pcep_pcc_finalize(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+int pcep_pcc_enable(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state);
+int pcep_pcc_disable(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+int pcep_pcc_update(struct ctrl_state *ctrl_state, struct pcc_state *pcc_state,
+ struct pcc_opts *pcc_opts, struct pce_opts *pce_opts);
+void pcep_pcc_reconnect(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+void pcep_pcc_pcep_event_handler(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ pcep_event *event);
+void pcep_pcc_pathd_event_handler(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ enum pcep_pathd_event_type type,
+ struct path *path);
+void pcep_pcc_timeout_handler(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state,
+ enum pcep_ctrl_timeout_type type, void *param);
+void pcep_pcc_sync_path(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct path *path);
+void pcep_pcc_sync_done(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state);
+/* Send a report explicitly. When doing so the PCC may send multiple reports
+ * due to expectations from vendors for the first report to be with a DOWN
+ * status. The parameter is_stable is used for that purpose as a hint wheter
+ * to expect an update for the report */
+void pcep_pcc_send_report(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct path *path,
+ bool is_stable);
+void pcep_pcc_send_error(struct ctrl_state *ctrl_state,
+ struct pcc_state *pcc_state, struct pcep_error *path,
+ bool is_stable);
+int pcep_pcc_multi_pce_sync_path(struct ctrl_state *ctrl_state, int pcc_id,
+ struct pcc_state **pcc_state_list);
+int pcep_pcc_multi_pce_remove_pcc(struct ctrl_state *ctrl_state,
+ struct pcc_state **pcc_state_list);
+int pcep_pcc_timer_update_best_pce(struct ctrl_state *ctrl_state, int pcc_id);
+int pcep_pcc_calculate_best_pce(struct pcc_state **pcc);
+int pcep_pcc_get_pcc_id_by_ip_port(struct pcc_state **pcc,
+ struct pce_opts *pce_opts);
+int pcep_pcc_get_pcc_id_by_idx(struct pcc_state **pcc, int idx);
+struct pcc_state *pcep_pcc_get_pcc_by_id(struct pcc_state **pcc, int id);
+struct pcc_state *pcep_pcc_get_pcc_by_name(struct pcc_state **pcc,
+ const char *pce_name);
+int pcep_pcc_get_pcc_idx_by_id(struct pcc_state **pcc, int id);
+int pcep_pcc_get_free_pcc_idx(struct pcc_state **pcc);
+int pcep_pcc_get_pcc_id(struct pcc_state *pcc);
+void pcep_pcc_copy_pcc_info(struct pcc_state **pcc,
+ struct pcep_pcc_info *pcc_info);
+
+#endif // _PATH_PCEP_PCC_H_
diff --git a/pathd/path_ted.c b/pathd/path_ted.c
new file mode 100644
index 0000000..316255a
--- /dev/null
+++ b/pathd/path_ted.c
@@ -0,0 +1,721 @@
+/*
+ * Copyright (C) 2020 Volta Networks, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <zebra.h>
+
+#include <stdlib.h>
+
+#include "memory.h"
+#include "log.h"
+#include "command.h"
+#include "prefix.h"
+#include <lib/json.h>
+
+#include "pathd.h"
+#include "pathd/path_errors.h"
+#include "pathd/path_ted.h"
+
+#ifndef VTYSH_EXTRACT_PL
+#include "pathd/path_ted_clippy.c"
+#endif
+
+static struct ls_ted *path_ted_create_ted(void);
+static void path_ted_register_vty(void);
+static void path_ted_unregister_vty(void);
+static uint32_t path_ted_start_importing_igp(const char *daemon_str);
+static uint32_t path_ted_stop_importing_igp(void);
+static enum zclient_send_status path_ted_link_state_sync(void);
+static void path_ted_timer_handler_sync(struct thread *thread);
+static void path_ted_timer_handler_refresh(struct thread *thread);
+static int path_ted_cli_debug_config_write(struct vty *vty);
+static int path_ted_cli_debug_set_all(uint32_t flags, bool set);
+
+extern struct zclient *zclient;
+
+struct ted_state ted_state_g = {};
+
+/*
+ * path_path_ted public API function implementations
+ */
+
+void path_ted_init(struct thread_master *master)
+{
+ ted_state_g.main = master;
+ ted_state_g.link_state_delay_interval = TIMER_RETRY_DELAY;
+ ted_state_g.segment_list_refresh_interval = TIMER_RETRY_DELAY;
+ path_ted_register_vty();
+ path_ted_segment_list_refresh();
+}
+
+uint32_t path_ted_teardown(void)
+{
+ PATH_TED_DEBUG("%s : TED [%p]", __func__, ted_state_g.ted);
+ path_ted_unregister_vty();
+ path_ted_stop_importing_igp();
+ ls_ted_del_all(&ted_state_g.ted);
+ path_ted_timer_sync_cancel();
+ path_ted_timer_refresh_cancel();
+ return 0;
+}
+
+/**
+ * Set all needed to receive igp data.
+ *
+ * @return true if ok
+ *
+ */
+uint32_t path_ted_start_importing_igp(const char *daemon_str)
+{
+ uint32_t status = 0;
+
+ if (strcmp(daemon_str, "ospfv2") == 0)
+ ted_state_g.import = IMPORT_OSPFv2;
+ else if (strcmp(daemon_str, "ospfv3") == 0) {
+ ted_state_g.import = IMPORT_UNKNOWN;
+ return 1;
+ } else if (strcmp(daemon_str, "isis") == 0)
+ ted_state_g.import = IMPORT_ISIS;
+ else {
+ ted_state_g.import = IMPORT_UNKNOWN;
+ return 1;
+ }
+
+ if (ls_register(zclient, false /*client*/) != 0) {
+ PATH_TED_ERROR("%s: PATHD-TED: Unable to register Link State",
+ __func__);
+ ted_state_g.import = IMPORT_UNKNOWN;
+ status = 1;
+ } else {
+ if (path_ted_link_state_sync() != -1) {
+ PATH_TED_DEBUG("%s: PATHD-TED: Importing %s data ON",
+ __func__,
+ PATH_TED_IGP_PRINT(ted_state_g.import));
+ } else {
+ PATH_TED_WARN("%s: PATHD-TED: Importing %s data OFF",
+ __func__,
+ PATH_TED_IGP_PRINT(ted_state_g.import));
+ ted_state_g.import = IMPORT_UNKNOWN;
+ }
+ }
+ return status;
+}
+
+/**
+ * Unset all needed to receive igp data.
+ *
+ * @return true if ok
+ *
+ */
+uint32_t path_ted_stop_importing_igp(void)
+{
+ uint32_t status = 0;
+
+ if (ted_state_g.import != IMPORT_UNKNOWN) {
+ if (ls_unregister(zclient, false /*client*/) != 0) {
+ PATH_TED_ERROR(
+ "%s: PATHD-TED: Unable to unregister Link State",
+ __func__);
+ status = 1;
+ } else {
+ ted_state_g.import = IMPORT_UNKNOWN;
+ PATH_TED_DEBUG("%s: PATHD-TED: Importing igp data OFF",
+ __func__);
+ }
+ path_ted_timer_sync_cancel();
+ }
+ return status;
+}
+/**
+ * Check for ted status
+ *
+ * @return true if ok
+ *
+ */
+bool path_ted_is_initialized(void)
+{
+ if (ted_state_g.ted == NULL) {
+ PATH_TED_WARN("PATHD TED ls_ted not initialized");
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * Creates an empty ted
+ *
+ * @param void
+ *
+ * @return Ptr to ted or NULL
+ */
+struct ls_ted *path_ted_create_ted()
+{
+ struct ls_ted *ted = ls_ted_new(TED_KEY, TED_NAME, TED_ASN);
+
+ if (ted == NULL) {
+ PATH_TED_ERROR("%s Unable to initialize TED Key [%d] ASN [%d] Name [%s]",
+ __func__, TED_KEY, TED_ASN, TED_NAME);
+ } else {
+ PATH_TED_INFO("%s Initialize TED Key [%d] ASN [%d] Name [%s]",
+ __func__, TED_KEY, TED_ASN, TED_NAME);
+ }
+
+ return ted;
+}
+
+uint32_t path_ted_rcvd_message(struct ls_message *msg)
+{
+ if (!path_ted_is_initialized())
+ return 1;
+
+ if (msg == NULL) {
+ PATH_TED_ERROR("%s: [rcv ted] TED received NULL message ",
+ __func__);
+ return 1;
+ }
+
+ if (path_ted_get_current_igp(msg->data.node->adv.origin))
+ return 1;
+
+ switch (msg->type) {
+ case LS_MSG_TYPE_NODE:
+ ls_msg2vertex(ted_state_g.ted, msg, true /*hard delete*/);
+ break;
+
+ case LS_MSG_TYPE_ATTRIBUTES:
+ ls_msg2edge(ted_state_g.ted, msg, true /*Ä¥ard delete*/);
+ break;
+
+ case LS_MSG_TYPE_PREFIX:
+ ls_msg2subnet(ted_state_g.ted, msg, true /*hard delete*/);
+ break;
+
+ default:
+ PATH_TED_DEBUG(
+ "%s: [rcv ted] TED received unknown message type [%d]",
+ __func__, msg->type);
+ break;
+ }
+ return 0;
+}
+
+uint32_t path_ted_query_type_f(struct ipaddr *local, struct ipaddr *remote)
+{
+ uint32_t sid = MPLS_LABEL_NONE;
+ struct ls_edge *edge;
+ uint64_t key;
+
+ if (!path_ted_is_initialized())
+ return MPLS_LABEL_NONE;
+
+ if (!local || !remote)
+ return MPLS_LABEL_NONE;
+
+ switch (local->ipa_type) {
+ case IPADDR_V4:
+ /* We have local and remote ip */
+ /* so check all attributes in ted */
+ key = ((uint64_t)ntohl(local->ip._v4_addr.s_addr)) & 0xffffffff;
+ edge = ls_find_edge_by_key(ted_state_g.ted, key);
+ if (edge) {
+ if (edge->attributes->standard.remote.s_addr
+ == remote->ip._v4_addr.s_addr
+ && CHECK_FLAG(edge->attributes->flags,
+ LS_ATTR_ADJ_SID)) {
+ sid = edge->attributes->adj_sid[0]
+ .sid; /* from primary */
+ break;
+ }
+ }
+ break;
+ case IPADDR_V6:
+ key = (uint64_t)ntohl(local->ip._v6_addr.s6_addr32[2]) << 32 |
+ (uint64_t)ntohl(local->ip._v6_addr.s6_addr32[3]);
+ edge = ls_find_edge_by_key(ted_state_g.ted, key);
+ if (edge) {
+ if ((0 == memcmp(&edge->attributes->standard.remote6,
+ &remote->ip._v6_addr,
+ sizeof(remote->ip._v6_addr)) &&
+ CHECK_FLAG(edge->attributes->flags,
+ LS_ATTR_ADJ_SID6))) {
+ sid = edge->attributes->adj_sid[ADJ_PRI_IPV6]
+ .sid; /* from primary */
+ break;
+ }
+ }
+ break;
+ case IPADDR_NONE:
+ break;
+ }
+
+ return sid;
+}
+
+uint32_t path_ted_query_type_c(struct prefix *prefix, uint8_t algo)
+{
+ uint32_t sid = MPLS_LABEL_NONE;
+ struct ls_subnet *subnet;
+
+ if (!path_ted_is_initialized())
+ return MPLS_LABEL_NONE;
+
+ if (!prefix)
+ return MPLS_LABEL_NONE;
+
+ switch (prefix->family) {
+ case AF_INET:
+ case AF_INET6:
+ subnet = ls_find_subnet(ted_state_g.ted, *prefix);
+ if (subnet) {
+ if ((CHECK_FLAG(subnet->ls_pref->flags, LS_PREF_SR))
+ && (subnet->ls_pref->sr.algo == algo))
+ sid = subnet->ls_pref->sr.sid;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return sid;
+}
+
+uint32_t path_ted_query_type_e(struct prefix *prefix, uint32_t iface_id)
+{
+ uint32_t sid = MPLS_LABEL_NONE;
+ struct ls_subnet *subnet;
+ struct listnode *lst_node;
+ struct ls_edge *edge;
+
+ if (!path_ted_is_initialized())
+ return MPLS_LABEL_NONE;
+
+ if (!prefix)
+ return MPLS_LABEL_NONE;
+
+ switch (prefix->family) {
+ case AF_INET:
+ case AF_INET6:
+ subnet = ls_find_subnet(ted_state_g.ted, *prefix);
+ if (subnet && subnet->vertex
+ && subnet->vertex->outgoing_edges) {
+ /* from the vertex linked in subnet */
+ /* loop over outgoing edges */
+ for (ALL_LIST_ELEMENTS_RO(
+ subnet->vertex->outgoing_edges, lst_node,
+ edge)) {
+ /* and look for ifaceid */
+ /* so get sid of attribute */
+ if (CHECK_FLAG(edge->attributes->flags,
+ LS_ATTR_LOCAL_ID)
+ && edge->attributes->standard.local_id
+ == iface_id) {
+ sid = subnet->ls_pref->sr.sid;
+ break;
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ return sid;
+}
+
+DEFPY (debug_path_ted,
+ debug_path_ted_cmd,
+ "[no] debug pathd mpls-te",
+ NO_STR
+ DEBUG_STR
+ "path debugging\n"
+ "ted debugging\n")
+{
+ uint32_t mode = DEBUG_NODE2MODE(vty->node);
+ bool no_debug = (no != NULL);
+
+ DEBUG_MODE_SET(&ted_state_g.dbg, mode, !no);
+ DEBUG_FLAGS_SET(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC, !no_debug);
+ return CMD_SUCCESS;
+}
+
+/*
+ * Following are vty command functions.
+ */
+/* clang-format off */
+DEFUN (path_ted_on,
+ path_ted_on_cmd,
+ "mpls-te on",
+ NO_STR
+ "Enable the TE database (TED) functionality\n")
+/* clang-format on */
+{
+
+ if (ted_state_g.enabled) {
+ PATH_TED_DEBUG("%s: PATHD-TED: Enabled ON -> ON.", __func__);
+ return CMD_SUCCESS;
+ }
+
+ ted_state_g.ted = path_ted_create_ted();
+ ted_state_g.enabled = true;
+ PATH_TED_DEBUG("%s: PATHD-TED: Enabled OFF -> ON.", __func__);
+
+ return CMD_SUCCESS;
+}
+
+/* clang-format off */
+DEFUN (no_path_ted,
+ no_path_ted_cmd,
+ "no mpls-te [on]",
+ NO_STR
+ NO_STR
+ "Disable the TE Database functionality\n")
+/* clang-format on */
+{
+ if (!ted_state_g.enabled) {
+ PATH_TED_DEBUG("%s: PATHD-TED: OFF -> OFF", __func__);
+ return CMD_SUCCESS;
+ }
+
+ /* Remove TED */
+ ls_ted_del_all(&ted_state_g.ted);
+ ted_state_g.enabled = false;
+ PATH_TED_DEBUG("%s: PATHD-TED: ON -> OFF", __func__);
+ ted_state_g.import = IMPORT_UNKNOWN;
+ if (ls_unregister(zclient, false /*client*/) != 0) {
+ vty_out(vty, "Unable to unregister Link State\n");
+ return CMD_WARNING;
+ }
+
+ return CMD_SUCCESS;
+}
+
+/* clang-format off */
+DEFPY(path_ted_import,
+ path_ted_import_cmd,
+ "mpls-te import <ospfv2|ospfv3|isis>$import_daemon",
+ "Enable the TE database (TED) fill with remote igp data\n"
+ "import\n"
+ "Origin ospfv2\n"
+ "Origin ospfv3\n"
+ "Origin isis\n")
+/* clang-format on */
+{
+
+ if (ted_state_g.enabled)
+ if (path_ted_start_importing_igp(import_daemon)) {
+ vty_out(vty, "Unable to start importing\n");
+ return CMD_WARNING;
+ }
+ return CMD_SUCCESS;
+}
+
+/* clang-format off */
+DEFUN (no_path_ted_import,
+ no_path_ted_import_cmd,
+ "no mpls-te import",
+ NO_STR
+ NO_STR
+ "Disable the TE Database fill with remote igp data\n")
+/* clang-format on */
+{
+
+ if (ted_state_g.import) {
+ if (path_ted_stop_importing_igp()) {
+ vty_out(vty, "Unable to stop importing\n");
+ return CMD_WARNING;
+ } else {
+ PATH_TED_DEBUG(
+ "%s: PATHD-TED: Importing igp data already OFF",
+ __func__);
+ }
+ }
+ return CMD_SUCCESS;
+}
+
+/* clang-format off */
+DEFPY (show_pathd_ted_db,
+ show_pathd_ted_db_cmd,
+ "show pathd ted database <verbose|json>$ver_json ",
+ "show command\n"
+ "pathd daemon\n"
+ "traffic eng\n"
+ "database\n"
+ "verbose output\n"
+ "Show complete received TED database\n")
+/* clang-format on */
+{
+ bool st_json = false;
+ json_object *json = NULL;
+
+ if (!ted_state_g.enabled) {
+ vty_out(vty, "Traffic Engineering database is not enabled\n");
+ return CMD_WARNING;
+ }
+ if (strcmp(ver_json, "json") == 0) {
+ st_json = true;
+ json = json_object_new_object();
+ }
+ /* Show the complete TED */
+ ls_show_ted(ted_state_g.ted, vty, json, !st_json);
+ if (st_json)
+ vty_json(vty, json);
+ return CMD_SUCCESS;
+}
+
+/*
+ * Config Write functions
+ */
+
+int path_ted_cli_debug_config_write(struct vty *vty)
+{
+ if (DEBUG_MODE_CHECK(&ted_state_g.dbg, DEBUG_MODE_CONF)) {
+ if (DEBUG_FLAGS_CHECK(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC))
+ vty_out(vty, "debug pathd mpls-te\n");
+ return 1;
+ }
+ return 0;
+}
+
+int path_ted_cli_debug_set_all(uint32_t flags, bool set)
+{
+ DEBUG_FLAGS_SET(&ted_state_g.dbg, flags, set);
+
+ /* If all modes have been turned off, don't preserve options. */
+ if (!DEBUG_MODE_CHECK(&ted_state_g.dbg, DEBUG_MODE_ALL))
+ DEBUG_CLEAR(&ted_state_g.dbg);
+
+ return 0;
+}
+
+/**
+ * Help fn to show ted related configuration
+ *
+ * @param vty
+ *
+ * @return Status
+ */
+uint32_t path_ted_config_write(struct vty *vty)
+{
+
+ if (ted_state_g.enabled) {
+ vty_out(vty, " mpls-te on\n");
+ switch (ted_state_g.import) {
+ case IMPORT_ISIS:
+ vty_out(vty, " mpls-te import isis\n");
+ break;
+ case IMPORT_OSPFv2:
+ vty_out(vty, " mpls-te import ospfv2\n");
+ break;
+ case IMPORT_OSPFv3:
+ vty_out(vty, " mpls-te import ospfv3\n");
+ break;
+ default:
+ break;
+ }
+ }
+ return 0;
+}
+
+/**
+ * Register the fn's for CLI and hook for config show
+ *
+ * @param void
+ *
+ */
+static void path_ted_register_vty(void)
+{
+ install_element(VIEW_NODE, &show_pathd_ted_db_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &path_ted_on_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &no_path_ted_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &path_ted_import_cmd);
+ install_element(SR_TRAFFIC_ENG_NODE, &no_path_ted_import_cmd);
+
+ install_element(CONFIG_NODE, &debug_path_ted_cmd);
+ install_element(ENABLE_NODE, &debug_path_ted_cmd);
+
+ hook_register(nb_client_debug_config_write,
+ path_ted_cli_debug_config_write);
+ hook_register(nb_client_debug_set_all, path_ted_cli_debug_set_all);
+}
+
+/**
+ * UnRegister the fn's for CLI and hook for config show
+ *
+ * @param void
+ *
+ */
+static void path_ted_unregister_vty(void)
+{
+ uninstall_element(VIEW_NODE, &show_pathd_ted_db_cmd);
+ uninstall_element(SR_TRAFFIC_ENG_NODE, &path_ted_on_cmd);
+ uninstall_element(SR_TRAFFIC_ENG_NODE, &no_path_ted_cmd);
+ uninstall_element(SR_TRAFFIC_ENG_NODE, &path_ted_import_cmd);
+ uninstall_element(SR_TRAFFIC_ENG_NODE, &no_path_ted_import_cmd);
+}
+
+/**
+ * Ask igp for a complete TED so far
+ *
+ * @param void
+ *
+ * @return zclient status
+ */
+enum zclient_send_status path_ted_link_state_sync(void)
+{
+ enum zclient_send_status status;
+
+ status = ls_request_sync(zclient);
+ if (status == -1) {
+ PATH_TED_ERROR(
+ "%s: PATHD-TED: Opaque error asking for TED sync ",
+ __func__);
+ return status;
+ } else {
+ PATH_TED_DEBUG("%s: PATHD-TED: Opaque asked for TED sync ",
+ __func__);
+ }
+ thread_add_timer(ted_state_g.main, path_ted_timer_handler_sync,
+ &ted_state_g, ted_state_g.link_state_delay_interval,
+ &ted_state_g.t_link_state_sync);
+
+ return status;
+}
+
+/**
+ * Timer cb for check link state sync
+ *
+ * @param thread Current thread
+ *
+ * @return status
+ */
+void path_ted_timer_handler_sync(struct thread *thread)
+{
+ /* data unpacking */
+ struct ted_state *data = THREAD_ARG(thread);
+
+ assert(data != NULL);
+ /* Retry the sync */
+ path_ted_link_state_sync();
+}
+
+/**
+ * refresg segment list and create timer to keep up updated
+ *
+ * @param void
+ *
+ * @return status
+ */
+int path_ted_segment_list_refresh(void)
+{
+ int status = 0;
+
+ path_ted_timer_refresh_cancel();
+ thread_add_timer(ted_state_g.main, path_ted_timer_handler_refresh,
+ &ted_state_g,
+ ted_state_g.segment_list_refresh_interval,
+ &ted_state_g.t_segment_list_refresh);
+
+ return status;
+}
+
+/**
+ * Timer cb for refreshing sid in segment lists
+ *
+ * @param void
+ *
+ * @return status
+ */
+void path_ted_timer_handler_refresh(struct thread *thread)
+{
+ if (!path_ted_is_initialized())
+ return;
+
+ PATH_TED_DEBUG("%s: PATHD-TED: Refresh sid from current TED", __func__);
+ /* data unpacking */
+ struct ted_state *data = THREAD_ARG(thread);
+
+ assert(data != NULL);
+
+ srte_policy_update_ted_sid();
+}
+
+/**
+ * Cancel sync timer
+ *
+ * @param void
+ *
+ * @return void status
+ */
+void path_ted_timer_sync_cancel(void)
+{
+ if (ted_state_g.t_link_state_sync != NULL) {
+ thread_cancel(&ted_state_g.t_link_state_sync);
+ ted_state_g.t_link_state_sync = NULL;
+ }
+}
+
+/**
+ * Cancel refresh timer
+ *
+ * @param void
+ *
+ * @return void status
+ */
+void path_ted_timer_refresh_cancel(void)
+{
+ if (ted_state_g.t_segment_list_refresh != NULL) {
+ thread_cancel(&ted_state_g.t_segment_list_refresh);
+ ted_state_g.t_segment_list_refresh = NULL;
+ }
+}
+
+/**
+ * Check which igp is configured
+ *
+ * @param igp who want to check against config-
+ *
+ * @return status
+ */
+uint32_t path_ted_get_current_igp(uint32_t igp)
+{
+ switch (igp) {
+ case ISIS_L1:
+ case ISIS_L2:
+ if (ted_state_g.import != IMPORT_ISIS) {
+ PATH_TED_ERROR(
+ "%s: [rcv ted] Incorrect igp origin wait (%s) got (%s) ",
+ __func__,
+ PATH_TED_IGP_PRINT(ted_state_g.import),
+ LS_IGP_PRINT(igp));
+ return 1;
+ }
+ break;
+ case OSPFv2:
+ if (ted_state_g.import != IMPORT_OSPFv2) {
+ PATH_TED_ERROR(
+ "%s: [rcv ted] Incorrect igp origin wait (%s) got (%s) ",
+ __func__,
+ PATH_TED_IGP_PRINT(ted_state_g.import),
+ LS_IGP_PRINT(igp));
+ return 1;
+ }
+ break;
+ case STATIC:
+ break;
+ }
+ return 0;
+}
diff --git a/pathd/path_ted.h b/pathd/path_ted.h
new file mode 100644
index 0000000..c6897b1
--- /dev/null
+++ b/pathd/path_ted.h
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2020 Volta Networks, Inc
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _PATH_TED_H
+#define _PATH_TED_H
+
+#ifdef __cplusplus
+
+extern "C" {
+#endif
+
+#include <zebra.h>
+
+#include <stdbool.h>
+
+#include <debug.h>
+#include "linklist.h"
+#include "log.h"
+#include "command.h"
+#include "stream.h"
+#include "prefix.h"
+#include "zclient.h"
+#include "link_state.h"
+
+extern struct ted_state ted_state_g;
+#define TIMER_RETRY_DELAY 5 /* Timeout in seconds between ls sync request */
+#define TED_KEY 1
+#define TED_ASN 1
+#define TED_NAME "PATHD TED"
+
+enum igp_import {
+ IMPORT_UNKNOWN = 0,
+ IMPORT_ISIS,
+ IMPORT_OSPFv2,
+ IMPORT_OSPFv3
+};
+struct ted_state {
+ struct thread_master *main;
+ /* Status of TED: enable or disable */
+ bool enabled;
+ /* From which igp is going to receive data */
+ enum igp_import import;
+ /* The TED itself as in link_state.h */
+ struct ls_ted *ted;
+ /* Timer for ted sync */
+ struct thread *t_link_state_sync;
+ /* Timer for refresh sid in segment list */
+ struct thread *t_segment_list_refresh;
+ /* delay interval in seconds */
+ uint32_t link_state_delay_interval;
+ /* delay interval refresh in seconds */
+ uint32_t segment_list_refresh_interval;
+ struct debug dbg;
+};
+/* Debug flags. */
+#define PATH_TED_DEBUG_BASIC 0x01
+#define PATH_TED_DEBUG(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC)) \
+ DEBUGD(&ted_state_g.dbg, "mpls-te: " fmt, ##__VA_ARGS__); \
+ } while (0)
+
+#define PATH_TED_ERROR(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC)) \
+ DEBUGE(&ted_state_g.dbg, "mpls-te: " fmt, ##__VA_ARGS__); \
+ } while (0)
+#define PATH_TED_WARN(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC)) \
+ DEBUGW(&ted_state_g.dbg, "mpls-te: " fmt, ##__VA_ARGS__); \
+ } while (0)
+#define PATH_TED_INFO(fmt, ...) \
+ do { \
+ if (DEBUG_FLAGS_CHECK(&ted_state_g.dbg, PATH_TED_DEBUG_BASIC)) \
+ DEBUGI(&ted_state_g.dbg, "mpls-te: " fmt, ##__VA_ARGS__); \
+ } while (0)
+
+/* TED management functions */
+bool path_ted_is_initialized(void);
+void path_ted_init(struct thread_master *master);
+uint32_t path_ted_teardown(void);
+void path_ted_timer_sync_cancel(void);
+void path_ted_timer_refresh_cancel(void);
+int path_ted_segment_list_refresh(void);
+
+/* TED configuration functions */
+uint32_t path_ted_config_write(struct vty *vty);
+
+/* TED util functions */
+/* clang-format off */
+#define LS_MSG_EVENT_PRINT(event) event == LS_MSG_EVENT_ADD?"add"\
+ : event == LS_MSG_EVENT_DELETE?"del"\
+ : event == LS_MSG_EVENT_UPDATE?"upd"\
+ : event == LS_MSG_EVENT_SYNC?"syn"\
+ : event == LS_MSG_EVENT_SYNC?"und" : "none"
+#define LS_MSG_TYPE_PRINT(type) type == LS_MSG_TYPE_NODE?"node"\
+ : type == LS_MSG_TYPE_ATTRIBUTES?"att"\
+ : type == LS_MSG_TYPE_PREFIX?"pre" : "none"
+#define LS_IGP_PRINT(type) type == ISIS_L1?"ISIS_L1"\
+ : type == ISIS_L2?"ISIS_L2"\
+ : type == DIRECT?"DIRECT"\
+ : type == STATIC?"STATIC"\
+ : type == OSPFv2?"OSPFv2" : "none"
+#define PATH_TED_IGP_PRINT(type) type == IMPORT_OSPFv2?"OSPFv2"\
+ : type == IMPORT_OSPFv3?"OSPFv3"\
+ : type == IMPORT_ISIS?"ISIS" : "none"
+/* clang-format on */
+
+
+uint32_t path_ted_get_current_igp(uint32_t);
+/* TED Query functions */
+
+/*
+ * Type of queries from draft-ietf-spring-segment-routing-policy-07 for types
+ * f,c,e
+ */
+
+/**
+ * Search for sid based in prefix and optional algo
+ *
+ * @param prefix Net prefix to resolv
+ * @param algo Algorithm for link state
+ *
+ * @return sid of attribute
+ */
+uint32_t path_ted_query_type_c(struct prefix *prefix, uint8_t algo);
+
+/**
+ * Search for sid based in prefix and interface id
+ *
+ * @param prefix Net prefix to resolv
+ * @param iface_id The interface id
+ *
+ * @return sid of attribute
+ */
+uint32_t path_ted_query_type_e(struct prefix *prefix, uint32_t iface_id);
+
+/**
+ * Search for sid based in local, remote pair
+ *
+ * @param local local ip of attribute
+ * @param remote remote ip of attribute
+ *
+ * @return sid of attribute
+ */
+uint32_t path_ted_query_type_f(struct ipaddr *local, struct ipaddr *remote);
+
+
+/**
+ * Handle the received opaque msg
+ *
+ * @param msg Holds the ted data
+ *
+ * @return sid of attribute
+ */
+uint32_t path_ted_rcvd_message(struct ls_message *msg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _PATH_TED_H */
diff --git a/pathd/path_zebra.c b/pathd/path_zebra.c
new file mode 100644
index 0000000..a98532c
--- /dev/null
+++ b/pathd/path_zebra.c
@@ -0,0 +1,360 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "thread.h"
+#include "log.h"
+#include "lib_errors.h"
+#include "if.h"
+#include "prefix.h"
+#include "zclient.h"
+#include "network.h"
+#include "stream.h"
+#include "linklist.h"
+#include "nexthop.h"
+#include "vrf.h"
+#include "typesafe.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_ted.h"
+#include "pathd/path_zebra.h"
+#include "lib/command.h"
+#include "lib/link_state.h"
+
+static int path_zebra_opaque_msg_handler(ZAPI_CALLBACK_ARGS);
+
+struct zclient *zclient;
+static struct zclient *zclient_sync;
+
+/* Global Variables */
+bool g_has_router_id_v4 = false;
+bool g_has_router_id_v6 = false;
+struct in_addr g_router_id_v4;
+struct in6_addr g_router_id_v6;
+pthread_mutex_t g_router_id_v4_mtx = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t g_router_id_v6_mtx = PTHREAD_MUTEX_INITIALIZER;
+
+/**
+ * Gives the IPv4 router ID received from Zebra.
+ *
+ * @param router_id The in_addr strucure where to store the router id
+ * @return true if the router ID was available, false otherwise
+ */
+bool get_ipv4_router_id(struct in_addr *router_id)
+{
+ bool retval = false;
+ assert(router_id != NULL);
+ pthread_mutex_lock(&g_router_id_v4_mtx);
+ if (g_has_router_id_v4) {
+ memcpy(router_id, &g_router_id_v4, sizeof(*router_id));
+ retval = true;
+ }
+ pthread_mutex_unlock(&g_router_id_v4_mtx);
+ return retval;
+}
+
+/**
+ * Gives the IPv6 router ID received from Zebra.
+ *
+ * @param router_id The in6_addr strucure where to store the router id
+ * @return true if the router ID was available, false otherwise
+ */
+bool get_ipv6_router_id(struct in6_addr *router_id)
+{
+ bool retval = false;
+ assert(router_id != NULL);
+ pthread_mutex_lock(&g_router_id_v6_mtx);
+ if (g_has_router_id_v6) {
+ memcpy(router_id, &g_router_id_v6, sizeof(*router_id));
+ retval = true;
+ }
+ pthread_mutex_unlock(&g_router_id_v6_mtx);
+ return retval;
+}
+
+static void path_zebra_connected(struct zclient *zclient)
+{
+ struct srte_policy *policy;
+
+ zclient_send_reg_requests(zclient, VRF_DEFAULT);
+ zclient_send_router_id_update(zclient, ZEBRA_ROUTER_ID_ADD, AFI_IP6,
+ VRF_DEFAULT);
+
+ RB_FOREACH (policy, srte_policy_head, &srte_policies) {
+ struct srte_candidate *candidate;
+ struct srte_segment_list *segment_list;
+
+ candidate = policy->best_candidate;
+ if (!candidate)
+ continue;
+
+ segment_list = candidate->lsp->segment_list;
+ if (!segment_list)
+ continue;
+
+ path_zebra_add_sr_policy(policy, segment_list);
+ }
+}
+
+static int path_zebra_sr_policy_notify_status(ZAPI_CALLBACK_ARGS)
+{
+ struct zapi_sr_policy zapi_sr_policy;
+ struct srte_policy *policy;
+ struct srte_candidate *best_candidate_path;
+
+ if (zapi_sr_policy_notify_status_decode(zclient->ibuf, &zapi_sr_policy))
+ return -1;
+
+ policy = srte_policy_find(zapi_sr_policy.color,
+ &zapi_sr_policy.endpoint);
+ if (!policy)
+ return -1;
+
+ best_candidate_path = policy->best_candidate;
+ if (!best_candidate_path)
+ return -1;
+
+ srte_candidate_status_update(best_candidate_path,
+ zapi_sr_policy.status);
+
+ return 0;
+}
+
+/* Router-id update message from zebra. */
+static int path_zebra_router_id_update(ZAPI_CALLBACK_ARGS)
+{
+ struct prefix pref;
+ const char *family;
+ char buf[PREFIX2STR_BUFFER];
+ zebra_router_id_update_read(zclient->ibuf, &pref);
+ if (pref.family == AF_INET) {
+ pthread_mutex_lock(&g_router_id_v4_mtx);
+ memcpy(&g_router_id_v4, &pref.u.prefix4,
+ sizeof(g_router_id_v4));
+ g_has_router_id_v4 = true;
+ inet_ntop(AF_INET, &g_router_id_v4, buf, sizeof(buf));
+ pthread_mutex_unlock(&g_router_id_v4_mtx);
+ family = "IPv4";
+ } else if (pref.family == AF_INET6) {
+ pthread_mutex_lock(&g_router_id_v6_mtx);
+ memcpy(&g_router_id_v6, &pref.u.prefix6,
+ sizeof(g_router_id_v6));
+ g_has_router_id_v6 = true;
+ inet_ntop(AF_INET6, &g_router_id_v6, buf, sizeof(buf));
+ pthread_mutex_unlock(&g_router_id_v6_mtx);
+ family = "IPv6";
+ } else {
+ zlog_warn("Unexpected router ID address family for vrf %u: %u",
+ vrf_id, pref.family);
+ return 0;
+ }
+ zlog_info("%s Router Id updated for VRF %u: %s", family, vrf_id, buf);
+ return 0;
+}
+
+/**
+ * Adds a segment routing policy to Zebra.
+ *
+ * @param policy The policy to add
+ * @param segment_list The segment list for the policy
+ */
+void path_zebra_add_sr_policy(struct srte_policy *policy,
+ struct srte_segment_list *segment_list)
+{
+ struct zapi_sr_policy zp = {};
+ struct srte_segment_entry *segment;
+
+ zp.color = policy->color;
+ zp.endpoint = policy->endpoint;
+ strlcpy(zp.name, policy->name, sizeof(zp.name));
+ zp.segment_list.type = ZEBRA_LSP_SRTE;
+ zp.segment_list.local_label = policy->binding_sid;
+ zp.segment_list.label_num = 0;
+ RB_FOREACH (segment, srte_segment_entry_head, &segment_list->segments)
+ zp.segment_list.labels[zp.segment_list.label_num++] =
+ segment->sid_value;
+ policy->status = SRTE_POLICY_STATUS_GOING_UP;
+
+ (void)zebra_send_sr_policy(zclient, ZEBRA_SR_POLICY_SET, &zp);
+}
+
+/**
+ * Deletes a segment policy from Zebra.
+ *
+ * @param policy The policy to remove
+ */
+void path_zebra_delete_sr_policy(struct srte_policy *policy)
+{
+ struct zapi_sr_policy zp = {};
+
+ zp.color = policy->color;
+ zp.endpoint = policy->endpoint;
+ strlcpy(zp.name, policy->name, sizeof(zp.name));
+ zp.segment_list.type = ZEBRA_LSP_SRTE;
+ zp.segment_list.local_label = policy->binding_sid;
+ zp.segment_list.label_num = 0;
+ policy->status = SRTE_POLICY_STATUS_DOWN;
+
+ (void)zebra_send_sr_policy(zclient, ZEBRA_SR_POLICY_DELETE, &zp);
+}
+
+/**
+ * Allocates a label from Zebra's label manager.
+ *
+ * @param label the label to be allocated
+ * @return 0 if the label has been allocated, -1 otherwise
+ */
+int path_zebra_request_label(mpls_label_t label)
+{
+ int ret;
+ uint32_t start, end;
+
+ ret = lm_get_label_chunk(zclient_sync, 0, label, 1, &start, &end);
+ if (ret < 0) {
+ zlog_warn("%s: error getting label range!", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
+ * Releases a previously allocated label from Zebra's label manager.
+ *
+ * @param label The label to release
+ * @return 0 ifthe label has beel released, -1 otherwise
+ */
+void path_zebra_release_label(mpls_label_t label)
+{
+ int ret;
+
+ ret = lm_release_label_chunk(zclient_sync, label, label);
+ if (ret < 0)
+ zlog_warn("%s: error releasing label range!", __func__);
+}
+
+static void path_zebra_label_manager_connect(void)
+{
+ /* Connect to label manager. */
+ while (zclient_socket_connect(zclient_sync) < 0) {
+ zlog_warn("%s: error connecting synchronous zclient!",
+ __func__);
+ sleep(1);
+ }
+ set_nonblocking(zclient_sync->sock);
+
+ /* Send hello to notify zebra this is a synchronous client */
+ while (zclient_send_hello(zclient_sync) < 0) {
+ zlog_warn("%s: Error sending hello for synchronous zclient!",
+ __func__);
+ sleep(1);
+ }
+
+ while (lm_label_manager_connect(zclient_sync, 0) != 0) {
+ zlog_warn("%s: error connecting to label manager!", __func__);
+ sleep(1);
+ }
+}
+
+static int path_zebra_opaque_msg_handler(ZAPI_CALLBACK_ARGS)
+{
+ int ret = 0;
+ struct stream *s;
+ struct zapi_opaque_msg info;
+
+ s = zclient->ibuf;
+
+ if (zclient_opaque_decode(s, &info) != 0)
+ return -1;
+
+ switch (info.type) {
+ case LINK_STATE_UPDATE:
+ case LINK_STATE_SYNC:
+ /* Start receiving ls data so cancel request sync timer */
+ path_ted_timer_sync_cancel();
+
+ struct ls_message *msg = ls_parse_msg(s);
+
+ if (msg) {
+ zlog_debug("%s: [rcv ted] ls (%s) msg (%s)-(%s) !",
+ __func__,
+ info.type == LINK_STATE_UPDATE
+ ? "LINK_STATE_UPDATE"
+ : "LINK_STATE_SYNC",
+ LS_MSG_TYPE_PRINT(msg->type),
+ LS_MSG_EVENT_PRINT(msg->event));
+ } else {
+ zlog_err(
+ "%s: [rcv ted] Could not parse LinkState stream message.",
+ __func__);
+ return -1;
+ }
+
+ ret = path_ted_rcvd_message(msg);
+ ls_delete_msg(msg);
+ /* Update local configuration after process update. */
+ path_ted_segment_list_refresh();
+ break;
+ default:
+ zlog_debug("%s: [rcv ted] unknown opaque event (%d) !",
+ __func__, info.type);
+ break;
+ }
+
+ return ret;
+}
+
+static zclient_handler *const path_handlers[] = {
+ [ZEBRA_SR_POLICY_NOTIFY_STATUS] = path_zebra_sr_policy_notify_status,
+ [ZEBRA_ROUTER_ID_UPDATE] = path_zebra_router_id_update,
+ [ZEBRA_OPAQUE_MESSAGE] = path_zebra_opaque_msg_handler,
+};
+
+/**
+ * Initializes Zebra asynchronous connection.
+ *
+ * @param master The master thread
+ */
+void path_zebra_init(struct thread_master *master)
+{
+ struct zclient_options options = zclient_options_default;
+ options.synchronous = true;
+
+ /* Initialize asynchronous zclient. */
+ zclient = zclient_new(master, &zclient_options_default, path_handlers,
+ array_size(path_handlers));
+ zclient_init(zclient, ZEBRA_ROUTE_SRTE, 0, &pathd_privs);
+ zclient->zebra_connected = path_zebra_connected;
+
+ /* Initialize special zclient for synchronous message exchanges. */
+ zclient_sync = zclient_new(master, &options, NULL, 0);
+ zclient_sync->sock = -1;
+ zclient_sync->redist_default = ZEBRA_ROUTE_SRTE;
+ zclient_sync->instance = 1;
+ zclient_sync->privs = &pathd_privs;
+
+ /* Connect to the LM. */
+ path_zebra_label_manager_connect();
+}
+
+void path_zebra_stop(void)
+{
+ zclient_stop(zclient);
+ zclient_free(zclient);
+}
diff --git a/pathd/path_zebra.h b/pathd/path_zebra.h
new file mode 100644
index 0000000..683fcf1
--- /dev/null
+++ b/pathd/path_zebra.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _FRR_PATH_MPLS_H_
+#define _FRR_PATH_MPLS_H_
+
+#include <zebra.h>
+#include "pathd/pathd.h"
+
+bool get_ipv4_router_id(struct in_addr *router_id);
+bool get_ipv6_router_id(struct in6_addr *router_id);
+void path_zebra_add_sr_policy(struct srte_policy *policy,
+ struct srte_segment_list *segment_list);
+void path_zebra_delete_sr_policy(struct srte_policy *policy);
+int path_zebra_request_label(mpls_label_t label);
+void path_zebra_release_label(mpls_label_t label);
+void path_zebra_init(struct thread_master *master);
+void path_zebra_stop(void);
+
+#endif /* _FRR_PATH_MPLS_H_ */
diff --git a/pathd/pathd.c b/pathd/pathd.c
new file mode 100644
index 0000000..e9d7cc6
--- /dev/null
+++ b/pathd/pathd.c
@@ -0,0 +1,1419 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "memory.h"
+#include "log.h"
+#include "lib_errors.h"
+#include "network.h"
+#include "libfrr.h"
+
+#include "pathd/pathd.h"
+#include "pathd/path_zebra.h"
+#include "pathd/path_debug.h"
+#include "pathd/path_ted.h"
+
+#define HOOK_DELAY 3
+
+DEFINE_MGROUP(PATHD, "pathd");
+
+DEFINE_MTYPE_STATIC(PATHD, PATH_SEGMENT_LIST, "Segment List");
+DEFINE_MTYPE_STATIC(PATHD, PATH_SR_POLICY, "SR Policy");
+DEFINE_MTYPE_STATIC(PATHD, PATH_SR_CANDIDATE, "SR Policy candidate path");
+
+DEFINE_HOOK(pathd_candidate_created, (struct srte_candidate * candidate),
+ (candidate));
+DEFINE_HOOK(pathd_candidate_updated, (struct srte_candidate * candidate),
+ (candidate));
+DEFINE_HOOK(pathd_candidate_removed, (struct srte_candidate * candidate),
+ (candidate));
+
+static void trigger_pathd_candidate_created(struct srte_candidate *candidate);
+static void trigger_pathd_candidate_created_timer(struct thread *thread);
+static void trigger_pathd_candidate_updated(struct srte_candidate *candidate);
+static void trigger_pathd_candidate_updated_timer(struct thread *thread);
+static void trigger_pathd_candidate_removed(struct srte_candidate *candidate);
+static const char *
+srte_candidate_metric_name(enum srte_candidate_metric_type type);
+
+static void srte_set_metric(struct srte_metric *metric, float value,
+ bool required, bool is_bound, bool is_computed);
+static void srte_unset_metric(struct srte_metric *metric);
+
+
+/* Generate rb-tree of Segment List Segment instances. */
+static inline int srte_segment_entry_compare(const struct srte_segment_entry *a,
+ const struct srte_segment_entry *b)
+{
+ return a->index - b->index;
+}
+RB_GENERATE(srte_segment_entry_head, srte_segment_entry, entry,
+ srte_segment_entry_compare)
+
+/* Generate rb-tree of Segment List instances. */
+static inline int srte_segment_list_compare(const struct srte_segment_list *a,
+ const struct srte_segment_list *b)
+{
+ return strcmp(a->name, b->name);
+}
+RB_GENERATE(srte_segment_list_head, srte_segment_list, entry,
+ srte_segment_list_compare)
+
+struct srte_segment_list_head srte_segment_lists =
+ RB_INITIALIZER(&srte_segment_lists);
+
+/* Generate rb-tree of Candidate Path instances. */
+static inline int srte_candidate_compare(const struct srte_candidate *a,
+ const struct srte_candidate *b)
+{
+ return a->preference - b->preference;
+}
+RB_GENERATE(srte_candidate_head, srte_candidate, entry, srte_candidate_compare)
+
+/* Generate rb-tree of SR Policy instances. */
+static inline int srte_policy_compare(const struct srte_policy *a,
+ const struct srte_policy *b)
+{
+ return sr_policy_compare(&a->endpoint, &b->endpoint, a->color,
+ b->color);
+}
+RB_GENERATE(srte_policy_head, srte_policy, entry, srte_policy_compare)
+
+struct srte_policy_head srte_policies = RB_INITIALIZER(&srte_policies);
+
+/**
+ * Adds a segment list to pathd.
+ *
+ * @param name The name of the segment list to add
+ * @return The added segment list
+ */
+struct srte_segment_list *srte_segment_list_add(const char *name)
+{
+ struct srte_segment_list *segment_list;
+
+ segment_list = XCALLOC(MTYPE_PATH_SEGMENT_LIST, sizeof(*segment_list));
+ strlcpy(segment_list->name, name, sizeof(segment_list->name));
+ RB_INIT(srte_segment_entry_head, &segment_list->segments);
+ RB_INSERT(srte_segment_list_head, &srte_segment_lists, segment_list);
+
+ return segment_list;
+}
+
+/**
+ * Deletes a segment list from pathd.
+ *
+ * The given segment list structure will be freed and should not be used anymore
+ * after calling this function.
+ *
+ * @param segment_list the segment list to remove from pathd.
+ */
+void srte_segment_list_del(struct srte_segment_list *segment_list)
+{
+ struct srte_segment_entry *segment, *safe_seg;
+ RB_FOREACH_SAFE (segment, srte_segment_entry_head,
+ &segment_list->segments, safe_seg) {
+ srte_segment_entry_del(segment);
+ }
+ RB_REMOVE(srte_segment_list_head, &srte_segment_lists, segment_list);
+ XFREE(MTYPE_PATH_SEGMENT_LIST, segment_list);
+}
+
+/**
+ * Search for a segment list by name.
+ *
+ * @param name The name of the segment list to look for
+ * @return The segment list if found, NULL otherwise
+ */
+struct srte_segment_list *srte_segment_list_find(const char *name)
+{
+ struct srte_segment_list search;
+
+ strlcpy(search.name, name, sizeof(search.name));
+ return RB_FIND(srte_segment_list_head, &srte_segment_lists, &search);
+}
+
+/**
+ * Adds a segment to a segment list.
+ *
+ * @param segment_list The segment list the segment should be added to
+ * @param index The index of the added segment in the segment list
+ * @return The added segment
+ */
+struct srte_segment_entry *
+srte_segment_entry_add(struct srte_segment_list *segment_list, uint32_t index)
+{
+ struct srte_segment_entry *segment;
+
+ segment = XCALLOC(MTYPE_PATH_SEGMENT_LIST, sizeof(*segment));
+ segment->segment_list = segment_list;
+ segment->index = index;
+ RB_INSERT(srte_segment_entry_head, &segment_list->segments, segment);
+
+ return segment;
+}
+
+/**
+ * Deletes a segment from a segment list.
+ *
+ * @param segment The segment to be removed
+ */
+void srte_segment_entry_del(struct srte_segment_entry *segment)
+{
+ RB_REMOVE(srte_segment_entry_head, &segment->segment_list->segments,
+ segment);
+ XFREE(MTYPE_PATH_SEGMENT_LIST, segment);
+}
+
+/**
+ * Set the node or adjacency identifier of a segment.
+ *
+ * @param segment The segment for which the NAI should be set
+ * @param type The type of the NAI
+ * @param type The address of the node or the local address of the adjacency
+ * @param type The local interface index of the unumbered adjacency
+ * @param type The remote address of the adjacency
+ * @param type The remote interface index of the unumbered adjacency
+ */
+int srte_segment_entry_set_nai(struct srte_segment_entry *segment,
+ enum srte_segment_nai_type type,
+ struct ipaddr *local_ip, uint32_t local_iface,
+ struct ipaddr *remote_ip, uint32_t remote_iface,
+ uint8_t algo, uint8_t pref_len)
+{
+
+ int32_t status = 0;
+ struct prefix pre = {0};
+
+ if (!segment || !local_ip || !remote_ip)
+ return 1;
+
+ segment->nai_type = type;
+ memcpy(&segment->nai_local_addr, local_ip, sizeof(struct ipaddr));
+
+ switch (type) {
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_NODE:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_NODE:
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY:
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY:
+ memcpy(&segment->nai_remote_addr, remote_ip,
+ sizeof(struct ipaddr));
+ status = srte_ted_do_query_type_f(segment, local_ip, remote_ip);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_UNNUMBERED_ADJACENCY:
+ memcpy(&segment->nai_remote_addr, remote_ip,
+ sizeof(struct ipaddr));
+ segment->nai_local_iface = local_iface;
+ segment->nai_remote_iface = remote_iface;
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ALGORITHM:
+ pre.family = AF_INET6;
+ pre.prefixlen = pref_len;
+ pre.u.prefix6 = local_ip->ip._v6_addr;
+ segment->nai_local_prefix_len = pref_len;
+ segment->nai_algorithm = algo;
+ status = srte_ted_do_query_type_c(segment, &pre, algo);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM:
+ pre.family = AF_INET;
+ pre.prefixlen = pref_len;
+ pre.u.prefix4 = local_ip->ip._v4_addr;
+ segment->nai_local_prefix_len = pref_len;
+ segment->nai_algorithm = algo;
+ status = srte_ted_do_query_type_c(segment, &pre, algo);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_LOCAL_IFACE:
+ pre.family = AF_INET6;
+ pre.prefixlen = pref_len;
+ pre.u.prefix6 = local_ip->ip._v6_addr;
+ segment->nai_local_prefix_len = pref_len;
+ segment->nai_local_iface = local_iface;
+ status = srte_ted_do_query_type_e(segment, &pre, local_iface);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE:
+ pre.family = AF_INET;
+ pre.prefixlen = pref_len;
+ pre.u.prefix4 = local_ip->ip._v4_addr;
+ segment->nai_local_prefix_len = pref_len;
+ segment->nai_local_iface = local_iface;
+ status = srte_ted_do_query_type_e(segment, &pre, local_iface);
+ break;
+ default:
+ segment->nai_local_addr.ipa_type = IPADDR_NONE;
+ segment->nai_local_iface = 0;
+ segment->nai_remote_addr.ipa_type = IPADDR_NONE;
+ segment->nai_remote_iface = 0;
+ }
+ return status;
+}
+
+/**
+ * Mark segment as modified depending in protocol and sid conditions
+ *
+ * @param protocol_origin Origin of the segment list
+ * @param s_list Ptr to segment list with flags,sid to modidy
+ * @param s_entry Ptr to segment entry with sid to modidy
+ * @param ted_sid The sid from ted query
+ * @return void
+ */
+void srte_segment_set_local_modification(struct srte_segment_list *s_list,
+ struct srte_segment_entry *s_entry,
+ uint32_t ted_sid)
+{
+ if (!s_list || !s_entry)
+ return;
+
+ if (s_list->protocol_origin == SRTE_ORIGIN_LOCAL
+ && s_entry->sid_value != ted_sid) {
+ s_entry->sid_value = ted_sid;
+ SET_FLAG(s_list->flags, F_SEGMENT_LIST_MODIFIED);
+ }
+}
+
+/**
+ * Add a policy to pathd.
+ *
+ * WARNING: The color 0 is a special case as it is the no-color.
+ *
+ * @param color The color of the policy.
+ * @param endpoint The IP address of the policy endpoint
+ * @return The created policy
+ */
+struct srte_policy *srte_policy_add(uint32_t color, struct ipaddr *endpoint,
+ enum srte_protocol_origin origin,
+ const char *originator)
+{
+ struct srte_policy *policy;
+
+ policy = XCALLOC(MTYPE_PATH_SR_POLICY, sizeof(*policy));
+ policy->color = color;
+ policy->endpoint = *endpoint;
+ policy->binding_sid = MPLS_LABEL_NONE;
+ policy->protocol_origin = origin;
+ if (originator != NULL)
+ strlcpy(policy->originator, originator,
+ sizeof(policy->originator));
+
+ RB_INIT(srte_candidate_head, &policy->candidate_paths);
+ RB_INSERT(srte_policy_head, &srte_policies, policy);
+
+ return policy;
+}
+
+/**
+ * Delete a policy from pathd.
+ *
+ * The given policy structure will be freed and should never be used again
+ * after calling this function.
+ *
+ * @param policy The policy to be removed
+ */
+void srte_policy_del(struct srte_policy *policy)
+{
+ struct srte_candidate *candidate;
+
+ path_zebra_delete_sr_policy(policy);
+
+ path_zebra_release_label(policy->binding_sid);
+
+ while (!RB_EMPTY(srte_candidate_head, &policy->candidate_paths)) {
+ candidate =
+ RB_ROOT(srte_candidate_head, &policy->candidate_paths);
+ trigger_pathd_candidate_removed(candidate);
+ srte_candidate_del(candidate);
+ }
+
+ RB_REMOVE(srte_policy_head, &srte_policies, policy);
+ XFREE(MTYPE_PATH_SR_POLICY, policy);
+}
+
+/**
+ * Search for a policy by color and endpoint.
+ *
+ * WARNING: The color 0 is a special case as it is the no-color.
+ *
+ * @param color The color of the policy to look for
+ * @param endpoint The endpoint of the policy to look for
+ * @return The policy if found, NULL otherwise
+ */
+struct srte_policy *srte_policy_find(uint32_t color, struct ipaddr *endpoint)
+{
+ struct srte_policy search;
+
+ search.color = color;
+ search.endpoint = *endpoint;
+ return RB_FIND(srte_policy_head, &srte_policies, &search);
+}
+
+/*
+ * After new data from igp,local and pce the segment list :
+ * Mark as invalid for origin pce if cannot be validated
+ * Updated for origin local
+ */
+int srte_policy_update_ted_sid(void)
+{
+
+ int number_of_sid_clashed = 0;
+ struct srte_segment_list *s_list;
+ struct srte_segment_entry *s_entry;
+
+ if (!path_ted_is_initialized())
+ return 0;
+ if (RB_EMPTY(srte_segment_list_head, &srte_segment_lists))
+ return 0;
+
+ RB_FOREACH (s_list, srte_segment_list_head, &srte_segment_lists) {
+ if (CHECK_FLAG(s_list->flags, F_SEGMENT_LIST_DELETED))
+ continue;
+ RB_FOREACH (s_entry, srte_segment_entry_head,
+ &s_list->segments) {
+ PATH_TED_DEBUG(
+ "%s:PATHD-TED: SL: Name: %s index:(%d) sid:(%d) prefix_len:(%d) local iface:(%d) algorithm:(%d)",
+ __func__, s_list->name, s_entry->index,
+ s_entry->sid_value,
+ s_entry->nai_local_prefix_len,
+ s_entry->nai_local_iface,
+ s_entry->nai_algorithm);
+ struct prefix prefix_cli = {0};
+
+ switch (s_entry->nai_type) {
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY:
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY:
+ number_of_sid_clashed +=
+ srte_ted_do_query_type_f(
+ s_entry,
+ &s_entry->nai_local_addr,
+ &s_entry->nai_remote_addr);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_LOCAL_IFACE:
+ prefix_cli.family = AF_INET6;
+ prefix_cli.prefixlen =
+ s_entry->nai_local_prefix_len;
+ prefix_cli.u.prefix6 =
+ s_entry->nai_local_addr.ip._v6_addr;
+ number_of_sid_clashed +=
+ srte_ted_do_query_type_e(
+ s_entry, &prefix_cli,
+ s_entry->nai_local_iface);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE:
+ prefix_cli.family = AF_INET;
+ prefix_cli.prefixlen =
+ s_entry->nai_local_prefix_len;
+ prefix_cli.u.prefix4 =
+ s_entry->nai_local_addr.ip._v4_addr;
+ number_of_sid_clashed +=
+ srte_ted_do_query_type_e(
+ s_entry, &prefix_cli,
+ s_entry->nai_local_iface);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV6_ALGORITHM:
+ prefix_cli.family = AF_INET6;
+ prefix_cli.prefixlen =
+ s_entry->nai_local_prefix_len;
+ prefix_cli.u.prefix6 =
+ s_entry->nai_local_addr.ip._v6_addr;
+ number_of_sid_clashed +=
+ srte_ted_do_query_type_c(
+ s_entry, &prefix_cli,
+ s_entry->nai_algorithm);
+ break;
+ case SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM:
+ prefix_cli.family = AF_INET;
+ prefix_cli.prefixlen =
+ s_entry->nai_local_prefix_len;
+ prefix_cli.u.prefix4 =
+ s_entry->nai_local_addr.ip._v4_addr;
+ number_of_sid_clashed +=
+ srte_ted_do_query_type_c(
+ s_entry, &prefix_cli,
+ s_entry->nai_algorithm);
+ break;
+ default:
+ break;
+ }
+ }
+ if (number_of_sid_clashed) {
+ SET_FLAG(s_list->flags, F_SEGMENT_LIST_SID_CONFLICT);
+ number_of_sid_clashed = 0;
+ } else
+ UNSET_FLAG(s_list->flags, F_SEGMENT_LIST_SID_CONFLICT);
+ }
+ srte_apply_changes();
+
+ return 0;
+}
+
+/**
+ * Update a policy binding SID.
+ *
+ * @param policy The policy for which the SID should be updated
+ * @param binding_sid The new binding SID for the given policy
+ */
+void srte_policy_update_binding_sid(struct srte_policy *policy,
+ uint32_t binding_sid)
+{
+ if (policy->binding_sid != MPLS_LABEL_NONE)
+ path_zebra_release_label(policy->binding_sid);
+
+ policy->binding_sid = binding_sid;
+
+ /* Reinstall the Binding-SID if necessary. */
+ if (policy->best_candidate)
+ path_zebra_add_sr_policy(
+ policy, policy->best_candidate->lsp->segment_list);
+}
+
+/**
+ * Gives the policy best candidate path.
+ *
+ * @param policy The policy we want the best candidate path from
+ * @return The best candidate path
+ */
+static struct srte_candidate *
+srte_policy_best_candidate(const struct srte_policy *policy)
+{
+ struct srte_candidate *candidate;
+
+ RB_FOREACH_REVERSE (candidate, srte_candidate_head,
+ &policy->candidate_paths) {
+ /* search for highest preference with existing segment list */
+ if (!CHECK_FLAG(candidate->flags, F_CANDIDATE_DELETED)
+ && candidate->lsp->segment_list
+ && (!CHECK_FLAG(candidate->lsp->segment_list->flags,
+ F_SEGMENT_LIST_SID_CONFLICT)))
+ return candidate;
+ }
+
+ return NULL;
+}
+
+void srte_clean_zebra(void)
+{
+ struct srte_policy *policy, *safe_pol;
+
+ RB_FOREACH_SAFE (policy, srte_policy_head, &srte_policies, safe_pol)
+ srte_policy_del(policy);
+
+ path_zebra_stop();
+}
+
+/**
+ * Apply changes defined by setting the policies, candidate paths
+ * and segment lists modification flags NEW, MODIFIED and DELETED.
+ *
+ * This allows the northbound code to delay all the side effects of adding
+ * modifying and deleting them to the end.
+ *
+ * Example of marking an object as modified:
+ * `SET_FLAG(obj->flags, F_XXX_MODIFIED)`
+ */
+void srte_apply_changes(void)
+{
+ struct srte_policy *policy, *safe_pol;
+ struct srte_segment_list *segment_list, *safe_sl;
+
+ RB_FOREACH_SAFE (policy, srte_policy_head, &srte_policies, safe_pol) {
+ if (CHECK_FLAG(policy->flags, F_POLICY_DELETED)) {
+ srte_policy_del(policy);
+ continue;
+ }
+ srte_policy_apply_changes(policy);
+ UNSET_FLAG(policy->flags, F_POLICY_NEW);
+ UNSET_FLAG(policy->flags, F_POLICY_MODIFIED);
+ }
+
+ RB_FOREACH_SAFE (segment_list, srte_segment_list_head,
+ &srte_segment_lists, safe_sl) {
+ if (CHECK_FLAG(segment_list->flags, F_SEGMENT_LIST_DELETED)) {
+ srte_segment_list_del(segment_list);
+ continue;
+ }
+ UNSET_FLAG(segment_list->flags, F_SEGMENT_LIST_NEW);
+ UNSET_FLAG(segment_list->flags, F_SEGMENT_LIST_MODIFIED);
+ }
+}
+
+/**
+ * Apply changes defined by setting the given policy and its candidate paths
+ * modification flags NEW, MODIFIED and DELETED.
+ *
+ * In moste cases `void srte_apply_changes(void)` should be used instead,
+ * this function will not handle the changes of segment lists used by the
+ * policy.
+ *
+ * @param policy The policy changes has to be applied to.
+ */
+void srte_policy_apply_changes(struct srte_policy *policy)
+{
+ struct srte_candidate *candidate, *safe;
+ struct srte_candidate *old_best_candidate;
+ struct srte_candidate *new_best_candidate;
+ char endpoint[46];
+
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+
+ /* Get old and new best candidate path. */
+ old_best_candidate = policy->best_candidate;
+ new_best_candidate = srte_policy_best_candidate(policy);
+
+ if (new_best_candidate != old_best_candidate) {
+ /* TODO: add debug guard. */
+ zlog_debug(
+ "SR-TE(%s, %u): best candidate changed from %s to %s",
+ endpoint, policy->color,
+ old_best_candidate ? old_best_candidate->name : "none",
+ new_best_candidate ? new_best_candidate->name : "none");
+
+ if (old_best_candidate) {
+ policy->best_candidate = NULL;
+ UNSET_FLAG(old_best_candidate->flags, F_CANDIDATE_BEST);
+ SET_FLAG(old_best_candidate->flags,
+ F_CANDIDATE_MODIFIED);
+
+ /*
+ * Rely on replace semantics if there's a new best
+ * candidate.
+ */
+ if (!new_best_candidate)
+ path_zebra_delete_sr_policy(policy);
+ }
+ if (new_best_candidate) {
+ policy->best_candidate = new_best_candidate;
+ SET_FLAG(new_best_candidate->flags, F_CANDIDATE_BEST);
+ SET_FLAG(new_best_candidate->flags,
+ F_CANDIDATE_MODIFIED);
+
+ path_zebra_add_sr_policy(
+ policy, new_best_candidate->lsp->segment_list);
+ }
+ } else if (new_best_candidate) {
+ /* The best candidate path did not change, but some of its
+ * attributes or its segment list may have changed.
+ */
+
+ bool candidate_changed = CHECK_FLAG(new_best_candidate->flags,
+ F_CANDIDATE_MODIFIED);
+ bool segment_list_changed =
+ new_best_candidate->lsp->segment_list
+ && CHECK_FLAG(
+ new_best_candidate->lsp->segment_list->flags,
+ F_SEGMENT_LIST_MODIFIED);
+
+ if (candidate_changed || segment_list_changed) {
+ /* TODO: add debug guard. */
+ zlog_debug("SR-TE(%s, %u): best candidate %s changed",
+ endpoint, policy->color,
+ new_best_candidate->name);
+
+ path_zebra_add_sr_policy(
+ policy, new_best_candidate->lsp->segment_list);
+ }
+ }
+
+ RB_FOREACH_SAFE (candidate, srte_candidate_head,
+ &policy->candidate_paths, safe) {
+ if (CHECK_FLAG(candidate->flags, F_CANDIDATE_DELETED)) {
+ trigger_pathd_candidate_removed(candidate);
+ srte_candidate_del(candidate);
+ continue;
+ } else if (CHECK_FLAG(candidate->flags, F_CANDIDATE_NEW)) {
+ trigger_pathd_candidate_created(candidate);
+ } else if (CHECK_FLAG(candidate->flags, F_CANDIDATE_MODIFIED)) {
+ trigger_pathd_candidate_updated(candidate);
+ } else if (candidate->lsp->segment_list
+ && CHECK_FLAG(candidate->lsp->segment_list->flags,
+ F_SEGMENT_LIST_MODIFIED)) {
+ trigger_pathd_candidate_updated(candidate);
+ }
+
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_NEW);
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ }
+}
+
+/**
+ * Adds a candidate path to a policy.
+ *
+ * @param policy The policy the candidate path should be added to
+ * @param preference The preference of the candidate path to be added
+ * @return The added candidate path
+ */
+struct srte_candidate *srte_candidate_add(struct srte_policy *policy,
+ uint32_t preference,
+ enum srte_protocol_origin origin,
+ const char *originator)
+{
+ struct srte_candidate *candidate;
+ struct srte_lsp *lsp;
+
+ candidate = XCALLOC(MTYPE_PATH_SR_CANDIDATE, sizeof(*candidate));
+ lsp = XCALLOC(MTYPE_PATH_SR_CANDIDATE, sizeof(*lsp));
+
+ candidate->preference = preference;
+ candidate->policy = policy;
+ candidate->type = SRTE_CANDIDATE_TYPE_UNDEFINED;
+ candidate->discriminator = frr_weak_random();
+ candidate->protocol_origin = origin;
+ if (originator != NULL) {
+ strlcpy(candidate->originator, originator,
+ sizeof(candidate->originator));
+ lsp->protocol_origin = origin;
+ }
+
+ if (candidate->protocol_origin == SRTE_ORIGIN_PCEP
+ || candidate->protocol_origin == SRTE_ORIGIN_BGP) {
+ candidate->type = SRTE_CANDIDATE_TYPE_DYNAMIC;
+ }
+ lsp->candidate = candidate;
+ candidate->lsp = lsp;
+
+ RB_INSERT(srte_candidate_head, &policy->candidate_paths, candidate);
+
+ return candidate;
+}
+
+/**
+ * Deletes a candidate.
+ *
+ * The corresponding LSP will be removed alongside the candidate path.
+ * The given candidate will be freed and shouldn't be used anymore after the
+ * calling this function.
+ *
+ * @param candidate The candidate path to delete
+ */
+void srte_candidate_del(struct srte_candidate *candidate)
+{
+ struct srte_policy *srte_policy = candidate->policy;
+
+ RB_REMOVE(srte_candidate_head, &srte_policy->candidate_paths,
+ candidate);
+
+ XFREE(MTYPE_PATH_SR_CANDIDATE, candidate->lsp);
+ XFREE(MTYPE_PATH_SR_CANDIDATE, candidate);
+}
+
+/**
+ * Sets the bandwidth constraint of given candidate path.
+ *
+ * The corresponding LSP will be changed too.
+ *
+ * @param candidate The candidate path of which the bandwidth should be changed
+ * @param bandwidth The Bandwidth constraint to set to the candidate path
+ * @param required If the constraint is required (true) or only desired (false)
+ */
+void srte_candidate_set_bandwidth(struct srte_candidate *candidate,
+ float bandwidth, bool required)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug(
+ "SR-TE(%s, %u): candidate %s %sconfig bandwidth set to %f B/s",
+ endpoint, policy->color, candidate->name,
+ required ? "required " : "", bandwidth);
+ SET_FLAG(candidate->flags, F_CANDIDATE_HAS_BANDWIDTH);
+ COND_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_BANDWIDTH, required);
+ candidate->bandwidth = bandwidth;
+
+ srte_lsp_set_bandwidth(candidate->lsp, bandwidth, required);
+}
+
+/**
+ * Sets the bandwidth constraint of the given LSP.
+ *
+ * The changes will not be shown as part of the running configuration.
+ *
+ * @param lsp The lsp of which the bandwidth should be changed
+ * @param bandwidth The Bandwidth constraint to set to the candidate path
+ * @param required If the constraint is required (true) or only desired (false)
+ */
+void srte_lsp_set_bandwidth(struct srte_lsp *lsp, float bandwidth,
+ bool required)
+{
+ struct srte_candidate *candidate = lsp->candidate;
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug("SR-TE(%s, %u): candidate %s %slsp bandwidth set to %f B/s",
+ endpoint, policy->color, candidate->name,
+ required ? "required" : "", bandwidth);
+ SET_FLAG(lsp->flags, F_CANDIDATE_HAS_BANDWIDTH);
+ COND_FLAG(lsp->flags, F_CANDIDATE_REQUIRED_BANDWIDTH, required);
+ lsp->bandwidth = bandwidth;
+}
+
+/**
+ * Remove a candidate path bandwidth constraint.
+ *
+ * The corresponding LSP will be changed too.
+ *
+ * @param candidate The candidate path of which the bandwidth should be removed
+ */
+void srte_candidate_unset_bandwidth(struct srte_candidate *candidate)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug("SR-TE(%s, %u): candidate %s config bandwidth unset",
+ endpoint, policy->color, candidate->name);
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_HAS_BANDWIDTH);
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_BANDWIDTH);
+ candidate->bandwidth = 0;
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ srte_lsp_unset_bandwidth(candidate->lsp);
+}
+
+/**
+ * Remove an LSP bandwidth constraint.
+ *
+ * The changes will not be shown as part of the running configuration.
+ *
+ * @param lsp The lsp of which the bandwidth should be changed
+ */
+void srte_lsp_unset_bandwidth(struct srte_lsp *lsp)
+{
+ struct srte_candidate *candidate = lsp->candidate;
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug("SR-TE(%s, %u): candidate %s lsp bandwidth unset", endpoint,
+ policy->color, candidate->name);
+ UNSET_FLAG(lsp->flags, F_CANDIDATE_HAS_BANDWIDTH);
+ UNSET_FLAG(lsp->flags, F_CANDIDATE_REQUIRED_BANDWIDTH);
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ lsp->bandwidth = 0;
+}
+
+/**
+ * Sets a candidate path metric constraint.
+ *
+ * The corresponding LSP will be changed too.
+ *
+ * @param candidate The candidate path of which the metric should be changed
+ * @param type The metric type
+ * @param value The metric value
+ * @param required If the constraint is required (true) or only desired (false)
+ * @param is_bound If the metric is an indicative value or a strict upper bound
+ * @param is_computed If the metric was computed or configured
+ */
+void srte_candidate_set_metric(struct srte_candidate *candidate,
+ enum srte_candidate_metric_type type,
+ float value, bool required, bool is_bound,
+ bool is_computed)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug(
+ "SR-TE(%s, %u): candidate %s %sconfig metric %s (%u) set to %f (is-bound: %s; is_computed: %s)",
+ endpoint, policy->color, candidate->name,
+ required ? "required " : "", srte_candidate_metric_name(type),
+ type, value, is_bound ? "true" : "false",
+ is_computed ? "true" : "false");
+ assert((type > 0) && (type <= MAX_METRIC_TYPE));
+ srte_set_metric(&candidate->metrics[type - 1], value, required,
+ is_bound, is_computed);
+ srte_lsp_set_metric(candidate->lsp, type, value, required, is_bound,
+ is_computed);
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+}
+
+/**
+ * Sets an LSP metric constraint.
+ *
+ * The changes will not be shown as part of the running configuration.
+ *
+ * @param lsp The LSP of which the metric should be changed
+ * @param type The metric type
+ * @param value The metric value
+ * @param required If the constraint is required (true) or only desired (false)
+ * @param is_bound If the metric is an indicative value or a strict upper bound
+ * @param is_computed If the metric was computed or configured
+ */
+void srte_lsp_set_metric(struct srte_lsp *lsp,
+ enum srte_candidate_metric_type type, float value,
+ bool required, bool is_bound, bool is_computed)
+{
+ struct srte_candidate *candidate = lsp->candidate;
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug(
+ "SR-TE(%s, %u): candidate %s %slsp metric %s (%u) set to %f (is-bound: %s; is_computed: %s)",
+ endpoint, policy->color, candidate->name,
+ required ? "required " : "", srte_candidate_metric_name(type),
+ type, value, is_bound ? "true" : "false",
+ is_computed ? "true" : "false");
+ assert((type > 0) && (type <= MAX_METRIC_TYPE));
+ srte_set_metric(&lsp->metrics[type - 1], value, required, is_bound,
+ is_computed);
+}
+
+void srte_set_metric(struct srte_metric *metric, float value, bool required,
+ bool is_bound, bool is_computed)
+{
+ SET_FLAG(metric->flags, F_METRIC_IS_DEFINED);
+ COND_FLAG(metric->flags, F_METRIC_IS_REQUIRED, required);
+ COND_FLAG(metric->flags, F_METRIC_IS_BOUND, is_bound);
+ COND_FLAG(metric->flags, F_METRIC_IS_COMPUTED, is_computed);
+ metric->value = value;
+}
+
+/**
+ * Removes a candidate path metric constraint.
+ *
+ * The corresponding LSP will be changed too.
+ *
+ * @param candidate The candidate path from which the metric should be removed
+ * @param type The metric type
+ */
+void srte_candidate_unset_metric(struct srte_candidate *candidate,
+ enum srte_candidate_metric_type type)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug("SR-TE(%s, %u): candidate %s config metric %s (%u) unset",
+ endpoint, policy->color, candidate->name,
+ srte_candidate_metric_name(type), type);
+ assert((type > 0) && (type <= MAX_METRIC_TYPE));
+ srte_unset_metric(&candidate->metrics[type - 1]);
+ srte_lsp_unset_metric(candidate->lsp, type);
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+}
+
+/**
+ * Removes a candidate path metric constraint.
+ *
+ * The changes will not be shown as part of the running configuration.
+ *
+ * @param lsp The LSP from which the metric should be removed
+ * @param type The metric type
+ */
+void srte_lsp_unset_metric(struct srte_lsp *lsp,
+ enum srte_candidate_metric_type type)
+{
+ struct srte_candidate *candidate = lsp->candidate;
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug("SR-TE(%s, %u): candidate %s lsp metric %s (%u) unset",
+ endpoint, policy->color, candidate->name,
+ srte_candidate_metric_name(type), type);
+ assert((type > 0) && (type <= MAX_METRIC_TYPE));
+ srte_unset_metric(&lsp->metrics[type - 1]);
+}
+
+void srte_unset_metric(struct srte_metric *metric)
+{
+ UNSET_FLAG(metric->flags, F_METRIC_IS_DEFINED);
+ UNSET_FLAG(metric->flags, F_METRIC_IS_BOUND);
+ UNSET_FLAG(metric->flags, F_METRIC_IS_COMPUTED);
+ metric->value = 0;
+}
+
+/**
+ * Sets a candidate path objective function.
+ *
+ * @param candidate The candidate path of which the OF should be changed
+ * @param required If the constraint is required (true) or only desired (false)
+ * @param type The objective function type
+ */
+void srte_candidate_set_objfun(struct srte_candidate *candidate, bool required,
+ enum objfun_type type)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+
+ candidate->objfun = type;
+ SET_FLAG(candidate->flags, F_CANDIDATE_HAS_OBJFUN);
+ COND_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_OBJFUN, required);
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ zlog_debug("SR-TE(%s, %u): candidate %s %sobjective function set to %s",
+ endpoint, policy->color, candidate->name,
+ required ? "required " : "", objfun_type_name(type));
+}
+
+/**
+ * Removed the objective function constraint from a candidate path.
+ *
+ * @param candidate The candidate path from which the OF should be removed
+ */
+void srte_candidate_unset_objfun(struct srte_candidate *candidate)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_HAS_OBJFUN);
+ UNSET_FLAG(candidate->flags, F_CANDIDATE_REQUIRED_OBJFUN);
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ candidate->objfun = OBJFUN_UNDEFINED;
+ zlog_debug(
+ "SR-TE(%s, %u): candidate %s objective functions preferences unset",
+ endpoint, policy->color, candidate->name);
+}
+
+static uint32_t filter_type_to_flag(enum affinity_filter_type type)
+{
+ switch (type) {
+ case AFFINITY_FILTER_EXCLUDE_ANY:
+ return F_CANDIDATE_HAS_EXCLUDE_ANY;
+ case AFFINITY_FILTER_INCLUDE_ANY:
+ return F_CANDIDATE_HAS_INCLUDE_ANY;
+ case AFFINITY_FILTER_INCLUDE_ALL:
+ return F_CANDIDATE_HAS_INCLUDE_ALL;
+ default:
+ return 0;
+ }
+}
+
+static const char *filter_type_name(enum affinity_filter_type type)
+{
+ switch (type) {
+ case AFFINITY_FILTER_EXCLUDE_ANY:
+ return "exclude-any";
+ case AFFINITY_FILTER_INCLUDE_ANY:
+ return "include-any";
+ case AFFINITY_FILTER_INCLUDE_ALL:
+ return "include-all";
+ default:
+ return "unknown";
+ }
+}
+
+/**
+ * Sets a candidate path affinity filter constraint.
+ *
+ * @param candidate The candidate path of which the constraint should be changed
+ * @param type The affinity constraint type to set
+ * @param filter The bitmask filter of the constraint
+ */
+void srte_candidate_set_affinity_filter(struct srte_candidate *candidate,
+ enum affinity_filter_type type,
+ uint32_t filter)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+
+ assert(type > AFFINITY_FILTER_UNDEFINED);
+ assert(type <= MAX_AFFINITY_FILTER_TYPE);
+ SET_FLAG(candidate->flags, filter_type_to_flag(type));
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ candidate->affinity_filters[type - 1] = filter;
+ zlog_debug(
+ "SR-TE(%s, %u): candidate %s affinity filter %s set to 0x%08x",
+ endpoint, policy->color, candidate->name,
+ filter_type_name(type), filter);
+}
+
+/**
+ * Removes a candidate path affinity filter constraint.
+ *
+ * @param candidate The candidate path from which the constraint should be
+ * removed
+ * @param type The affinity constraint type to remove
+ */
+void srte_candidate_unset_affinity_filter(struct srte_candidate *candidate,
+ enum affinity_filter_type type)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+
+ assert(type > AFFINITY_FILTER_UNDEFINED);
+ assert(type <= MAX_AFFINITY_FILTER_TYPE);
+ UNSET_FLAG(candidate->flags, filter_type_to_flag(type));
+ SET_FLAG(candidate->flags, F_CANDIDATE_MODIFIED);
+ candidate->affinity_filters[type - 1] = 0;
+ zlog_debug("SR-TE(%s, %u): candidate %s affinity filter %s unset",
+ endpoint, policy->color, candidate->name,
+ filter_type_name(type));
+}
+
+/**
+ * Searches for a candidate path of the given policy.
+ *
+ * @param policy The policy to search for candidate path
+ * @param preference The preference of the candidate path you are looking for
+ * @return The candidate path if found, NULL otherwise
+ */
+struct srte_candidate *srte_candidate_find(struct srte_policy *policy,
+ uint32_t preference)
+{
+ struct srte_candidate search;
+
+ search.preference = preference;
+ return RB_FIND(srte_candidate_head, &policy->candidate_paths, &search);
+}
+
+/**
+ * Searches for a an entry of a given segment list.
+ *
+ * @param segment_list The segment list to search for the entry
+ * @param index The index of the entry you are looking for
+ * @return The segment list entry if found, NULL otherwise.
+ */
+struct srte_segment_entry *
+srte_segment_entry_find(struct srte_segment_list *segment_list, uint32_t index)
+{
+ struct srte_segment_entry search;
+
+ search.index = index;
+ return RB_FIND(srte_segment_entry_head, &segment_list->segments,
+ &search);
+}
+
+/**
+ * Updates a candidate status.
+ *
+ * @param candidate The candidate of which the status should be updated
+ * @param status The new candidate path status
+ */
+void srte_candidate_status_update(struct srte_candidate *candidate, int status)
+{
+ struct srte_policy *policy = candidate->policy;
+ char endpoint[46];
+ ipaddr2str(&policy->endpoint, endpoint, sizeof(endpoint));
+ zlog_debug("SR-TE(%s, %u): zebra updated status to %d", endpoint,
+ policy->color, status);
+ switch (status) {
+ case ZEBRA_SR_POLICY_DOWN:
+ switch (policy->status) {
+ /* If the policy is GOING_UP, and zebra faild
+ to install it, we wait for zebra to retry */
+ /* TODO: Add some timeout after which we would
+ get is back to DOWN and remove the
+ policy */
+ case SRTE_POLICY_STATUS_GOING_UP:
+ case SRTE_POLICY_STATUS_DOWN:
+ return;
+ default:
+ zlog_debug("SR-TE(%s, %u): policy is DOWN", endpoint,
+ policy->color);
+ policy->status = SRTE_POLICY_STATUS_DOWN;
+ break;
+ }
+ break;
+ case ZEBRA_SR_POLICY_UP:
+ switch (policy->status) {
+ case SRTE_POLICY_STATUS_UP:
+ return;
+ default:
+ zlog_debug("SR-TE(%s, %u): policy is UP", endpoint,
+ policy->color);
+ policy->status = SRTE_POLICY_STATUS_UP;
+ break;
+ }
+ break;
+ }
+
+ trigger_pathd_candidate_updated(candidate);
+}
+
+/**
+ * Flags the segment lists from give originator for removal.
+ *
+ * The function srte_apply_changes must be called afterward for
+ * the segment list to be removed.
+ *
+ * @param originator The originator tag of the segment list to be marked
+ * @param force If the unset should be forced regardless of the originator
+ */
+void srte_candidate_unset_segment_list(const char *originator, bool force)
+{
+ if (originator == NULL) {
+ zlog_warn(
+ "Cannot unset segment list because originator is NULL");
+ return;
+ }
+
+ zlog_debug("Unset segment lists for originator %s", originator);
+
+ /* Iterate the policies, then iterate each policy's candidate path
+ * to check the candidate path's segment list originator */
+ struct srte_policy *policy;
+ RB_FOREACH (policy, srte_policy_head, &srte_policies) {
+ zlog_debug("Unset segment lists checking policy %s",
+ policy->name);
+ struct srte_candidate *candidate;
+ RB_FOREACH (candidate, srte_candidate_head,
+ &policy->candidate_paths) {
+ zlog_debug("Unset segment lists checking candidate %s",
+ candidate->name);
+ if (candidate->lsp == NULL) {
+ continue;
+ }
+
+ /* The candidate->lsp->segment_list is operational data,
+ * configured by the PCE. We dont want to modify the
+ * candidate->segment_list,
+ * which is configuration data. */
+ struct srte_segment_list *segment_list =
+ candidate->lsp->segment_list;
+ if (segment_list == NULL) {
+ continue;
+ }
+
+ if (segment_list->protocol_origin
+ == SRTE_ORIGIN_LOCAL) {
+ zlog_warn(
+ "Cannot unset segment list %s because it was created locally",
+ segment_list->name);
+ continue;
+ }
+
+ /* In the case of last pce,we force the unset
+ * because we don't have pce by prefix (TODO) is all
+ * 'global' */
+ if (strncmp(segment_list->originator, originator,
+ sizeof(segment_list->originator))
+ == 0
+ || force) {
+ zlog_debug("Unset segment list %s",
+ segment_list->name);
+ SET_FLAG(segment_list->flags,
+ F_SEGMENT_LIST_DELETED);
+ SET_FLAG(candidate->flags,
+ F_CANDIDATE_MODIFIED);
+ candidate->lsp->segment_list = NULL;
+ }
+ }
+ }
+}
+
+/**
+ * Gives a string representation of given protocol origin enum.
+ *
+ * @param origin The enum you want a string representation of
+ * @return The string representation of given enum
+ */
+const char *srte_origin2str(enum srte_protocol_origin origin)
+{
+ switch (origin) {
+ case SRTE_ORIGIN_PCEP:
+ return "PCEP";
+ case SRTE_ORIGIN_BGP:
+ return "BGP";
+ case SRTE_ORIGIN_LOCAL:
+ return "Local";
+ default:
+ return "Unknown";
+ }
+}
+
+void pathd_shutdown(void)
+{
+ path_ted_teardown();
+ srte_clean_zebra();
+ frr_fini();
+}
+
+void trigger_pathd_candidate_created(struct srte_candidate *candidate)
+{
+ /* The hook is called asynchronously to let the PCEP module
+ time to send a response to the PCE before receiving any updates from
+ pathd. In addition, a minimum amount of time need to pass before
+ the hook is called to prevent the hook to be called multiple times
+ from changing the candidate by hand with the console */
+ if (candidate->hook_timer != NULL)
+ return;
+ thread_add_timer(master, trigger_pathd_candidate_created_timer,
+ (void *)candidate, HOOK_DELAY, &candidate->hook_timer);
+}
+
+void trigger_pathd_candidate_created_timer(struct thread *thread)
+{
+ struct srte_candidate *candidate = THREAD_ARG(thread);
+ candidate->hook_timer = NULL;
+ hook_call(pathd_candidate_created, candidate);
+}
+
+void trigger_pathd_candidate_updated(struct srte_candidate *candidate)
+{
+ /* The hook is called asynchronously to let the PCEP module
+ time to send a response to the PCE before receiving any updates from
+ pathd. In addition, a minimum amount of time need to pass before
+ the hook is called to prevent the hook to be called multiple times
+ from changing the candidate by hand with the console */
+ if (candidate->hook_timer != NULL)
+ return;
+ thread_add_timer(master, trigger_pathd_candidate_updated_timer,
+ (void *)candidate, HOOK_DELAY, &candidate->hook_timer);
+}
+
+void trigger_pathd_candidate_updated_timer(struct thread *thread)
+{
+ struct srte_candidate *candidate = THREAD_ARG(thread);
+ candidate->hook_timer = NULL;
+ hook_call(pathd_candidate_updated, candidate);
+}
+
+void trigger_pathd_candidate_removed(struct srte_candidate *candidate)
+{
+ /* The hook needs to be call synchronously, otherwise the candidate
+ path will be already deleted when the handler is called */
+ if (candidate->hook_timer != NULL) {
+ thread_cancel(&candidate->hook_timer);
+ candidate->hook_timer = NULL;
+ }
+ hook_call(pathd_candidate_removed, candidate);
+}
+
+const char *srte_candidate_metric_name(enum srte_candidate_metric_type type)
+{
+ switch (type) {
+ case SRTE_CANDIDATE_METRIC_TYPE_IGP:
+ return "IGP";
+ case SRTE_CANDIDATE_METRIC_TYPE_TE:
+ return "TE";
+ case SRTE_CANDIDATE_METRIC_TYPE_HC:
+ return "HC";
+ case SRTE_CANDIDATE_METRIC_TYPE_ABC:
+ return "ABC";
+ case SRTE_CANDIDATE_METRIC_TYPE_LMLL:
+ return "LMLL";
+ case SRTE_CANDIDATE_METRIC_TYPE_CIGP:
+ return "CIGP";
+ case SRTE_CANDIDATE_METRIC_TYPE_CTE:
+ return "CTE";
+ case SRTE_CANDIDATE_METRIC_TYPE_PIGP:
+ return "PIGP";
+ case SRTE_CANDIDATE_METRIC_TYPE_PTE:
+ return "PTE";
+ case SRTE_CANDIDATE_METRIC_TYPE_PHC:
+ return "PHC";
+ case SRTE_CANDIDATE_METRIC_TYPE_MSD:
+ return "MSD";
+ case SRTE_CANDIDATE_METRIC_TYPE_PD:
+ return "PD";
+ case SRTE_CANDIDATE_METRIC_TYPE_PDV:
+ return "PDV";
+ case SRTE_CANDIDATE_METRIC_TYPE_PL:
+ return "PL";
+ case SRTE_CANDIDATE_METRIC_TYPE_PPD:
+ return "PPD";
+ case SRTE_CANDIDATE_METRIC_TYPE_PPDV:
+ return "PPDV";
+ case SRTE_CANDIDATE_METRIC_TYPE_PPL:
+ return "PPL";
+ case SRTE_CANDIDATE_METRIC_TYPE_NAP:
+ return "NAP";
+ case SRTE_CANDIDATE_METRIC_TYPE_NLP:
+ return "NLP";
+ case SRTE_CANDIDATE_METRIC_TYPE_DC:
+ return "DC";
+ case SRTE_CANDIDATE_METRIC_TYPE_BNC:
+ return "BNC";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+int32_t srte_ted_do_query_type_c(struct srte_segment_entry *entry,
+ struct prefix *prefix_cli, uint32_t algo)
+{
+ int32_t status = 0;
+ uint32_t ted_sid = MPLS_LABEL_NONE;
+
+ if (!entry || !prefix_cli)
+ return 0;
+
+ if (!path_ted_is_initialized())
+ return 0;
+
+ ted_sid = path_ted_query_type_c(prefix_cli, algo);
+ if (ted_sid == MPLS_LABEL_NONE) {
+ zlog_warn(" %s: PATHD-TED: SL: ERROR query C : ted-sid (%d)",
+ __func__, ted_sid);
+ } else {
+ zlog_debug("%s: PATHD-TED: SL: Success query C : ted-sid (%d)",
+ __func__, ted_sid);
+ }
+ if (CHECK_SID(entry->segment_list->protocol_origin, ted_sid,
+ entry->sid_value)) {
+ status = PATH_SID_ERROR;
+ } else
+ srte_segment_set_local_modification(entry->segment_list, entry,
+ ted_sid);
+ return status;
+}
+
+int32_t srte_ted_do_query_type_e(struct srte_segment_entry *entry,
+ struct prefix *prefix_cli,
+ uint32_t local_iface)
+{
+ int32_t status = 0;
+ uint32_t ted_sid = MPLS_LABEL_NONE;
+
+ if (!entry || !prefix_cli)
+ return 0;
+
+ if (!path_ted_is_initialized())
+ return 0;
+
+ ted_sid = path_ted_query_type_e(prefix_cli, local_iface);
+ if (ted_sid == MPLS_LABEL_NONE) {
+ zlog_warn(" %s: PATHD-TED: SL: ERROR query E : ted-sid (%d)",
+ __func__, ted_sid);
+ } else {
+ zlog_debug("%s: PATHD-TED: SL: Success query E : ted-sid (%d)",
+ __func__, ted_sid);
+ }
+ if (CHECK_SID(entry->segment_list->protocol_origin, ted_sid,
+ entry->sid_value)) {
+ status = PATH_SID_ERROR;
+ } else
+ srte_segment_set_local_modification(entry->segment_list, entry,
+ ted_sid);
+ return status;
+}
+
+int32_t srte_ted_do_query_type_f(struct srte_segment_entry *entry,
+ struct ipaddr *local, struct ipaddr *remote)
+{
+ int32_t status = 0;
+ uint32_t ted_sid = MPLS_LABEL_NONE;
+
+ if (!entry || !local || !remote)
+ return 0;
+
+ if (!path_ted_is_initialized())
+ return status;
+
+ ted_sid = path_ted_query_type_f(local, remote);
+ if (ted_sid == MPLS_LABEL_NONE) {
+ zlog_warn("%s:SL: ERROR query F : ted-sid (%d)", __func__,
+ ted_sid);
+ } else {
+ zlog_debug("%s:SL: Success query F : ted-sid (%d)", __func__,
+ ted_sid);
+ }
+ if (CHECK_SID(entry->segment_list->protocol_origin, ted_sid,
+ entry->sid_value)) {
+ status = PATH_SID_ERROR;
+ } else
+ srte_segment_set_local_modification(entry->segment_list, entry,
+ ted_sid);
+ return status;
+}
diff --git a/pathd/pathd.h b/pathd/pathd.h
new file mode 100644
index 0000000..81d7aa9
--- /dev/null
+++ b/pathd/pathd.h
@@ -0,0 +1,487 @@
+/*
+ * Copyright (C) 2020 NetDEF, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _FRR_PATHD_H_
+#define _FRR_PATHD_H_
+
+#include "lib/memory.h"
+#include "lib/mpls.h"
+#include "lib/ipaddr.h"
+#include "lib/srte.h"
+#include "lib/hook.h"
+#include "lib/prefix.h"
+
+#define PATH_SID_ERROR 1
+#define PATH_SID_NO_ERROR 0
+#define CHECK_SID(or, ts, es) \
+ ((or == SRTE_ORIGIN_PCEP && (ts == MPLS_LABEL_NONE || es != ts)) \
+ || (or == SRTE_ORIGIN_LOCAL && ts == MPLS_LABEL_NONE))
+
+DECLARE_MGROUP(PATHD);
+
+DECLARE_HOOK(pathd_srte_config_write, (struct vty *vty), (vty));
+
+enum srte_protocol_origin {
+ SRTE_ORIGIN_UNDEFINED = 0,
+ SRTE_ORIGIN_PCEP = 1,
+ SRTE_ORIGIN_BGP = 2,
+ SRTE_ORIGIN_LOCAL = 3,
+};
+
+enum srte_policy_status {
+ SRTE_POLICY_STATUS_UNKNOWN = 0,
+ SRTE_POLICY_STATUS_DOWN = 1,
+ SRTE_POLICY_STATUS_UP = 2,
+ SRTE_POLICY_STATUS_GOING_DOWN = 3,
+ SRTE_POLICY_STATUS_GOING_UP = 4
+};
+
+enum srte_candidate_type {
+ SRTE_CANDIDATE_TYPE_UNDEFINED = 0,
+ SRTE_CANDIDATE_TYPE_EXPLICIT = 1,
+ SRTE_CANDIDATE_TYPE_DYNAMIC = 2,
+};
+
+enum srte_candidate_metric_type {
+ /* IGP metric */
+ SRTE_CANDIDATE_METRIC_TYPE_IGP = 1,
+ /* TE metric */
+ SRTE_CANDIDATE_METRIC_TYPE_TE = 2,
+ /* Hop Counts */
+ SRTE_CANDIDATE_METRIC_TYPE_HC = 3,
+ /* Aggregate bandwidth consumption */
+ SRTE_CANDIDATE_METRIC_TYPE_ABC = 4,
+ /* Load of the most loaded link */
+ SRTE_CANDIDATE_METRIC_TYPE_LMLL = 5,
+ /* Cumulative IGP cost */
+ SRTE_CANDIDATE_METRIC_TYPE_CIGP = 6,
+ /* Cumulative TE cost */
+ SRTE_CANDIDATE_METRIC_TYPE_CTE = 7,
+ /* P2MP IGP metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PIGP = 8,
+ /* P2MP TE metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PTE = 9,
+ /* P2MP hop count metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PHC = 10,
+ /* Segment-ID (SID) Depth */
+ SRTE_CANDIDATE_METRIC_TYPE_MSD = 11,
+ /* Path Delay metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PD = 12,
+ /* Path Delay Variation metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PDV = 13,
+ /* Path Loss metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PL = 14,
+ /* P2MP Path Delay metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PPD = 15,
+ /* P2MP Path Delay variation metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PPDV = 16,
+ /* P2MP Path Loss metric */
+ SRTE_CANDIDATE_METRIC_TYPE_PPL = 17,
+ /* Number of adaptations on a path */
+ SRTE_CANDIDATE_METRIC_TYPE_NAP = 18,
+ /* Number of layers on a path */
+ SRTE_CANDIDATE_METRIC_TYPE_NLP = 19,
+ /* Domain Count metric */
+ SRTE_CANDIDATE_METRIC_TYPE_DC = 20,
+ /* Border Node Count metric */
+ SRTE_CANDIDATE_METRIC_TYPE_BNC = 21,
+};
+#define MAX_METRIC_TYPE 21
+
+enum srte_segment_nai_type {
+ SRTE_SEGMENT_NAI_TYPE_NONE = 0,
+ SRTE_SEGMENT_NAI_TYPE_IPV4_NODE = 1,
+ SRTE_SEGMENT_NAI_TYPE_IPV6_NODE = 2,
+ SRTE_SEGMENT_NAI_TYPE_IPV4_ADJACENCY = 3,
+ SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY = 4,
+ SRTE_SEGMENT_NAI_TYPE_IPV4_UNNUMBERED_ADJACENCY = 5,
+ SRTE_SEGMENT_NAI_TYPE_IPV6_ADJACENCY_LINK_LOCAL_ADDRESSES = 6,
+ SRTE_SEGMENT_NAI_TYPE_IPV4_LOCAL_IFACE = 7,
+ SRTE_SEGMENT_NAI_TYPE_IPV6_LOCAL_IFACE = 8,
+ SRTE_SEGMENT_NAI_TYPE_IPV4_ALGORITHM = 9,
+ SRTE_SEGMENT_NAI_TYPE_IPV6_ALGORITHM = 10
+};
+
+enum objfun_type {
+ OBJFUN_UNDEFINED = 0,
+ /* Minimum Cost Path [RFC5541] */
+ OBJFUN_MCP = 1,
+ /* Minimum Load Path [RFC5541] */
+ OBJFUN_MLP = 2,
+ /* Maximum residual Bandwidth Path [RFC5541] */
+ OBJFUN_MBP = 3,
+ /* Minimize aggregate Bandwidth Consumption [RFC5541] */
+ OBJFUN_MBC = 4,
+ /* Minimize the Load of the most loaded Link [RFC5541] */
+ OBJFUN_MLL = 5,
+ /* Minimize the Cumulative Cost of a set of paths [RFC5541] */
+ OBJFUN_MCC = 6,
+ /* Shortest Path Tree [RFC8306] */
+ OBJFUN_SPT = 7,
+ /* Minimum Cost Tree [RFC8306] */
+ OBJFUN_MCT = 8,
+ /* Minimum Packet Loss Path [RFC8233] */
+ OBJFUN_MPLP = 9,
+ /* Maximum Under-Utilized Path [RFC8233] */
+ OBJFUN_MUP = 10,
+ /* Maximum Reserved Under-Utilized Path [RFC8233] */
+ OBJFUN_MRUP = 11,
+ /* Minimize the number of Transit Domains [RFC8685] */
+ OBJFUN_MTD = 12,
+ /* Minimize the number of Border Nodes [RFC8685] */
+ OBJFUN_MBN = 13,
+ /* Minimize the number of Common Transit Domains [RFC8685] */
+ OBJFUN_MCTD = 14,
+ /* Minimize the number of Shared Links [RFC8800] */
+ OBJFUN_MSL = 15,
+ /* Minimize the number of Shared SRLGs [RFC8800] */
+ OBJFUN_MSS = 16,
+ /* Minimize the number of Shared Nodes [RFC8800] */
+ OBJFUN_MSN = 17,
+};
+#define MAX_OBJFUN_TYPE 17
+
+enum affinity_filter_type {
+ AFFINITY_FILTER_UNDEFINED = 0,
+ AFFINITY_FILTER_EXCLUDE_ANY = 1,
+ AFFINITY_FILTER_INCLUDE_ANY = 2,
+ AFFINITY_FILTER_INCLUDE_ALL = 3,
+};
+#define MAX_AFFINITY_FILTER_TYPE 3
+
+struct srte_segment_list;
+
+struct srte_segment_entry {
+ RB_ENTRY(srte_segment_entry) entry;
+
+ /* The segment list the entry belong to */
+ struct srte_segment_list *segment_list;
+
+ /* Index of the Label. */
+ uint32_t index;
+
+ /* Label Value. */
+ mpls_label_t sid_value;
+
+ /* NAI Type */
+ enum srte_segment_nai_type nai_type;
+ /* NAI local address when nai type is not NONE */
+ struct ipaddr nai_local_addr;
+ /* NAI local interface when nai type is not IPv4 unnumbered adjacency */
+ uint32_t nai_local_iface;
+ /* NAI local interface when nai type is IPv4 or IPv6 adjacency */
+ struct ipaddr nai_remote_addr;
+ /* NAI remote interface when nai type is not IPv4 unnumbered adjacency
+ */
+ uint32_t nai_remote_iface;
+ /* Support draft-ietf-spring-segment-routing-policy sl types queries*/
+ uint8_t nai_local_prefix_len;
+ uint8_t nai_algorithm;
+};
+RB_HEAD(srte_segment_entry_head, srte_segment_entry);
+RB_PROTOTYPE(srte_segment_entry_head, srte_segment_entry, entry,
+ srte_segment_entry_compare)
+
+struct srte_segment_list {
+ RB_ENTRY(srte_segment_list) entry;
+
+ /* Name of the Segment List. */
+ char name[64];
+
+ /* The Protocol-Origin. */
+ enum srte_protocol_origin protocol_origin;
+
+ /* The Originator */
+ char originator[64];
+
+ /* Nexthops. */
+ struct srte_segment_entry_head segments;
+
+ /* Status flags. */
+ uint16_t flags;
+#define F_SEGMENT_LIST_NEW 0x0002
+#define F_SEGMENT_LIST_MODIFIED 0x0004
+#define F_SEGMENT_LIST_DELETED 0x0008
+#define F_SEGMENT_LIST_SID_CONFLICT 0x0010
+};
+RB_HEAD(srte_segment_list_head, srte_segment_list);
+RB_PROTOTYPE(srte_segment_list_head, srte_segment_list, entry,
+ srte_segment_list_compare)
+
+struct srte_metric {
+ uint16_t flags;
+#define F_METRIC_IS_DEFINED 0x0001
+#define F_METRIC_IS_REQUIRED 0x0002
+#define F_METRIC_IS_BOUND 0x0004
+#define F_METRIC_IS_COMPUTED 0x0008
+ float value;
+};
+
+/* Runtime information about the candidate path */
+struct srte_lsp {
+ /* Backpointer to the Candidate Path. */
+ struct srte_candidate *candidate;
+
+ /* The associated Segment List. */
+ struct srte_segment_list *segment_list;
+
+ /* The Protocol-Origin. */
+ enum srte_protocol_origin protocol_origin;
+
+ /* The Originator */
+ char originator[64];
+
+ /* The Discriminator */
+ uint32_t discriminator;
+
+ /* Flags. */
+ uint32_t flags;
+
+ /* Metrics LSP Values */
+ struct srte_metric metrics[MAX_METRIC_TYPE];
+
+ /* Bandwidth Configured Value */
+ float bandwidth;
+
+ /* The objective function in used */
+ enum objfun_type objfun;
+};
+
+/* Configured candidate path */
+struct srte_candidate {
+ RB_ENTRY(srte_candidate) entry;
+
+ /* Backpointer to SR Policy */
+ struct srte_policy *policy;
+
+ /* The LSP associated with this candidate path. */
+ struct srte_lsp *lsp;
+
+ /* Administrative preference. */
+ uint32_t preference;
+
+ /* Symbolic Name. */
+ char name[64];
+
+ /* The associated Segment List. */
+ struct srte_segment_list *segment_list;
+
+ /* The Protocol-Origin. */
+ enum srte_protocol_origin protocol_origin;
+
+ /* The Originator */
+ char originator[64];
+
+ /* The Discriminator */
+ uint32_t discriminator;
+
+ /* The Type (explicit or dynamic) */
+ enum srte_candidate_type type;
+
+ /* Flags. */
+ uint32_t flags;
+#define F_CANDIDATE_BEST 0x0001
+#define F_CANDIDATE_NEW 0x0002
+#define F_CANDIDATE_MODIFIED 0x0004
+#define F_CANDIDATE_DELETED 0x0008
+#define F_CANDIDATE_HAS_BANDWIDTH 0x0100
+#define F_CANDIDATE_REQUIRED_BANDWIDTH 0x0200
+#define F_CANDIDATE_HAS_OBJFUN 0x0400
+#define F_CANDIDATE_REQUIRED_OBJFUN 0x0800
+#define F_CANDIDATE_HAS_EXCLUDE_ANY 0x1000
+#define F_CANDIDATE_HAS_INCLUDE_ANY 0x2000
+#define F_CANDIDATE_HAS_INCLUDE_ALL 0x4000
+
+ /* Metrics Configured Values */
+ struct srte_metric metrics[MAX_METRIC_TYPE];
+
+ /* Bandwidth Configured Value */
+ float bandwidth;
+
+ /* Configured objective functions */
+ enum objfun_type objfun;
+
+ /* Path constraints attribute filters */
+ uint32_t affinity_filters[MAX_AFFINITY_FILTER_TYPE];
+
+ /* Hooks delaying timer */
+ struct thread *hook_timer;
+};
+
+RB_HEAD(srte_candidate_head, srte_candidate);
+RB_PROTOTYPE(srte_candidate_head, srte_candidate, entry, srte_candidate_compare)
+
+struct srte_policy {
+ RB_ENTRY(srte_policy) entry;
+
+ /* Color */
+ uint32_t color;
+
+ /* Endpoint */
+ struct ipaddr endpoint;
+
+ /* Name */
+ char name[64];
+
+ /* Binding SID */
+ mpls_label_t binding_sid;
+
+ /* The Protocol-Origin. */
+ enum srte_protocol_origin protocol_origin;
+
+ /* The Originator */
+ char originator[64];
+
+ /* Operational Status of the policy */
+ enum srte_policy_status status;
+
+ /* Best candidate path. */
+ struct srte_candidate *best_candidate;
+
+ /* Candidate Paths */
+ struct srte_candidate_head candidate_paths;
+ /* Status flags. */
+ uint16_t flags;
+#define F_POLICY_NEW 0x0002
+#define F_POLICY_MODIFIED 0x0004
+#define F_POLICY_DELETED 0x0008
+ /* SRP id for PcInitiated support */
+ int srp_id;
+};
+RB_HEAD(srte_policy_head, srte_policy);
+RB_PROTOTYPE(srte_policy_head, srte_policy, entry, srte_policy_compare)
+
+DECLARE_HOOK(pathd_candidate_created, (struct srte_candidate * candidate),
+ (candidate));
+DECLARE_HOOK(pathd_candidate_updated, (struct srte_candidate * candidate),
+ (candidate));
+DECLARE_HOOK(pathd_candidate_removed, (struct srte_candidate * candidate),
+ (candidate));
+
+extern struct srte_segment_list_head srte_segment_lists;
+extern struct srte_policy_head srte_policies;
+extern struct zebra_privs_t pathd_privs;
+
+/* master thread, defined in path_main.c */
+extern struct thread_master *master;
+
+/* pathd.c */
+struct srte_segment_list *srte_segment_list_add(const char *name);
+void srte_segment_list_del(struct srte_segment_list *segment_list);
+struct srte_segment_list *srte_segment_list_find(const char *name);
+struct srte_segment_entry *
+srte_segment_entry_add(struct srte_segment_list *segment_list, uint32_t index);
+void srte_segment_entry_del(struct srte_segment_entry *segment);
+int srte_segment_entry_set_nai(struct srte_segment_entry *segment,
+ enum srte_segment_nai_type type,
+ struct ipaddr *local_ip, uint32_t local_iface,
+ struct ipaddr *remote_ip, uint32_t remote_iface,
+ uint8_t algo, uint8_t pref_len);
+void srte_segment_set_local_modification(struct srte_segment_list *s_list,
+ struct srte_segment_entry *s_entry,
+ uint32_t ted_sid);
+struct srte_policy *srte_policy_add(uint32_t color, struct ipaddr *endpoint,
+ enum srte_protocol_origin origin,
+ const char *originator);
+void srte_policy_del(struct srte_policy *policy);
+struct srte_policy *srte_policy_find(uint32_t color, struct ipaddr *endpoint);
+int srte_policy_update_ted_sid(void);
+void srte_policy_update_binding_sid(struct srte_policy *policy,
+ uint32_t binding_sid);
+void srte_apply_changes(void);
+void srte_clean_zebra(void);
+void srte_policy_apply_changes(struct srte_policy *policy);
+struct srte_candidate *srte_candidate_add(struct srte_policy *policy,
+ uint32_t preference,
+ enum srte_protocol_origin origin,
+ const char *originator);
+void srte_candidate_del(struct srte_candidate *candidate);
+void srte_candidate_set_bandwidth(struct srte_candidate *candidate,
+ float bandwidth, bool required);
+void srte_candidate_unset_bandwidth(struct srte_candidate *candidate);
+void srte_candidate_set_metric(struct srte_candidate *candidate,
+ enum srte_candidate_metric_type type,
+ float value, bool required, bool is_cound,
+ bool is_computed);
+void srte_candidate_unset_metric(struct srte_candidate *candidate,
+ enum srte_candidate_metric_type type);
+void srte_candidate_set_objfun(struct srte_candidate *candidate, bool required,
+ enum objfun_type type);
+void srte_candidate_unset_objfun(struct srte_candidate *candidate);
+void srte_candidate_set_affinity_filter(struct srte_candidate *candidate,
+ enum affinity_filter_type type,
+ uint32_t filter);
+void srte_candidate_unset_affinity_filter(struct srte_candidate *candidate,
+ enum affinity_filter_type type);
+void srte_lsp_set_bandwidth(struct srte_lsp *lsp, float bandwidth,
+ bool required);
+void srte_lsp_unset_bandwidth(struct srte_lsp *lsp);
+void srte_lsp_set_metric(struct srte_lsp *lsp,
+ enum srte_candidate_metric_type type, float value,
+ bool required, bool is_cound, bool is_computed);
+void srte_lsp_unset_metric(struct srte_lsp *lsp,
+ enum srte_candidate_metric_type type);
+struct srte_candidate *srte_candidate_find(struct srte_policy *policy,
+ uint32_t preference);
+struct srte_segment_entry *
+srte_segment_entry_find(struct srte_segment_list *segment_list, uint32_t index);
+void srte_candidate_status_update(struct srte_candidate *candidate, int status);
+void srte_candidate_unset_segment_list(const char *originator, bool force);
+const char *srte_origin2str(enum srte_protocol_origin origin);
+void pathd_shutdown(void);
+
+/* path_cli.c */
+void path_cli_init(void);
+
+
+/**
+ * Search for sid based in prefix and algorithm
+ *
+ * @param Prefix The prefix to use
+ * @param algo Algorithm we want to query for
+ * @param ted_sid Sid to query
+ *
+ * @return void
+ */
+int32_t srte_ted_do_query_type_c(struct srte_segment_entry *entry,
+ struct prefix *prefix_cli, uint32_t algo);
+
+/**
+ * Search for sid based in prefix and interface id
+ *
+ * @param Prefix The prefix to use
+ * @param local_iface The id of interface
+ * @param ted_sid Sid to query
+ *
+ * @return void
+ */
+int32_t srte_ted_do_query_type_e(struct srte_segment_entry *entry,
+ struct prefix *prefix_cli,
+ uint32_t local_iface);
+/**
+ * Search for sid based in local and remote ip
+ *
+ * @param entry entry to update
+ * @param local Local addr for query
+ * @param remote Local addr for query
+ *
+ * @return void
+ */
+int32_t srte_ted_do_query_type_f(struct srte_segment_entry *entry,
+ struct ipaddr *local, struct ipaddr *remote);
+#endif /* _FRR_PATHD_H_ */
diff --git a/pathd/subdir.am b/pathd/subdir.am
new file mode 100644
index 0000000..f339c79
--- /dev/null
+++ b/pathd/subdir.am
@@ -0,0 +1,85 @@
+#
+# pathd
+#
+
+if PATHD
+noinst_LIBRARIES += pathd/libpath.a
+sbin_PROGRAMS += pathd/pathd
+vtysh_scan += \
+ pathd/path_cli.c \
+ pathd/path_ted.c \
+ #end
+vtysh_daemons += pathd
+# TODO add man page
+#man8 += $(MANBUILD)/pathd.8
+
+if PATHD_PCEP
+vtysh_scan += pathd/path_pcep_cli.c
+module_LTLIBRARIES += pathd/pathd_pcep.la
+endif
+
+endif
+
+pathd_libpath_a_SOURCES = \
+ pathd/path_cli.c \
+ pathd/path_debug.c \
+ pathd/path_errors.c \
+ pathd/path_nb.c \
+ pathd/path_nb_config.c \
+ pathd/path_nb_state.c \
+ pathd/path_ted.c \
+ pathd/path_zebra.c \
+ pathd/pathd.c \
+ # end
+
+clippy_scan += \
+ pathd/path_cli.c \
+ pathd/path_pcep_cli.c \
+ pathd/path_ted.c \
+ # end
+
+noinst_HEADERS += \
+ pathd/path_debug.h \
+ pathd/path_errors.h \
+ pathd/path_nb.h \
+ pathd/path_pcep.h \
+ pathd/path_pcep_cli.h \
+ pathd/path_pcep_controller.h \
+ pathd/path_pcep_debug.h \
+ pathd/path_pcep_lib.h \
+ pathd/path_pcep_config.h \
+ pathd/path_pcep_pcc.h \
+ pathd/path_ted.h \
+ pathd/path_zebra.h \
+ pathd/pathd.h \
+ # end
+
+pathd_pathd_SOURCES = \
+ pathd/path_main.c \
+ # end
+nodist_pathd_pathd_SOURCES = \
+ yang/frr-pathd.yang.c \
+ # end
+pathd_pathd_LDADD = pathd/libpath.a lib/libfrr.la -lm $(LIBCAP)
+
+pathd_pathd_pcep_la_SOURCES = \
+ pathd/path_pcep.c \
+ pathd/path_pcep_cli.c \
+ pathd/path_pcep_controller.c \
+ pathd/path_pcep_debug.c \
+ pathd/path_pcep_lib.c \
+ pathd/path_pcep_config.c \
+ pathd/path_pcep_pcc.c \
+ # end
+
+if PATHD_PCEP
+pathd_pathd_pcep_la_CPPFLAGS = -I./pceplib $(AM_CPPFLAGS)
+pathd_pathd_pcep_la_LIBADD = pceplib/libpcep_pcc.la
+else
+pathd_pathd_pcep_la_CPPFLAGS = $(AM_CPPFLAGS)
+pathd_pathd_pcep_la_LIBADD =
+endif
+
+
+#pathd_pathd_pcep_la_CFLAGS = $(AM_CFLAGS)
+pathd_pathd_pcep_la_LDFLAGS = $(MODULE_LDFLAGS)