Annotation of embedaddon/quagga/zebra/rt_ioctl.c, revision 1.1.1.1
1.1 misho 1: /*
2: * kernel routing table update by ioctl().
3: * Copyright (C) 1997, 98 Kunihiro Ishiguro
4: *
5: * This file is part of GNU Zebra.
6: *
7: * GNU Zebra is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2, or (at your option) any
10: * later version.
11: *
12: * GNU Zebra is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20: * 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "prefix.h"
26: #include "log.h"
27: #include "if.h"
28:
29: #include "zebra/zserv.h"
30: #include "zebra/rib.h"
31: #include "zebra/debug.h"
32: #include "zebra/rt.h"
33:
34: /* Initialize of kernel interface. There is no kernel communication
35: support under ioctl(). So this is dummy stub function. */
36: void
37: kernel_init (void)
38: {
39: return;
40: }
41:
42: /* Dummy function of routing socket. */
43: static void
44: kernel_read (int sock)
45: {
46: return;
47: }
48:
49: #if 0
50: /* Initialization prototype of struct sockaddr_in. */
51: static struct sockaddr_in sin_proto =
52: {
53: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
54: sizeof (struct sockaddr_in),
55: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
56: AF_INET, 0, {0}, {0}
57: };
58: #endif /* 0 */
59:
60: /* Solaris has ortentry. */
61: #ifdef HAVE_OLD_RTENTRY
62: #define rtentry ortentry
63: #endif /* HAVE_OLD_RTENTRY */
64:
65: /* Interface to ioctl route message. */
66: int
67: kernel_add_route (struct prefix_ipv4 *dest, struct in_addr *gate,
68: int index, int flags)
69: {
70: int ret;
71: int sock;
72: struct rtentry rtentry;
73: struct sockaddr_in sin_dest, sin_mask, sin_gate;
74:
75: memset (&rtentry, 0, sizeof (struct rtentry));
76:
77: /* Make destination. */
78: memset (&sin_dest, 0, sizeof (struct sockaddr_in));
79: sin_dest.sin_family = AF_INET;
80: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
81: sin_dest.sin_len = sizeof (struct sockaddr_in);
82: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
83: sin_dest.sin_addr = dest->prefix;
84:
85: /* Make gateway. */
86: if (gate)
87: {
88: memset (&sin_gate, 0, sizeof (struct sockaddr_in));
89: sin_gate.sin_family = AF_INET;
90: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
91: sin_gate.sin_len = sizeof (struct sockaddr_in);
92: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
93: sin_gate.sin_addr = *gate;
94: }
95:
96: memset (&sin_mask, 0, sizeof (struct sockaddr_in));
97: sin_mask.sin_family = AF_INET;
98: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
99: sin_gate.sin_len = sizeof (struct sockaddr_in);
100: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
101: masklen2ip (dest->prefixlen, &sin_mask.sin_addr);
102:
103: /* Set destination address, mask and gateway.*/
104: memcpy (&rtentry.rt_dst, &sin_dest, sizeof (struct sockaddr_in));
105: if (gate)
106: memcpy (&rtentry.rt_gateway, &sin_gate, sizeof (struct sockaddr_in));
107: #ifndef SUNOS_5
108: memcpy (&rtentry.rt_genmask, &sin_mask, sizeof (struct sockaddr_in));
109: #endif /* SUNOS_5 */
110:
111: /* Routing entry flag set. */
112: if (dest->prefixlen == 32)
113: rtentry.rt_flags |= RTF_HOST;
114:
115: if (gate && gate->s_addr != INADDR_ANY)
116: rtentry.rt_flags |= RTF_GATEWAY;
117:
118: rtentry.rt_flags |= RTF_UP;
119:
120: /* Additional flags */
121: rtentry.rt_flags |= flags;
122:
123:
124: /* For tagging route. */
125: /* rtentry.rt_flags |= RTF_DYNAMIC; */
126:
127: /* Open socket for ioctl. */
128: sock = socket (AF_INET, SOCK_DGRAM, 0);
129: if (sock < 0)
130: {
131: zlog_warn ("can't make socket\n");
132: return -1;
133: }
134:
135: /* Send message by ioctl(). */
136: ret = ioctl (sock, SIOCADDRT, &rtentry);
137: if (ret < 0)
138: {
139: switch (errno)
140: {
141: case EEXIST:
142: close (sock);
143: return ZEBRA_ERR_RTEXIST;
144: break;
145: case ENETUNREACH:
146: close (sock);
147: return ZEBRA_ERR_RTUNREACH;
148: break;
149: case EPERM:
150: close (sock);
151: return ZEBRA_ERR_EPERM;
152: break;
153: }
154:
155: close (sock);
156: zlog_warn ("write : %s (%d)", safe_strerror (errno), errno);
157: return 1;
158: }
159: close (sock);
160:
161: return ret;
162: }
163:
164: /* Interface to ioctl route message. */
165: static int
166: kernel_ioctl_ipv4 (u_long cmd, struct prefix *p, struct rib *rib, int family)
167: {
168: int ret;
169: int sock;
170: struct rtentry rtentry;
171: struct sockaddr_in sin_dest, sin_mask, sin_gate;
172: struct nexthop *nexthop;
173: int nexthop_num = 0;
174: struct interface *ifp;
175:
176: memset (&rtentry, 0, sizeof (struct rtentry));
177:
178: /* Make destination. */
179: memset (&sin_dest, 0, sizeof (struct sockaddr_in));
180: sin_dest.sin_family = AF_INET;
181: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
182: sin_dest.sin_len = sizeof (struct sockaddr_in);
183: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
184: sin_dest.sin_addr = p->u.prefix4;
185:
186: if (CHECK_FLAG (rib->flags, ZEBRA_FLAG_BLACKHOLE))
187: {
188: SET_FLAG (rtentry.rt_flags, RTF_REJECT);
189:
190: if (cmd == SIOCADDRT)
191: for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
192: SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
193:
194: goto skip;
195: }
196:
197: memset (&sin_gate, 0, sizeof (struct sockaddr_in));
198:
199: /* Make gateway. */
200: for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
201: {
202: if ((cmd == SIOCADDRT
203: && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
204: || (cmd == SIOCDELRT
205: && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
206: {
207: if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
208: {
209: if (nexthop->rtype == NEXTHOP_TYPE_IPV4 ||
210: nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX)
211: {
212: sin_gate.sin_family = AF_INET;
213: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
214: sin_gate.sin_len = sizeof (struct sockaddr_in);
215: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
216: sin_gate.sin_addr = nexthop->rgate.ipv4;
217: rtentry.rt_flags |= RTF_GATEWAY;
218: }
219: if (nexthop->rtype == NEXTHOP_TYPE_IFINDEX
220: || nexthop->rtype == NEXTHOP_TYPE_IFNAME)
221: {
222: ifp = if_lookup_by_index (nexthop->rifindex);
223: if (ifp)
224: rtentry.rt_dev = ifp->name;
225: else
226: return -1;
227: }
228: }
229: else
230: {
231: if (nexthop->type == NEXTHOP_TYPE_IPV4 ||
232: nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
233: {
234: sin_gate.sin_family = AF_INET;
235: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
236: sin_gate.sin_len = sizeof (struct sockaddr_in);
237: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
238: sin_gate.sin_addr = nexthop->gate.ipv4;
239: rtentry.rt_flags |= RTF_GATEWAY;
240: }
241: if (nexthop->type == NEXTHOP_TYPE_IFINDEX
242: || nexthop->type == NEXTHOP_TYPE_IFNAME)
243: {
244: ifp = if_lookup_by_index (nexthop->ifindex);
245: if (ifp)
246: rtentry.rt_dev = ifp->name;
247: else
248: return -1;
249: }
250: }
251:
252: if (cmd == SIOCADDRT)
253: SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
254:
255: nexthop_num++;
256: break;
257: }
258: }
259:
260: /* If there is no useful nexthop then return. */
261: if (nexthop_num == 0)
262: {
263: if (IS_ZEBRA_DEBUG_KERNEL)
264: zlog_debug ("netlink_route_multipath(): No useful nexthop.");
265: return 0;
266: }
267:
268: skip:
269:
270: memset (&sin_mask, 0, sizeof (struct sockaddr_in));
271: sin_mask.sin_family = AF_INET;
272: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
273: sin_mask.sin_len = sizeof (struct sockaddr_in);
274: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
275: masklen2ip (p->prefixlen, &sin_mask.sin_addr);
276:
277: /* Set destination address, mask and gateway.*/
278: memcpy (&rtentry.rt_dst, &sin_dest, sizeof (struct sockaddr_in));
279:
280: if (rtentry.rt_flags & RTF_GATEWAY)
281: memcpy (&rtentry.rt_gateway, &sin_gate, sizeof (struct sockaddr_in));
282:
283: #ifndef SUNOS_5
284: memcpy (&rtentry.rt_genmask, &sin_mask, sizeof (struct sockaddr_in));
285: #endif /* SUNOS_5 */
286:
287: /* Metric. It seems metric minus one value is installed... */
288: rtentry.rt_metric = rib->metric;
289:
290: /* Routing entry flag set. */
291: if (p->prefixlen == 32)
292: rtentry.rt_flags |= RTF_HOST;
293:
294: rtentry.rt_flags |= RTF_UP;
295:
296: /* Additional flags */
297: /* rtentry.rt_flags |= flags; */
298:
299: /* For tagging route. */
300: /* rtentry.rt_flags |= RTF_DYNAMIC; */
301:
302: /* Open socket for ioctl. */
303: sock = socket (AF_INET, SOCK_DGRAM, 0);
304: if (sock < 0)
305: {
306: zlog_warn ("can't make socket\n");
307: return -1;
308: }
309:
310: /* Send message by ioctl(). */
311: ret = ioctl (sock, cmd, &rtentry);
312: if (ret < 0)
313: {
314: switch (errno)
315: {
316: case EEXIST:
317: close (sock);
318: return ZEBRA_ERR_RTEXIST;
319: break;
320: case ENETUNREACH:
321: close (sock);
322: return ZEBRA_ERR_RTUNREACH;
323: break;
324: case EPERM:
325: close (sock);
326: return ZEBRA_ERR_EPERM;
327: break;
328: }
329:
330: close (sock);
331: zlog_warn ("write : %s (%d)", safe_strerror (errno), errno);
332: return ret;
333: }
334: close (sock);
335:
336: return ret;
337: }
338:
339: int
340: kernel_add_ipv4 (struct prefix *p, struct rib *rib)
341: {
342: return kernel_ioctl_ipv4 (SIOCADDRT, p, rib, AF_INET);
343: }
344:
345: int
346: kernel_delete_ipv4 (struct prefix *p, struct rib *rib)
347: {
348: return kernel_ioctl_ipv4 (SIOCDELRT, p, rib, AF_INET);
349: }
350:
351: #ifdef HAVE_IPV6
352:
353: /* Below is hack for GNU libc definition and Linux 2.1.X header. */
354: #undef RTF_DEFAULT
355: #undef RTF_ADDRCONF
356:
357: #include <asm/types.h>
358:
359: #if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
360: /* struct in6_rtmsg will be declared in net/route.h. */
361: #else
362: #include <linux/ipv6_route.h>
363: #endif
364:
365: static int
366: kernel_ioctl_ipv6 (u_long type, struct prefix_ipv6 *dest, struct in6_addr *gate,
367: int index, int flags)
368: {
369: int ret;
370: int sock;
371: struct in6_rtmsg rtm;
372:
373: memset (&rtm, 0, sizeof (struct in6_rtmsg));
374:
375: rtm.rtmsg_flags |= RTF_UP;
376: rtm.rtmsg_metric = 1;
377: memcpy (&rtm.rtmsg_dst, &dest->prefix, sizeof (struct in6_addr));
378: rtm.rtmsg_dst_len = dest->prefixlen;
379:
380: /* We need link local index. But this should be done caller...
381: if (IN6_IS_ADDR_LINKLOCAL(&rtm.rtmsg_gateway))
382: {
383: index = if_index_address (&rtm.rtmsg_gateway);
384: rtm.rtmsg_ifindex = index;
385: }
386: else
387: rtm.rtmsg_ifindex = 0;
388: */
389:
390: rtm.rtmsg_flags |= RTF_GATEWAY;
391:
392: /* For tagging route. */
393: /* rtm.rtmsg_flags |= RTF_DYNAMIC; */
394:
395: memcpy (&rtm.rtmsg_gateway, gate, sizeof (struct in6_addr));
396:
397: if (index)
398: rtm.rtmsg_ifindex = index;
399: else
400: rtm.rtmsg_ifindex = 0;
401:
402: rtm.rtmsg_metric = 1;
403:
404: sock = socket (AF_INET6, SOCK_DGRAM, 0);
405: if (sock < 0)
406: {
407: zlog_warn ("can't make socket\n");
408: return -1;
409: }
410:
411: /* Send message via ioctl. */
412: ret = ioctl (sock, type, &rtm);
413: if (ret < 0)
414: {
415: zlog_warn ("can't %s ipv6 route: %s\n", type == SIOCADDRT ? "add" : "delete",
416: safe_strerror(errno));
417: ret = errno;
418: close (sock);
419: return ret;
420: }
421: close (sock);
422:
423: return ret;
424: }
425:
426: static int
427: kernel_ioctl_ipv6_multipath (u_long cmd, struct prefix *p, struct rib *rib,
428: int family)
429: {
430: int ret;
431: int sock;
432: struct in6_rtmsg rtm;
433: struct nexthop *nexthop;
434: int nexthop_num = 0;
435:
436: memset (&rtm, 0, sizeof (struct in6_rtmsg));
437:
438: rtm.rtmsg_flags |= RTF_UP;
439: rtm.rtmsg_metric = rib->metric;
440: memcpy (&rtm.rtmsg_dst, &p->u.prefix, sizeof (struct in6_addr));
441: rtm.rtmsg_dst_len = p->prefixlen;
442:
443: /* We need link local index. But this should be done caller...
444: if (IN6_IS_ADDR_LINKLOCAL(&rtm.rtmsg_gateway))
445: {
446: index = if_index_address (&rtm.rtmsg_gateway);
447: rtm.rtmsg_ifindex = index;
448: }
449: else
450: rtm.rtmsg_ifindex = 0;
451: */
452:
453: rtm.rtmsg_flags |= RTF_GATEWAY;
454:
455: /* For tagging route. */
456: /* rtm.rtmsg_flags |= RTF_DYNAMIC; */
457:
458: /* Make gateway. */
459: for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
460: {
461: if ((cmd == SIOCADDRT
462: && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
463: || (cmd == SIOCDELRT
464: && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
465: {
466: if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
467: {
468: if (nexthop->rtype == NEXTHOP_TYPE_IPV6
469: || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME
470: || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX)
471: {
472: memcpy (&rtm.rtmsg_gateway, &nexthop->rgate.ipv6,
473: sizeof (struct in6_addr));
474: }
475: if (nexthop->rtype == NEXTHOP_TYPE_IFINDEX
476: || nexthop->rtype == NEXTHOP_TYPE_IFNAME
477: || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME
478: || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX)
479: rtm.rtmsg_ifindex = nexthop->rifindex;
480: else
481: rtm.rtmsg_ifindex = 0;
482:
483: }
484: else
485: {
486: if (nexthop->type == NEXTHOP_TYPE_IPV6
487: || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
488: || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
489: {
490: memcpy (&rtm.rtmsg_gateway, &nexthop->gate.ipv6,
491: sizeof (struct in6_addr));
492: }
493: if (nexthop->type == NEXTHOP_TYPE_IFINDEX
494: || nexthop->type == NEXTHOP_TYPE_IFNAME
495: || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
496: || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
497: rtm.rtmsg_ifindex = nexthop->ifindex;
498: else
499: rtm.rtmsg_ifindex = 0;
500: }
501:
502: if (cmd == SIOCADDRT)
503: SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
504:
505: nexthop_num++;
506: break;
507: }
508: }
509:
510: /* If there is no useful nexthop then return. */
511: if (nexthop_num == 0)
512: {
513: if (IS_ZEBRA_DEBUG_KERNEL)
514: zlog_debug ("netlink_route_multipath(): No useful nexthop.");
515: return 0;
516: }
517:
518: sock = socket (AF_INET6, SOCK_DGRAM, 0);
519: if (sock < 0)
520: {
521: zlog_warn ("can't make socket\n");
522: return -1;
523: }
524:
525: /* Send message via ioctl. */
526: ret = ioctl (sock, cmd, &rtm);
527: if (ret < 0)
528: {
529: zlog_warn ("can't %s ipv6 route: %s\n",
530: cmd == SIOCADDRT ? "add" : "delete",
531: safe_strerror(errno));
532: ret = errno;
533: close (sock);
534: return ret;
535: }
536: close (sock);
537:
538: return ret;
539: }
540:
541: int
542: kernel_add_ipv6 (struct prefix *p, struct rib *rib)
543: {
544: return kernel_ioctl_ipv6_multipath (SIOCADDRT, p, rib, AF_INET6);
545: }
546:
547: int
548: kernel_delete_ipv6 (struct prefix *p, struct rib *rib)
549: {
550: return kernel_ioctl_ipv6_multipath (SIOCDELRT, p, rib, AF_INET6);
551: }
552:
553: /* Delete IPv6 route from the kernel. */
554: int
555: kernel_delete_ipv6_old (struct prefix_ipv6 *dest, struct in6_addr *gate,
556: unsigned int index, int flags, int table)
557: {
558: return kernel_ioctl_ipv6 (SIOCDELRT, dest, gate, index, flags);
559: }
560: #endif /* HAVE_IPV6 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rt_ioctl.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