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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/* Zebra Policy Based Routing (PBR) main handling.
* Copyright (C) 2018 Cumulus Networks, Inc.
*
* This file is part of FRR.
*
* FRR 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, or (at your option) any
* later version.
*
* FRR 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 FRR; see the file COPYING. If not, write to the Free
* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include <zebra.h>
#include <jhash.h>
#include <hash.h>
#include "zebra/zebra_pbr.h"
#include "zebra/rt.h"
/* definitions */
/* static function declarations */
/* Private functions */
/* Public functions */
void zebra_pbr_rules_free(void *arg)
{
struct zebra_pbr_rule *rule;
rule = (struct zebra_pbr_rule *)arg;
kernel_del_pbr_rule(rule);
XFREE(MTYPE_TMP, rule);
}
uint32_t zebra_pbr_rules_hash_key(void *arg)
{
struct zebra_pbr_rule *rule;
uint32_t key;
rule = (struct zebra_pbr_rule *)arg;
key = jhash_3words(rule->seq, rule->priority, rule->action.table,
prefix_hash_key(&rule->filter.src_ip));
if (rule->ifp)
key = jhash_1word(rule->ifp->ifindex, key);
else
key = jhash_1word(0, key);
return jhash_3words(rule->filter.src_port, rule->filter.dst_port,
prefix_hash_key(&rule->filter.dst_ip),
jhash_1word(rule->unique, key));
}
int zebra_pbr_rules_hash_equal(const void *arg1, const void *arg2)
{
const struct zebra_pbr_rule *r1, *r2;
r1 = (const struct zebra_pbr_rule *)arg1;
r2 = (const struct zebra_pbr_rule *)arg2;
if (r1->seq != r2->seq)
return 0;
if (r1->priority != r2->priority)
return 0;
if (r1->unique != r2->unique)
return 0;
if (r1->action.table != r2->action.table)
return 0;
if (r1->filter.src_port != r2->filter.src_port)
return 0;
if (r1->filter.dst_port != r2->filter.dst_port)
return 0;
if (!prefix_same(&r1->filter.src_ip, &r2->filter.src_ip))
return 0;
if (!prefix_same(&r1->filter.dst_ip, &r2->filter.dst_ip))
return 0;
if (r1->ifp != r2->ifp)
return 0;
return 1;
}
struct pbr_unique_lookup {
struct zebra_pbr_rule *rule;
uint32_t unique;
};
static int pbr_rule_lookup_unique_walker(struct hash_backet *b, void *data)
{
struct pbr_unique_lookup *pul = data;
struct zebra_pbr_rule *rule = b->data;
if (pul->unique == rule->unique) {
pul->rule = rule;
return HASHWALK_ABORT;
}
return HASHWALK_CONTINUE;
}
static struct zebra_pbr_rule *pbr_rule_lookup_unique(struct zebra_ns *zns,
uint32_t unique)
{
struct pbr_unique_lookup pul;
pul.unique = unique;
pul.rule = NULL;
hash_walk(zns->rules_hash, &pbr_rule_lookup_unique_walker, &pul);
return pul.rule;
}
static void *pbr_rule_alloc_intern(void *arg)
{
struct zebra_pbr_rule *zpr;
struct zebra_pbr_rule *new;
zpr = (struct zebra_pbr_rule *)arg;
new = XCALLOC(MTYPE_TMP, sizeof(*new));
memcpy(new, zpr, sizeof(*zpr));
return new;
}
void zebra_pbr_add_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule)
{
struct zebra_pbr_rule *unique =
pbr_rule_lookup_unique(zns, rule->unique);
(void)hash_get(zns->rules_hash, rule, pbr_rule_alloc_intern);
kernel_add_pbr_rule(rule);
/*
* Rule Replace semantics, if we have an old, install the
* new rule, look above, and then delete the old
*/
if (unique)
zebra_pbr_del_rule(zns, unique);
}
void zebra_pbr_del_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule)
{
struct zebra_pbr_rule *lookup;
lookup = hash_lookup(zns->rules_hash, rule);
kernel_del_pbr_rule(rule);
if (lookup) {
hash_release(zns->rules_hash, lookup);
XFREE(MTYPE_TMP, lookup);
} else
zlog_warn("%s: Rule being deleted we know nothing about",
__PRETTY_FUNCTION__);
}
static void zebra_pbr_cleanup_rules(struct hash_backet *b, void *data)
{
struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT);
struct zebra_pbr_rule *rule = b->data;
int *sock = data;
if (rule->sock == *sock) {
kernel_del_pbr_rule(rule);
hash_release(zns->rules_hash, rule);
XFREE(MTYPE_TMP, rule);
}
}
void zebra_pbr_client_close_cleanup(int sock)
{
struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT);
hash_iterate(zns->rules_hash, zebra_pbr_cleanup_rules, &sock);
}
/*
* Handle success or failure of rule (un)install in the kernel.
*/
void kernel_pbr_rule_add_del_status(struct zebra_pbr_rule *rule,
enum southbound_results res)
{
switch (res) {
case SOUTHBOUND_INSTALL_SUCCESS:
zsend_rule_notify_owner(rule, ZAPI_RULE_INSTALLED);
break;
case SOUTHBOUND_INSTALL_FAILURE:
zsend_rule_notify_owner(rule, ZAPI_RULE_FAIL_INSTALL);
break;
case SOUTHBOUND_DELETE_SUCCESS:
break;
case SOUTHBOUND_DELETE_FAILURE:
break;
}
}
/*
* Handle rule delete notification from kernel.
*/
int kernel_pbr_rule_del(struct zebra_pbr_rule *rule)
{
return 0;
}
|
