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
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
|
/*
* Routing Information Base header
* Copyright (C) 1997 Kunihiro Ishiguro
*
* This file is part of GNU Zebra.
*
* GNU Zebra 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.
*
* GNU Zebra 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 _ZEBRA_RIB_H
#define _ZEBRA_RIB_H
#include "zebra.h"
#include "hook.h"
#include "linklist.h"
#include "prefix.h"
#include "table.h"
#include "queue.h"
#include "nexthop.h"
#include "vrf.h"
#include "if.h"
#include "mpls.h"
#include "srcdest_table.h"
#define DISTANCE_INFINITY 255
#define ZEBRA_KERNEL_TABLE_MAX 252 /* support for no more than this rt tables */
struct route_entry {
/* Link list. */
struct route_entry *next;
struct route_entry *prev;
/* Nexthop structure */
struct nexthop *nexthop;
/* Tag */
route_tag_t tag;
/* Uptime. */
time_t uptime;
/* Type fo this route. */
int type;
/* Source protocol instance */
u_short instance;
/* VRF identifier. */
vrf_id_t vrf_id;
/* Which routing table */
uint32_t table;
/* Metric */
u_int32_t metric;
/* MTU */
u_int32_t mtu;
u_int32_t nexthop_mtu;
/* Distance. */
uint8_t distance;
/* Flags of this route.
* This flag's definition is in lib/zebra.h ZEBRA_FLAG_* and is exposed
* to clients via Zserv
*/
u_int32_t flags;
/* RIB internal status */
u_char status;
#define ROUTE_ENTRY_REMOVED 0x1
/* to simplify NHT logic when NHs change, instead of doing a NH by NH cmp */
#define ROUTE_ENTRY_NEXTHOPS_CHANGED 0x2
#define ROUTE_ENTRY_CHANGED 0x4
#define ROUTE_ENTRY_LABELS_CHANGED 0x8
/* Nexthop information. */
u_char nexthop_num;
u_char nexthop_active_num;
};
/* meta-queue structure:
* sub-queue 0: connected, kernel
* sub-queue 1: static
* sub-queue 2: RIP, RIPng, OSPF, OSPF6, IS-IS, EIGRP, NHRP
* sub-queue 3: iBGP, eBGP
* sub-queue 4: any other origin (if any)
*/
#define MQ_SIZE 5
struct meta_queue {
struct list *subq[MQ_SIZE];
u_int32_t size; /* sum of lengths of all subqueues */
};
/*
* Structure that represents a single destination (prefix).
*/
typedef struct rib_dest_t_ {
/*
* Back pointer to the route node for this destination. This helps
* us get to the prefix that this structure is for.
*/
struct route_node *rnode;
/*
* Doubly-linked list of routes for this prefix.
*/
struct route_entry *routes;
struct route_entry *selected_fib;
/*
* Flags, see below.
*/
u_int32_t flags;
/*
* Linkage to put dest on the FPM processing queue.
*/
TAILQ_ENTRY(rib_dest_t_) fpm_q_entries;
} rib_dest_t;
#define RIB_ROUTE_QUEUED(x) (1 << (x))
// If MQ_SIZE is modified this value needs to be updated.
#define RIB_ROUTE_ANY_QUEUED 0x1F
/*
* The maximum qindex that can be used.
*/
#define ZEBRA_MAX_QINDEX (MQ_SIZE - 1)
/*
* This flag indicates that a given prefix has been 'advertised' to
* the FPM to be installed in the forwarding plane.
*/
#define RIB_DEST_SENT_TO_FPM (1 << (ZEBRA_MAX_QINDEX + 1))
/*
* This flag is set when we need to send an update to the FPM about a
* dest.
*/
#define RIB_DEST_UPDATE_FPM (1 << (ZEBRA_MAX_QINDEX + 2))
/*
* Macro to iterate over each route for a destination (prefix).
*/
#define RE_DEST_FOREACH_ROUTE(dest, re) \
for ((re) = (dest) ? (dest)->routes : NULL; (re); (re) = (re)->next)
/*
* Same as above, but allows the current node to be unlinked.
*/
#define RE_DEST_FOREACH_ROUTE_SAFE(dest, re, next) \
for ((re) = (dest) ? (dest)->routes : NULL; \
(re) && ((next) = (re)->next, 1); (re) = (next))
#define RNODE_FOREACH_RE(rn, re) \
RE_DEST_FOREACH_ROUTE(rib_dest_from_rnode(rn), re)
#define RNODE_FOREACH_RE_SAFE(rn, re, next) \
RE_DEST_FOREACH_ROUTE_SAFE(rib_dest_from_rnode(rn), re, next)
#if defined(HAVE_RTADV)
/* Structure which hold status of router advertisement. */
struct rtadv {
int sock;
int adv_if_count;
int adv_msec_if_count;
struct thread *ra_read;
struct thread *ra_timer;
};
#endif /* HAVE_RTADV */
/*
* rib_table_info_t
*
* Structure that is hung off of a route_table that holds information about
* the table.
*/
typedef struct rib_table_info_t_ {
/*
* Back pointer to zebra_vrf.
*/
struct zebra_vrf *zvrf;
afi_t afi;
safi_t safi;
} rib_table_info_t;
typedef enum {
RIB_TABLES_ITER_S_INIT,
RIB_TABLES_ITER_S_ITERATING,
RIB_TABLES_ITER_S_DONE
} rib_tables_iter_state_t;
/*
* Structure that holds state for iterating over all tables in the
* Routing Information Base.
*/
typedef struct rib_tables_iter_t_ {
vrf_id_t vrf_id;
int afi_safi_ix;
rib_tables_iter_state_t state;
} rib_tables_iter_t;
/* Events/reasons triggering a RIB update. */
typedef enum {
RIB_UPDATE_IF_CHANGE,
RIB_UPDATE_RMAP_CHANGE,
RIB_UPDATE_OTHER
} rib_update_event_t;
extern struct nexthop *route_entry_nexthop_ifindex_add(struct route_entry *,
ifindex_t);
extern struct nexthop *route_entry_nexthop_blackhole_add(struct route_entry *,
enum blackhole_type);
extern struct nexthop *route_entry_nexthop_ipv4_add(struct route_entry *,
struct in_addr *,
struct in_addr *);
extern struct nexthop *
route_entry_nexthop_ipv4_ifindex_add(struct route_entry *, struct in_addr *,
struct in_addr *, ifindex_t);
extern void route_entry_nexthop_delete(struct route_entry *re,
struct nexthop *nexthop);
extern struct nexthop *route_entry_nexthop_ipv6_add(struct route_entry *,
struct in6_addr *);
extern struct nexthop *
route_entry_nexthop_ipv6_ifindex_add(struct route_entry *re,
struct in6_addr *ipv6, ifindex_t ifindex);
extern void route_entry_nexthop_add(struct route_entry *re,
struct nexthop *nexthop);
extern void route_entry_copy_nexthops(struct route_entry *re,
struct nexthop *nh);
#define route_entry_dump(prefix, src, re) _route_entry_dump(__func__, prefix, src, re)
extern void _route_entry_dump(const char *, union prefixconstptr,
union prefixconstptr, const struct route_entry *);
/* RPF lookup behaviour */
enum multicast_mode {
MCAST_NO_CONFIG = 0, /* MIX_MRIB_FIRST, but no show in config write */
MCAST_MRIB_ONLY, /* MRIB only */
MCAST_URIB_ONLY, /* URIB only */
MCAST_MIX_MRIB_FIRST, /* MRIB, if nothing at all then URIB */
MCAST_MIX_DISTANCE, /* MRIB & URIB, lower distance wins */
MCAST_MIX_PFXLEN, /* MRIB & URIB, longer prefix wins */
/* on equal value, MRIB wins for last 2 */
};
extern void multicast_mode_ipv4_set(enum multicast_mode mode);
extern enum multicast_mode multicast_mode_ipv4_get(void);
extern void rib_lookup_and_dump(struct prefix_ipv4 *, vrf_id_t);
extern void rib_lookup_and_pushup(struct prefix_ipv4 *, vrf_id_t);
extern int rib_lookup_ipv4_route(struct prefix_ipv4 *, union sockunion *,
vrf_id_t);
#define ZEBRA_RIB_LOOKUP_ERROR -1
#define ZEBRA_RIB_FOUND_EXACT 0
#define ZEBRA_RIB_FOUND_NOGATE 1
#define ZEBRA_RIB_FOUND_CONNECTED 2
#define ZEBRA_RIB_NOTFOUND 3
extern int is_zebra_valid_kernel_table(u_int32_t table_id);
extern int is_zebra_main_routing_table(u_int32_t table_id);
extern int zebra_check_addr(struct prefix *p);
extern void rib_addnode(struct route_node *rn, struct route_entry *re,
int process);
extern void rib_delnode(struct route_node *rn, struct route_entry *re);
extern void rib_install_kernel(struct route_node *rn, struct route_entry *re,
struct route_entry *old);
extern void rib_uninstall_kernel(struct route_node *rn, struct route_entry *re);
/* NOTE:
* All rib_add function will not just add prefix into RIB, but
* also implicitly withdraw equal prefix of same type. */
extern int rib_add(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
u_short instance, int flags, struct prefix *p,
struct prefix_ipv6 *src_p, const struct nexthop *nh,
u_int32_t table_id, u_int32_t metric, u_int32_t mtu,
uint8_t distance, route_tag_t tag);
extern int rib_add_multipath(afi_t afi, safi_t safi, struct prefix *,
struct prefix_ipv6 *src_p, struct route_entry *);
extern void rib_delete(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type,
u_short instance, int flags, struct prefix *p,
struct prefix_ipv6 *src_p, const struct nexthop *nh,
u_int32_t table_id, u_int32_t metric, bool fromkernel,
struct ethaddr *rmac);
extern struct route_entry *rib_match(afi_t afi, safi_t safi, vrf_id_t,
union g_addr *,
struct route_node **rn_out);
extern struct route_entry *rib_match_ipv4_multicast(vrf_id_t vrf_id,
struct in_addr addr,
struct route_node **rn_out);
extern struct route_entry *rib_lookup_ipv4(struct prefix_ipv4 *, vrf_id_t);
extern void rib_update(vrf_id_t, rib_update_event_t);
extern void rib_weed_tables(void);
extern void rib_sweep_route(void);
extern void rib_close_table(struct route_table *);
extern void rib_init(void);
extern unsigned long rib_score_proto(u_char proto, u_short instance);
extern void rib_queue_add(struct route_node *rn);
extern void meta_queue_free(struct meta_queue *mq);
extern int zebra_rib_labeled_unicast(struct route_entry *re);
extern struct route_table *rib_table_ipv6;
extern void rib_unlink(struct route_node *, struct route_entry *);
extern int rib_gc_dest(struct route_node *rn);
extern struct route_table *rib_tables_iter_next(rib_tables_iter_t *iter);
extern uint8_t route_distance(int type);
/*
* Inline functions.
*/
/*
* rib_table_info
*/
static inline rib_table_info_t *rib_table_info(struct route_table *table)
{
return (rib_table_info_t *)table->info;
}
/*
* rib_dest_from_rnode
*/
static inline rib_dest_t *rib_dest_from_rnode(struct route_node *rn)
{
return (rib_dest_t *)rn->info;
}
/*
* rnode_to_ribs
*
* Returns a pointer to the list of routes corresponding to the given
* route_node.
*/
static inline struct route_entry *rnode_to_ribs(struct route_node *rn)
{
rib_dest_t *dest;
dest = rib_dest_from_rnode(rn);
if (!dest)
return NULL;
return dest->routes;
}
/*
* rib_dest_prefix
*/
static inline struct prefix *rib_dest_prefix(rib_dest_t *dest)
{
return &dest->rnode->p;
}
/*
* rib_dest_af
*
* Returns the address family that the destination is for.
*/
static inline u_char rib_dest_af(rib_dest_t *dest)
{
return dest->rnode->p.family;
}
/*
* rib_dest_table
*/
static inline struct route_table *rib_dest_table(rib_dest_t *dest)
{
return srcdest_rnode_table(dest->rnode);
}
/*
* rib_dest_vrf
*/
static inline struct zebra_vrf *rib_dest_vrf(rib_dest_t *dest)
{
return rib_table_info(rib_dest_table(dest))->zvrf;
}
/*
* rib_tables_iter_init
*/
static inline void rib_tables_iter_init(rib_tables_iter_t *iter)
{
memset(iter, 0, sizeof(*iter));
iter->state = RIB_TABLES_ITER_S_INIT;
}
/*
* rib_tables_iter_started
*
* Returns TRUE if this iterator has started iterating over the set of
* tables.
*/
static inline int rib_tables_iter_started(rib_tables_iter_t *iter)
{
return iter->state != RIB_TABLES_ITER_S_INIT;
}
/*
* rib_tables_iter_cleanup
*/
static inline void rib_tables_iter_cleanup(rib_tables_iter_t *iter)
{
iter->state = RIB_TABLES_ITER_S_DONE;
}
DECLARE_HOOK(rib_update, (struct route_node * rn, const char *reason),
(rn, reason))
extern void zebra_vty_init(void);
extern pid_t pid;
#endif /*_ZEBRA_RIB_H */
|