Return to bgp_table.c CVS log

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

Annotation of embedaddon/quagga/bgpd/bgp_table.c, revision 1.1.1.3

1.1       misho       1: /* BGP routing table
                      2:    Copyright (C) 1998, 2001 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: #include <zebra.h>
                     22: 
                     23: #include "prefix.h"
                     24: #include "memory.h"
                     25: #include "sockunion.h"
                     26: #include "vty.h"
1.1.1.3 ! misho      27: #include "filter.h"
1.1       misho      28: 
                     29: #include "bgpd/bgpd.h"
                     30: #include "bgpd/bgp_table.h"
                     31: 
                     32: void
                     33: bgp_table_lock (struct bgp_table *rt)
                     34: {
                     35:   rt->lock++;
                     36: }
                     37: 
                     38: void
                     39: bgp_table_unlock (struct bgp_table *rt)
                     40: {
                     41:   assert (rt->lock > 0);
                     42:   rt->lock--;
                     43: 
1.1.1.2   misho      44:   if (rt->lock != 0) 
1.1       misho      45:     {
1.1.1.2   misho      46:       return;
1.1       misho      47:     }
                     48: 
1.1.1.2   misho      49:   route_table_finish (rt->route_table);
                     50:   rt->route_table = NULL;
1.1       misho      51: 
                     52:   if (rt->owner)
                     53:     {
                     54:       peer_unlock (rt->owner);
                     55:       rt->owner = NULL;
                     56:     }
                     57: 
                     58:   XFREE (MTYPE_BGP_TABLE, rt);
                     59: }
                     60: 
                     61: void
1.1.1.2   misho      62: bgp_table_finish (struct bgp_table **rt)
1.1       misho      63: {
1.1.1.2   misho      64:   if (*rt != NULL)
1.1       misho      65:     {
1.1.1.2   misho      66:       bgp_table_unlock(*rt);
                     67:       *rt = NULL;
1.1       misho      68:     }
                     69: }
                     70: 
1.1.1.2   misho      71: /*
                     72:  * bgp_node_create
                     73:  */
                     74: static struct route_node *
                     75: bgp_node_create (route_table_delegate_t *delegate, struct route_table *table)
1.1       misho      76: {
                     77:   struct bgp_node *node;
1.1.1.2   misho      78:   node = XCALLOC (MTYPE_BGP_NODE, sizeof (struct bgp_node));
                     79:   return bgp_node_to_rnode (node);
1.1       misho      80: }
                     81: 
1.1.1.2   misho      82: /*
                     83:  * bgp_node_destroy
                     84:  */
1.1       misho      85: static void
1.1.1.2   misho      86: bgp_node_destroy (route_table_delegate_t *delegate,
                     87:                  struct route_table *table, struct route_node *node)
1.1       misho      88: {
1.1.1.2   misho      89:   struct bgp_node *bgp_node;
                     90:   bgp_node = bgp_node_from_rnode (node);
                     91:   XFREE (MTYPE_BGP_NODE, bgp_node);
1.1       misho      92: }
                     93: 
1.1.1.2   misho      94: /*
                     95:  * Function vector to customize the behavior of the route table
                     96:  * library for BGP route tables.
                     97:  */
                     98: route_table_delegate_t bgp_table_delegate = {
                     99:   .create_node = bgp_node_create,
                    100:   .destroy_node = bgp_node_destroy
                    101: };
1.1       misho     102: 
1.1.1.2   misho     103: /*
                    104:  * bgp_table_init
                    105:  */
                    106: struct bgp_table *
                    107: bgp_table_init (afi_t afi, safi_t safi)
1.1       misho     108: {
1.1.1.2   misho     109:   struct bgp_table *rt;
1.1       misho     110: 
1.1.1.2   misho     111:   rt = XCALLOC (MTYPE_BGP_TABLE, sizeof (struct bgp_table));
1.1       misho     112: 
1.1.1.2   misho     113:   rt->route_table = route_table_init_with_delegate (&bgp_table_delegate);
1.1       misho     114: 
1.1.1.2   misho     115:   /*
                    116:    * Set up back pointer to bgp_table.
                    117:    */
                    118:   rt->route_table->info = rt;
1.1       misho     119: 
1.1.1.2   misho     120:   bgp_table_lock (rt);
                    121:   rt->type = BGP_TABLE_MAIN;
                    122:   rt->afi = afi;
                    123:   rt->safi = safi;
1.1       misho     124: 
1.1.1.2   misho     125:   return rt;
1.1       misho     126: }