Return to rtread_proc.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra

Annotation of embedaddon/quagga/zebra/rtread_proc.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Kernel routing readup by /proc filesystem
                      3:  * Copyright (C) 1997 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: #include "rib.h"
                     29: 
                     30: #include "zebra/zserv.h"
                     31: #include "zebra/rt.h"
                     32: 
                     33: /* Proc file system to read IPv4 routing table. */
                     34: #ifndef _PATH_PROCNET_ROUTE
                     35: #define _PATH_PROCNET_ROUTE      "/proc/net/route"
                     36: #endif /* _PATH_PROCNET_ROUTE */
                     37: 
                     38: /* Proc file system to read IPv6 routing table. */
                     39: #ifndef _PATH_PROCNET_ROUTE6
                     40: #define _PATH_PROCNET_ROUTE6     "/proc/net/ipv6_route"
                     41: #endif /* _PATH_PROCNET_ROUTE6 */
                     42: 
                     43: /* To read interface's name */
                     44: #define INTERFACE_NAMSIZ 20  
                     45: 
                     46: /* Reading buffer for one routing entry. */
                     47: #define RT_BUFSIZ 1024
                     48: 
                     49: /* Kernel routing table read up by /proc filesystem. */
                     50: static int
                     51: proc_route_read (void)
                     52: {
                     53:   FILE *fp;
                     54:   char buf[RT_BUFSIZ];
                     55:   char iface[INTERFACE_NAMSIZ], dest[9], gate[9], mask[9];
                     56:   int flags, refcnt, use, metric, mtu, window, rtt;
                     57: 
                     58:   /* Open /proc filesystem */
                     59:   fp = fopen (_PATH_PROCNET_ROUTE, "r");
                     60:   if (fp == NULL)
                     61:     {
                     62:       zlog_warn ("Can't open %s : %s\n", _PATH_PROCNET_ROUTE, safe_strerror (errno));
                     63:       return -1;
                     64:     }
                     65:   
                     66:   /* Drop first label line. */
                     67:   fgets (buf, RT_BUFSIZ, fp);
                     68: 
                     69:   while (fgets (buf, RT_BUFSIZ, fp) != NULL)
                     70:     {
                     71:       int n;
                     72:       struct prefix_ipv4 p;
                     73:       struct in_addr tmpmask;
                     74:       struct in_addr gateway;
                     75:       u_char zebra_flags = 0;
                     76: 
                     77:       n = sscanf (buf, "%s %s %s %x %d %d %d %s %d %d %d",
                     78:                  iface, dest, gate, &flags, &refcnt, &use, &metric, 
                     79:                  mask, &mtu, &window, &rtt);
                     80:       if (n != 11)
                     81:        {       
                     82:          zlog_warn ("can't read all of routing information\n");
                     83:          continue;
                     84:        }
                     85:       if (! (flags & RTF_UP))
                     86:        continue;
                     87:       if (! (flags & RTF_GATEWAY))
                     88:        continue;
                     89: 
                     90:       if (flags & RTF_DYNAMIC)
                     91:        zebra_flags |= ZEBRA_FLAG_SELFROUTE;
                     92: 
                     93:       p.family = AF_INET;
                     94:       sscanf (dest, "%lX", (unsigned long *)&p.prefix);
                     95:       sscanf (mask, "%lX", (unsigned long *)&tmpmask);
                     96:       p.prefixlen = ip_masklen (tmpmask);
                     97:       sscanf (gate, "%lX", (unsigned long *)&gateway);
                     98: 
                     99:       rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p, &gateway, NULL, 0, 0, 0, 0);
                    100:     }
                    101: 
                    102:   fclose (fp);
                    103:   return 0;
                    104: }
                    105: 
                    106: #ifdef HAVE_IPV6
                    107: static int
                    108: proc_ipv6_route_read ()
                    109: {
                    110:   FILE *fp;
                    111:   char buf [RT_BUFSIZ];
                    112: 
                    113:   /* Open /proc filesystem */
                    114:   fp = fopen (_PATH_PROCNET_ROUTE6, "r");
                    115:   if (fp == NULL)
                    116:     {
                    117:       zlog_warn ("Can't open %s : %s", _PATH_PROCNET_ROUTE6, 
                    118:                safe_strerror (errno));
                    119:       return -1;
                    120:     }
                    121:   
                    122:   /* There is no title line, so we don't drop first line.  */
                    123:   while (fgets (buf, RT_BUFSIZ, fp) != NULL)
                    124:     {
                    125:       int n;
                    126:       char dest[33], src[33], gate[33];
                    127:       char iface[INTERFACE_NAMSIZ];
                    128:       int dest_plen, src_plen;
                    129:       int metric, use, refcnt, flags;
                    130:       struct prefix_ipv6 p;
                    131:       struct in6_addr gateway;
                    132:       u_char zebra_flags = 0;
                    133: 
                    134:       /* Linux 2.1.x write this information at net/ipv6/route.c
                    135:          rt6_info_node () */
                    136:       n = sscanf (buf, "%32s %02x %32s %02x %32s %08x %08x %08x %08x %s",
                    137:                  dest, &dest_plen, src, &src_plen, gate,
                    138:                  &metric, &use, &refcnt, &flags, iface);
                    139: 
                    140:       if (n != 10)
                    141:        {       
                    142:          /* zlog_warn ("can't read all of routing information %d\n%s\n", n, buf); */
                    143:          continue;
                    144:        }
                    145: 
                    146:       if (! (flags & RTF_UP))
                    147:        continue;
                    148:       if (! (flags & RTF_GATEWAY))
                    149:        continue;
                    150: 
                    151:       if (flags & RTF_DYNAMIC)
                    152:        zebra_flags |= ZEBRA_FLAG_SELFROUTE;
                    153: 
                    154:       p.family = AF_INET6;
                    155:       str2in6_addr (dest, &p.prefix);
                    156:       str2in6_addr (gate, &gateway);
                    157:       p.prefixlen = dest_plen;
                    158: 
                    159:       rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p, &gateway, 0, 0,
                    160:                    metric, 0);
                    161:     }
                    162: 
                    163:   fclose (fp);
                    164:   return 0;
                    165: }
                    166: #endif /* HAVE_IPV6 */
                    167: 
                    168: void
                    169: route_read (void)
                    170: {
                    171:   proc_route_read ();
                    172: #ifdef HAVE_IPV6
                    173:   proc_ipv6_route_read ();
                    174: #endif /* HAVE_IPV6 */
                    175: }