Annotation of embedaddon/quagga/zebra/redistribute.c, revision 1.1.1.1
1.1 misho 1: /* Redistribution Handler
2: * Copyright (C) 1998 Kunihiro Ishiguro
3: *
4: * This file is part of GNU Zebra.
5: *
6: * GNU Zebra is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2, or (at your option) any
9: * later version.
10: *
11: * GNU Zebra is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of
13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: * General Public License for more details.
15: *
16: * You should have received a copy of the GNU General Public License
17: * along with GNU Zebra; see the file COPYING. If not, write to the Free
18: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19: * 02111-1307, USA.
20: */
21:
22: #include <zebra.h>
23:
24: #include "vector.h"
25: #include "vty.h"
26: #include "command.h"
27: #include "prefix.h"
28: #include "table.h"
29: #include "stream.h"
30: #include "zclient.h"
31: #include "linklist.h"
32: #include "log.h"
33:
34: #include "zebra/rib.h"
35: #include "zebra/zserv.h"
36: #include "zebra/redistribute.h"
37: #include "zebra/debug.h"
38: #include "zebra/router-id.h"
39:
40: /* master zebra server structure */
41: extern struct zebra_t zebrad;
42:
43: int
44: zebra_check_addr (struct prefix *p)
45: {
46: if (p->family == AF_INET)
47: {
48: u_int32_t addr;
49:
50: addr = p->u.prefix4.s_addr;
51: addr = ntohl (addr);
52:
53: if (IPV4_NET127 (addr)
54: || IN_CLASSD (addr)
55: || IPV4_LINKLOCAL(addr))
56: return 0;
57: }
58: #ifdef HAVE_IPV6
59: if (p->family == AF_INET6)
60: {
61: if (IN6_IS_ADDR_LOOPBACK (&p->u.prefix6))
62: return 0;
63: if (IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
64: return 0;
65: }
66: #endif /* HAVE_IPV6 */
67: return 1;
68: }
69:
70: static int
71: is_default (struct prefix *p)
72: {
73: if (p->family == AF_INET)
74: if (p->u.prefix4.s_addr == 0 && p->prefixlen == 0)
75: return 1;
76: #ifdef HAVE_IPV6
77: #if 0 /* IPv6 default separation is now pending until protocol daemon
78: can handle that. */
79: if (p->family == AF_INET6)
80: if (IN6_IS_ADDR_UNSPECIFIED (&p->u.prefix6) && p->prefixlen == 0)
81: return 1;
82: #endif /* 0 */
83: #endif /* HAVE_IPV6 */
84: return 0;
85: }
86:
87: static void
88: zebra_redistribute_default (struct zserv *client)
89: {
90: struct prefix_ipv4 p;
91: struct route_table *table;
92: struct route_node *rn;
93: struct rib *newrib;
94: #ifdef HAVE_IPV6
95: struct prefix_ipv6 p6;
96: #endif /* HAVE_IPV6 */
97:
98:
99: /* Lookup default route. */
100: memset (&p, 0, sizeof (struct prefix_ipv4));
101: p.family = AF_INET;
102:
103: /* Lookup table. */
104: table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
105: if (table)
106: {
107: rn = route_node_lookup (table, (struct prefix *)&p);
108: if (rn)
109: {
110: for (newrib = rn->info; newrib; newrib = newrib->next)
111: if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
112: && newrib->distance != DISTANCE_INFINITY)
113: zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
114: route_unlock_node (rn);
115: }
116: }
117:
118: #ifdef HAVE_IPV6
119: /* Lookup default route. */
120: memset (&p6, 0, sizeof (struct prefix_ipv6));
121: p6.family = AF_INET6;
122:
123: /* Lookup table. */
124: table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
125: if (table)
126: {
127: rn = route_node_lookup (table, (struct prefix *)&p6);
128: if (rn)
129: {
130: for (newrib = rn->info; newrib; newrib = newrib->next)
131: if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
132: && newrib->distance != DISTANCE_INFINITY)
133: zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
134: route_unlock_node (rn);
135: }
136: }
137: #endif /* HAVE_IPV6 */
138: }
139:
140: /* Redistribute routes. */
141: static void
142: zebra_redistribute (struct zserv *client, int type)
143: {
144: struct rib *newrib;
145: struct route_table *table;
146: struct route_node *rn;
147:
148: table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
149: if (table)
150: for (rn = route_top (table); rn; rn = route_next (rn))
151: for (newrib = rn->info; newrib; newrib = newrib->next)
152: if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
153: && newrib->type == type
154: && newrib->distance != DISTANCE_INFINITY
155: && zebra_check_addr (&rn->p))
156: zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, &rn->p, newrib);
157:
158: #ifdef HAVE_IPV6
159: table = vrf_table (AFI_IP6, SAFI_UNICAST, 0);
160: if (table)
161: for (rn = route_top (table); rn; rn = route_next (rn))
162: for (newrib = rn->info; newrib; newrib = newrib->next)
163: if (CHECK_FLAG (newrib->flags, ZEBRA_FLAG_SELECTED)
164: && newrib->type == type
165: && newrib->distance != DISTANCE_INFINITY
166: && zebra_check_addr (&rn->p))
167: zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, &rn->p, newrib);
168: #endif /* HAVE_IPV6 */
169: }
170:
171: void
172: redistribute_add (struct prefix *p, struct rib *rib)
173: {
174: struct listnode *node, *nnode;
175: struct zserv *client;
176:
177: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
178: {
179: if (is_default (p))
180: {
181: if (client->redist_default || client->redist[rib->type])
182: {
183: if (p->family == AF_INET)
184: zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
185: #ifdef HAVE_IPV6
186: if (p->family == AF_INET6)
187: zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
188: #endif /* HAVE_IPV6 */
189: }
190: }
191: else if (client->redist[rib->type])
192: {
193: if (p->family == AF_INET)
194: zsend_route_multipath (ZEBRA_IPV4_ROUTE_ADD, client, p, rib);
195: #ifdef HAVE_IPV6
196: if (p->family == AF_INET6)
197: zsend_route_multipath (ZEBRA_IPV6_ROUTE_ADD, client, p, rib);
198: #endif /* HAVE_IPV6 */
199: }
200: }
201: }
202:
203: void
204: redistribute_delete (struct prefix *p, struct rib *rib)
205: {
206: struct listnode *node, *nnode;
207: struct zserv *client;
208:
209: /* Add DISTANCE_INFINITY check. */
210: if (rib->distance == DISTANCE_INFINITY)
211: return;
212:
213: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
214: {
215: if (is_default (p))
216: {
217: if (client->redist_default || client->redist[rib->type])
218: {
219: if (p->family == AF_INET)
220: zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p,
221: rib);
222: #ifdef HAVE_IPV6
223: if (p->family == AF_INET6)
224: zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p,
225: rib);
226: #endif /* HAVE_IPV6 */
227: }
228: }
229: else if (client->redist[rib->type])
230: {
231: if (p->family == AF_INET)
232: zsend_route_multipath (ZEBRA_IPV4_ROUTE_DELETE, client, p, rib);
233: #ifdef HAVE_IPV6
234: if (p->family == AF_INET6)
235: zsend_route_multipath (ZEBRA_IPV6_ROUTE_DELETE, client, p, rib);
236: #endif /* HAVE_IPV6 */
237: }
238: }
239: }
240:
241: void
242: zebra_redistribute_add (int command, struct zserv *client, int length)
243: {
244: int type;
245:
246: type = stream_getc (client->ibuf);
247:
248: switch (type)
249: {
250: case ZEBRA_ROUTE_KERNEL:
251: case ZEBRA_ROUTE_CONNECT:
252: case ZEBRA_ROUTE_STATIC:
253: case ZEBRA_ROUTE_RIP:
254: case ZEBRA_ROUTE_RIPNG:
255: case ZEBRA_ROUTE_OSPF:
256: case ZEBRA_ROUTE_OSPF6:
257: case ZEBRA_ROUTE_BGP:
258: if (! client->redist[type])
259: {
260: client->redist[type] = 1;
261: zebra_redistribute (client, type);
262: }
263: break;
264: default:
265: break;
266: }
267: }
268:
269: void
270: zebra_redistribute_delete (int command, struct zserv *client, int length)
271: {
272: int type;
273:
274: type = stream_getc (client->ibuf);
275:
276: switch (type)
277: {
278: case ZEBRA_ROUTE_KERNEL:
279: case ZEBRA_ROUTE_CONNECT:
280: case ZEBRA_ROUTE_STATIC:
281: case ZEBRA_ROUTE_RIP:
282: case ZEBRA_ROUTE_RIPNG:
283: case ZEBRA_ROUTE_OSPF:
284: case ZEBRA_ROUTE_OSPF6:
285: case ZEBRA_ROUTE_BGP:
286: client->redist[type] = 0;
287: break;
288: default:
289: break;
290: }
291: }
292:
293: void
294: zebra_redistribute_default_add (int command, struct zserv *client, int length)
295: {
296: client->redist_default = 1;
297: zebra_redistribute_default (client);
298: }
299:
300: void
301: zebra_redistribute_default_delete (int command, struct zserv *client,
302: int length)
303: {
304: client->redist_default = 0;;
305: }
306:
307: /* Interface up information. */
308: void
309: zebra_interface_up_update (struct interface *ifp)
310: {
311: struct listnode *node, *nnode;
312: struct zserv *client;
313:
314: if (IS_ZEBRA_DEBUG_EVENT)
315: zlog_debug ("MESSAGE: ZEBRA_INTERFACE_UP %s", ifp->name);
316:
317: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
318: zsend_interface_update (ZEBRA_INTERFACE_UP, client, ifp);
319: }
320:
321: /* Interface down information. */
322: void
323: zebra_interface_down_update (struct interface *ifp)
324: {
325: struct listnode *node, *nnode;
326: struct zserv *client;
327:
328: if (IS_ZEBRA_DEBUG_EVENT)
329: zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DOWN %s", ifp->name);
330:
331: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
332: zsend_interface_update (ZEBRA_INTERFACE_DOWN, client, ifp);
333: }
334:
335: /* Interface information update. */
336: void
337: zebra_interface_add_update (struct interface *ifp)
338: {
339: struct listnode *node, *nnode;
340: struct zserv *client;
341:
342: if (IS_ZEBRA_DEBUG_EVENT)
343: zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADD %s", ifp->name);
344:
345: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
346: if (client->ifinfo)
347: zsend_interface_add (client, ifp);
348: }
349:
350: void
351: zebra_interface_delete_update (struct interface *ifp)
352: {
353: struct listnode *node, *nnode;
354: struct zserv *client;
355:
356: if (IS_ZEBRA_DEBUG_EVENT)
357: zlog_debug ("MESSAGE: ZEBRA_INTERFACE_DELETE %s", ifp->name);
358:
359: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
360: if (client->ifinfo)
361: zsend_interface_delete (client, ifp);
362: }
363:
364: /* Interface address addition. */
365: void
366: zebra_interface_address_add_update (struct interface *ifp,
367: struct connected *ifc)
368: {
369: struct listnode *node, *nnode;
370: struct zserv *client;
371: struct prefix *p;
372:
373: if (IS_ZEBRA_DEBUG_EVENT)
374: {
375: char buf[INET6_ADDRSTRLEN];
376:
377: p = ifc->address;
378: zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_ADD %s/%d on %s",
379: inet_ntop (p->family, &p->u.prefix, buf, INET6_ADDRSTRLEN),
380: p->prefixlen, ifc->ifp->name);
381: }
382:
383: router_id_add_address(ifc);
384:
385: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
386: if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
387: zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client, ifp, ifc);
388: }
389:
390: /* Interface address deletion. */
391: void
392: zebra_interface_address_delete_update (struct interface *ifp,
393: struct connected *ifc)
394: {
395: struct listnode *node, *nnode;
396: struct zserv *client;
397: struct prefix *p;
398:
399: if (IS_ZEBRA_DEBUG_EVENT)
400: {
401: char buf[INET6_ADDRSTRLEN];
402:
403: p = ifc->address;
404: zlog_debug ("MESSAGE: ZEBRA_INTERFACE_ADDRESS_DELETE %s/%d on %s",
405: inet_ntop (p->family, &p->u.prefix, buf, INET6_ADDRSTRLEN),
406: p->prefixlen, ifc->ifp->name);
407: }
408:
409: router_id_del_address(ifc);
410:
411: for (ALL_LIST_ELEMENTS (zebrad.client_list, node, nnode, client))
412: if (client->ifinfo && CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
413: zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_DELETE, client, ifp, ifc);
414: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to redistribute.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra