--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*********************************************************************
+ * Copyright 2022 Hiroki Shirokura, LINE Corporation
+ * Copyright 2022 Masakazu Asama
+ * Copyright 2022 6WIND S.A.
+ *
+ * flex_algo.c: Flexible Algorithm library
+ *
+ * Authors
+ * -------
+ * Hiroki Shirokura
+ * Masakazu Asama
+ * Louis Scalbert
+ */
+
+#include "zebra.h"
+
+#include "flex_algo.h"
+
+DEFINE_MTYPE_STATIC(LIB, FLEX_ALGO, "Flex-Algo Definition");
+
+struct flex_algos *flex_algos_alloc(flex_algo_allocator_t allocator,
+ flex_algo_releaser_t releaser)
+{
+ struct flex_algos *flex_algos;
+
+ flex_algos = XCALLOC(MTYPE_FLEX_ALGO, sizeof(*flex_algos));
+ flex_algos->flex_algos = list_new();
+ flex_algos->allocator = allocator;
+ flex_algos->releaser = releaser;
+ return flex_algos;
+}
+
+struct flex_algo *flex_algo_alloc(struct flex_algos *flex_algos,
+ uint8_t algorithm, void *arg)
+{
+ struct flex_algo *fa;
+
+ fa = XCALLOC(MTYPE_FLEX_ALGO, sizeof(*fa));
+ fa->algorithm = algorithm;
+ if (flex_algos->allocator)
+ fa->data = flex_algos->allocator(arg);
+ admin_group_init(&fa->admin_group_exclude_any);
+ admin_group_init(&fa->admin_group_include_any);
+ admin_group_init(&fa->admin_group_include_all);
+ listnode_add(flex_algos->flex_algos, fa);
+ return fa;
+}
+
+/**
+ * @brief Look up the local flex-algo object by its algorithm number.
+ * @param algorithm flex-algo algorithm number
+ * @param area area pointer of flex-algo
+ * @return local flex-algo object if exist, else NULL
+ */
+struct flex_algo *flex_algo_lookup(struct flex_algos *flex_algos,
+ uint8_t algorithm)
+{
+ struct listnode *node;
+ struct flex_algo *fa;
+
+ for (ALL_LIST_ELEMENTS_RO(flex_algos->flex_algos, node, fa))
+ if (fa->algorithm == algorithm)
+ return fa;
+ return NULL;
+}
+
+/**
+ * @brief Compare two Flex-Algo Definitions (FAD)
+ * @param Flex algo 1
+ * @param Flex algo 2
+ * @return true if the definition is equal, else false
+ */
+bool flex_algo_definition_cmp(struct flex_algo *fa1, struct flex_algo *fa2)
+{
+ if (fa1->algorithm != fa2->algorithm)
+ return false;
+ if (fa1->calc_type != fa2->calc_type)
+ return false;
+ if (fa1->metric_type != fa2->metric_type)
+ return false;
+
+ if (!admin_group_cmp(&fa1->admin_group_exclude_any,
+ &fa2->admin_group_exclude_any))
+ return false;
+ if (!admin_group_cmp(&fa1->admin_group_include_all,
+ &fa2->admin_group_include_all))
+ return false;
+ if (!admin_group_cmp(&fa1->admin_group_include_any,
+ &fa2->admin_group_include_any))
+ return false;
+
+ return true;
+}
+
+void flex_algo_delete(struct flex_algos *flex_algos, uint8_t algorithm)
+{
+ struct listnode *node, *nnode;
+ struct flex_algo *fa;
+
+ for (ALL_LIST_ELEMENTS(flex_algos->flex_algos, node, nnode, fa)) {
+ if (fa->algorithm != algorithm)
+ continue;
+ if (flex_algos->releaser)
+ flex_algos->releaser(fa->data);
+ admin_group_term(&fa->admin_group_exclude_any);
+ admin_group_term(&fa->admin_group_include_any);
+ admin_group_term(&fa->admin_group_include_all);
+ listnode_delete(flex_algos->flex_algos, fa);
+ XFREE(MTYPE_FLEX_ALGO, fa);
+ return;
+ }
+}
+
+/**
+ * Check SR Algorithm is Flex-Algo
+ * according to RFC9350 section 4
+ *
+ * @param algorithm SR Algorithm
+ */
+bool flex_algo_id_valid(uint16_t algorithm)
+{
+ return algorithm >= SR_ALGORITHM_FLEX_MIN &&
+ algorithm <= SR_ALGORITHM_FLEX_MAX;
+}
+
+char *flex_algo_metric_type_print(char *type_str, size_t sz,
+ enum flex_algo_metric_type metric_type)
+{
+ switch (metric_type) {
+ case MT_IGP:
+ snprintf(type_str, sz, "igp");
+ break;
+ case MT_MIN_UNI_LINK_DELAY:
+ snprintf(type_str, sz, "delay");
+ break;
+ case MT_TE_DEFAULT:
+ snprintf(type_str, sz, "te");
+ break;
+ }
+ return type_str;
+}
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*********************************************************************
+ * Copyright 2022 Hiroki Shirokura, LINE Corporation
+ * Copyright 2022 Masakazu Asama
+ * Copyright 2022 6WIND S.A.
+ *
+ * flex_algo.h: Flexible Algorithm library
+ *
+ * Authors
+ * -------
+ * Hiroki Shirokura
+ * Masakazu Asama
+ * Louis Scalbert
+ */
+
+#ifndef _FRR_FLEX_ALGO_H
+#define _FRR_FLEX_ALGO_H
+
+#include "admin_group.h"
+#include "linklist.h"
+#include "prefix.h"
+#include "segment_routing.h"
+
+#define FLEX_ALGO_PRIO_DEFAULT 128
+
+#define CALC_TYPE_SPF 0
+
+/* flex-algo definition flags */
+
+/* M-flag (aka. prefix-metric)
+ * Flex-Algorithm specific prefix and ASBR metric MUST be used
+ */
+#define FAD_FLAG_M 0x80
+
+/*
+ * Metric Type values from RFC9350 section 5.1
+ */
+enum flex_algo_metric_type {
+ MT_IGP = 0,
+ MT_MIN_UNI_LINK_DELAY = 1,
+ MT_TE_DEFAULT = 2,
+};
+
+
+/* Flex-Algo data about a given algorithm.
+ * It includes the definition and some local data.
+ */
+struct flex_algo {
+ /* Flex-Algo definition */
+ uint8_t algorithm;
+ enum flex_algo_metric_type metric_type;
+ uint8_t calc_type;
+ uint8_t priority;
+ uint8_t flags;
+
+ /* extended admin-groups */
+ struct admin_group admin_group_exclude_any;
+ struct admin_group admin_group_include_any;
+ struct admin_group admin_group_include_all;
+
+ /* Exclude SRLG Sub-TLV is not yet supported by IS-IS
+ * True if a Exclude SRLG Sub-TLV has been found
+ */
+ bool exclude_srlg;
+
+ /* True if an unsupported sub-TLV other Exclude SRLG
+ * has been received.
+ * A router that receives an unsupported definition
+ * that is elected must not participate in the algorithm.
+ * This boolean prevents future sub-TLV from being considered
+ * as supported.
+ */
+ bool unsupported_subtlv;
+
+ /* Flex-Algo local data */
+
+ /* True if the local definition must be advertised */
+ bool advertise_definition;
+
+ /* which dataplane must be used for the algorithm */
+#define FLEX_ALGO_SR_MPLS 0x01
+#define FLEX_ALGO_SRV6 0x02
+#define FLEX_ALGO_IP 0x04
+ uint8_t dataplanes;
+
+ /*
+ * This property can be freely extended among different routing
+ * protocols. Since Flex-Algo is an IGP protocol agnostic, both IS-IS
+ * and OSPF can implement Flex-Algo. The struct flex_algo thus provides
+ * the general data structure of Flex-Algo, and the value of extending
+ * it with the IGP protocol is provided by this property.
+ */
+ void *data;
+};
+
+typedef void *(*flex_algo_allocator_t)(void *);
+typedef void (*flex_algo_releaser_t)(void *);
+
+struct flex_algos {
+ flex_algo_allocator_t allocator;
+ flex_algo_releaser_t releaser;
+ struct list *flex_algos;
+};
+
+/*
+ * Flex-Algo Utilities
+ */
+struct flex_algos *flex_algos_alloc(flex_algo_allocator_t allocator,
+ flex_algo_releaser_t releaser);
+struct flex_algo *flex_algo_alloc(struct flex_algos *flex_algos,
+ uint8_t algorithm, void *arg);
+struct flex_algo *flex_algo_lookup(struct flex_algos *flex_algos,
+ uint8_t algorithm);
+void flex_algos_free(struct flex_algos *flex_algos);
+bool flex_algo_definition_cmp(struct flex_algo *fa1, struct flex_algo *fa2);
+void flex_algo_delete(struct flex_algos *flex_algos, uint8_t algorithm);
+bool flex_algo_id_valid(uint16_t algorithm);
+char *flex_algo_metric_type_print(char *type_str, size_t sz,
+ enum flex_algo_metric_type metric_type);
+
+#endif /* _FRR_FLEX_ALGO_H */
projects / matthieu / frr.git / commitdiff