Annotation of embedaddon/quagga/lib/if_rmap.c, revision 1.1.1.3
1.1 misho 1: /* route-map for interface.
2: * Copyright (C) 1999 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 "hash.h"
25: #include "command.h"
26: #include "memory.h"
27: #include "if.h"
28: #include "if_rmap.h"
29:
30: struct hash *ifrmaphash;
31:
32: /* Hook functions. */
33: static void (*if_rmap_add_hook) (struct if_rmap *) = NULL;
34: static void (*if_rmap_delete_hook) (struct if_rmap *) = NULL;
1.1.1.3 ! misho 35:
1.1 misho 36: static struct if_rmap *
37: if_rmap_new (void)
38: {
39: struct if_rmap *new;
40:
41: new = XCALLOC (MTYPE_IF_RMAP, sizeof (struct if_rmap));
42:
43: return new;
44: }
45:
46: static void
47: if_rmap_free (struct if_rmap *if_rmap)
48: {
49: if (if_rmap->ifname)
50: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->ifname);
51:
52: if (if_rmap->routemap[IF_RMAP_IN])
53: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_IN]);
54: if (if_rmap->routemap[IF_RMAP_OUT])
55: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_OUT]);
56:
57: XFREE (MTYPE_IF_RMAP, if_rmap);
58: }
59:
60: struct if_rmap *
61: if_rmap_lookup (const char *ifname)
62: {
63: struct if_rmap key;
64: struct if_rmap *if_rmap;
65:
66: /* temporary copy */
67: key.ifname = (char *)ifname;
68:
69: if_rmap = hash_lookup (ifrmaphash, &key);
70:
71: return if_rmap;
72: }
73:
74: void
75: if_rmap_hook_add (void (*func) (struct if_rmap *))
76: {
77: if_rmap_add_hook = func;
78: }
79:
80: void
81: if_rmap_hook_delete (void (*func) (struct if_rmap *))
82: {
83: if_rmap_delete_hook = func;
84: }
85:
86: static void *
87: if_rmap_hash_alloc (void *arg)
88: {
89: struct if_rmap *ifarg = arg;
90: struct if_rmap *if_rmap;
91:
92: if_rmap = if_rmap_new ();
93: if_rmap->ifname = XSTRDUP (MTYPE_IF_RMAP_NAME, ifarg->ifname);
94:
95: return if_rmap;
96: }
97:
98: static struct if_rmap *
99: if_rmap_get (const char *ifname)
100: {
101: struct if_rmap key;
102:
103: /* temporary copy */
104: key.ifname = (char *)ifname;
105:
106: return (struct if_rmap *) hash_get (ifrmaphash, &key, if_rmap_hash_alloc);
107: }
108:
109: static unsigned int
110: if_rmap_hash_make (void *data)
111: {
112: const struct if_rmap *if_rmap = data;
113:
114: return string_hash_make (if_rmap->ifname);
115: }
116:
117: static int
118: if_rmap_hash_cmp (const void *arg1, const void* arg2)
119: {
120: const struct if_rmap *if_rmap1 = arg1;
121: const struct if_rmap *if_rmap2 = arg2;
122:
123: return strcmp (if_rmap1->ifname, if_rmap2->ifname) == 0;
124: }
1.1.1.3 ! misho 125:
1.1 misho 126: static struct if_rmap *
127: if_rmap_set (const char *ifname, enum if_rmap_type type,
128: const char *routemap_name)
129: {
130: struct if_rmap *if_rmap;
131:
132: if_rmap = if_rmap_get (ifname);
133:
134: if (type == IF_RMAP_IN)
135: {
136: if (if_rmap->routemap[IF_RMAP_IN])
137: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_IN]);
138: if_rmap->routemap[IF_RMAP_IN]
139: = XSTRDUP (MTYPE_IF_RMAP_NAME, routemap_name);
140: }
141: if (type == IF_RMAP_OUT)
142: {
143: if (if_rmap->routemap[IF_RMAP_OUT])
144: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_OUT]);
145: if_rmap->routemap[IF_RMAP_OUT]
146: = XSTRDUP (MTYPE_IF_RMAP_NAME, routemap_name);
147: }
148:
149: if (if_rmap_add_hook)
150: (*if_rmap_add_hook) (if_rmap);
151:
152: return if_rmap;
153: }
154:
155: static int
156: if_rmap_unset (const char *ifname, enum if_rmap_type type,
157: const char *routemap_name)
158: {
159: struct if_rmap *if_rmap;
160:
161: if_rmap = if_rmap_lookup (ifname);
162: if (!if_rmap)
163: return 0;
164:
165: if (type == IF_RMAP_IN)
166: {
167: if (!if_rmap->routemap[IF_RMAP_IN])
168: return 0;
169: if (strcmp (if_rmap->routemap[IF_RMAP_IN], routemap_name) != 0)
170: return 0;
171:
172: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_IN]);
173: if_rmap->routemap[IF_RMAP_IN] = NULL;
174: }
175:
176: if (type == IF_RMAP_OUT)
177: {
178: if (!if_rmap->routemap[IF_RMAP_OUT])
179: return 0;
180: if (strcmp (if_rmap->routemap[IF_RMAP_OUT], routemap_name) != 0)
181: return 0;
182:
183: XFREE (MTYPE_IF_RMAP_NAME, if_rmap->routemap[IF_RMAP_OUT]);
184: if_rmap->routemap[IF_RMAP_OUT] = NULL;
185: }
186:
187: if (if_rmap_delete_hook)
188: (*if_rmap_delete_hook) (if_rmap);
189:
190: if (if_rmap->routemap[IF_RMAP_IN] == NULL &&
191: if_rmap->routemap[IF_RMAP_OUT] == NULL)
192: {
193: hash_release (ifrmaphash, if_rmap);
194: if_rmap_free (if_rmap);
195: }
196:
197: return 1;
198: }
199:
200: DEFUN (if_rmap,
201: if_rmap_cmd,
202: "route-map RMAP_NAME (in|out) IFNAME",
203: "Route map set\n"
204: "Route map name\n"
205: "Route map set for input filtering\n"
206: "Route map set for output filtering\n"
207: "Route map interface name\n")
208: {
209: enum if_rmap_type type;
210:
211: if (strncmp (argv[1], "i", 1) == 0)
212: type = IF_RMAP_IN;
213: else if (strncmp (argv[1], "o", 1) == 0)
214: type = IF_RMAP_OUT;
215: else
216: {
217: vty_out (vty, "route-map direction must be [in|out]%s", VTY_NEWLINE);
218: return CMD_WARNING;
219: }
220:
1.1.1.2 misho 221: if_rmap_set (argv[2], type, argv[0]);
1.1 misho 222:
223: return CMD_SUCCESS;
224: }
225:
226: ALIAS (if_rmap,
227: if_ipv6_rmap_cmd,
228: "route-map RMAP_NAME (in|out) IFNAME",
229: "Route map set\n"
230: "Route map name\n"
231: "Route map set for input filtering\n"
232: "Route map set for output filtering\n"
233: "Route map interface name\n")
234:
235: DEFUN (no_if_rmap,
236: no_if_rmap_cmd,
237: "no route-map ROUTEMAP_NAME (in|out) IFNAME",
238: NO_STR
239: "Route map unset\n"
240: "Route map name\n"
241: "Route map for input filtering\n"
242: "Route map for output filtering\n"
243: "Route map interface name\n")
244: {
245: int ret;
246: enum if_rmap_type type;
247:
248: if (strncmp (argv[1], "i", 1) == 0)
249: type = IF_RMAP_IN;
250: else if (strncmp (argv[1], "o", 1) == 0)
251: type = IF_RMAP_OUT;
252: else
253: {
254: vty_out (vty, "route-map direction must be [in|out]%s", VTY_NEWLINE);
255: return CMD_WARNING;
256: }
257:
258: ret = if_rmap_unset (argv[2], type, argv[0]);
259: if (! ret)
260: {
261: vty_out (vty, "route-map doesn't exist%s", VTY_NEWLINE);
262: return CMD_WARNING;
263: }
264: return CMD_SUCCESS;
265: }
266:
267: ALIAS (no_if_rmap,
268: no_if_ipv6_rmap_cmd,
269: "no route-map ROUTEMAP_NAME (in|out) IFNAME",
270: NO_STR
271: "Route map unset\n"
272: "Route map name\n"
273: "Route map for input filtering\n"
274: "Route map for output filtering\n"
275: "Route map interface name\n")
1.1.1.3 ! misho 276:
1.1 misho 277: /* Configuration write function. */
278: int
279: config_write_if_rmap (struct vty *vty)
280: {
281: unsigned int i;
282: struct hash_backet *mp;
283: int write = 0;
284:
285: for (i = 0; i < ifrmaphash->size; i++)
286: for (mp = ifrmaphash->index[i]; mp; mp = mp->next)
287: {
288: struct if_rmap *if_rmap;
289:
290: if_rmap = mp->data;
291:
292: if (if_rmap->routemap[IF_RMAP_IN])
293: {
294: vty_out (vty, " route-map %s in %s%s",
295: if_rmap->routemap[IF_RMAP_IN],
296: if_rmap->ifname,
297: VTY_NEWLINE);
298: write++;
299: }
300:
301: if (if_rmap->routemap[IF_RMAP_OUT])
302: {
303: vty_out (vty, " route-map %s out %s%s",
304: if_rmap->routemap[IF_RMAP_OUT],
305: if_rmap->ifname,
306: VTY_NEWLINE);
307: write++;
308: }
309: }
310: return write;
311: }
312:
313: void
314: if_rmap_reset ()
315: {
316: hash_clean (ifrmaphash, (void (*) (void *)) if_rmap_free);
317: }
318:
319: void
320: if_rmap_init (int node)
321: {
322: ifrmaphash = hash_create (if_rmap_hash_make, if_rmap_hash_cmp);
323: if (node == RIPNG_NODE) {
324: install_element (RIPNG_NODE, &if_ipv6_rmap_cmd);
325: install_element (RIPNG_NODE, &no_if_ipv6_rmap_cmd);
326: } else if (node == RIP_NODE) {
327: install_element (RIP_NODE, &if_rmap_cmd);
328: install_element (RIP_NODE, &no_if_rmap_cmd);
329: }
330: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to if_rmap.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 / lib