bgpd/bgp_table.c

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