1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* STATICd - Segment Routing over IPv6 (SRv6) code
* Copyright (C) 2025 Alibaba Inc.
* Yuqing Zhao
* Lingyu Zhang
*/
#include <zebra.h>
#include "vrf.h"
#include "nexthop.h"
#include "static_routes.h"
#include "static_srv6.h"
#include "static_vrf.h"
#include "static_zebra.h"
/*
* List of SRv6 SIDs.
*/
struct list *srv6_locators;
struct list *srv6_sids;
DEFINE_MTYPE_STATIC(STATIC, STATIC_SRV6_LOCATOR, "Static SRv6 locator");
DEFINE_MTYPE_STATIC(STATIC, STATIC_SRV6_SID, "Static SRv6 SID");
/*
* Allocate an SRv6 SID object and initialize the fields common to all the
* behaviors (i.e., SID address and behavor).
*/
struct static_srv6_sid *static_srv6_sid_alloc(struct prefix_ipv6 *addr)
{
struct static_srv6_sid *sid = NULL;
sid = XCALLOC(MTYPE_STATIC_SRV6_SID, sizeof(struct static_srv6_sid));
sid->addr = *addr;
return sid;
}
void static_srv6_sid_free(struct static_srv6_sid *sid)
{
XFREE(MTYPE_STATIC_SRV6_SID, sid);
}
struct static_srv6_locator *static_srv6_locator_lookup(const char *name)
{
struct static_srv6_locator *locator;
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(srv6_locators, node, locator))
if (!strncmp(name, locator->name, SRV6_LOCNAME_SIZE))
return locator;
return NULL;
}
/*
* Look-up an SRv6 SID in the list of SRv6 SIDs.
*/
struct static_srv6_sid *static_srv6_sid_lookup(struct prefix_ipv6 *sid_addr)
{
struct static_srv6_sid *sid;
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(srv6_sids, node, sid))
if (memcmp(&sid->addr, sid_addr, sizeof(struct prefix_ipv6)) == 0)
return sid;
return NULL;
}
struct static_srv6_locator *static_srv6_locator_alloc(const char *name)
{
struct static_srv6_locator *locator = NULL;
locator = XCALLOC(MTYPE_STATIC_SRV6_LOCATOR, sizeof(struct static_srv6_locator));
strlcpy(locator->name, name, sizeof(locator->name));
return locator;
}
void static_srv6_locator_free(struct static_srv6_locator *locator)
{
XFREE(MTYPE_STATIC_SRV6_LOCATOR, locator);
}
void delete_static_srv6_locator(void *val)
{
static_srv6_locator_free((struct static_srv6_locator *)val);
}
/*
* Remove an SRv6 SID from the zebra RIB (if it was previously installed) and
* release the memory previously allocated for the SID.
*/
void static_srv6_sid_del(struct static_srv6_sid *sid)
{
if (CHECK_FLAG(sid->flags, STATIC_FLAG_SRV6_SID_VALID)) {
static_zebra_release_srv6_sid(sid);
UNSET_FLAG(sid->flags, STATIC_FLAG_SRV6_SID_VALID);
}
if (CHECK_FLAG(sid->flags, STATIC_FLAG_SRV6_SID_SENT_TO_ZEBRA)) {
static_zebra_srv6_sid_uninstall(sid);
UNSET_FLAG(sid->flags, STATIC_FLAG_SRV6_SID_SENT_TO_ZEBRA);
}
XFREE(MTYPE_STATIC_SRV6_SID, sid);
}
void delete_static_srv6_sid(void *val)
{
static_srv6_sid_free((struct static_srv6_sid *)val);
}
/*
* Initialize SRv6 data structures.
*/
void static_srv6_init(void)
{
srv6_locators = list_new();
srv6_locators->del = delete_static_srv6_locator;
srv6_sids = list_new();
srv6_sids->del = delete_static_srv6_sid;
}
/*
* Clean up all the SRv6 data structures.
*/
void static_srv6_cleanup(void)
{
list_delete(&srv6_locators);
list_delete(&srv6_sids);
}
|
