bgpd/bgp_advertise.c

   1 /* BGP advertisement and adjacency
   2    Copyright (C) 1996, 97, 98, 99, 2000 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 "command.h"
  24 #include "memory.h"
  25 #include "prefix.h"
  26 #include "hash.h"
  27 #include "thread.h"
  28 #include "filter.h"
  29
  30 #include "bgpd/bgpd.h"
  31 #include "bgpd/bgp_table.h"
  32 #include "bgpd/bgp_route.h"
  33 #include "bgpd/bgp_advertise.h"
  34 #include "bgpd/bgp_attr.h"
  35 #include "bgpd/bgp_aspath.h"
  36 #include "bgpd/bgp_packet.h"
  37 #include "bgpd/bgp_fsm.h"
  38 #include "bgpd/bgp_mplsvpn.h"
  39
  40 /* BGP advertise attribute is used for pack same attribute update into
  41    one packet.  To do that we maintain attribute hash in struct
  42    peer.  */
  43 static struct bgp_advertise_attr *
  44 baa_new (void)
  45 {
  46   return (struct bgp_advertise_attr *)
  47     XCALLOC (MTYPE_BGP_ADVERTISE_ATTR, sizeof (struct bgp_advertise_attr));
  48 }
  49
  50 static void
  51 baa_free (struct bgp_advertise_attr *baa)
  52 {
  53   XFREE (MTYPE_BGP_ADVERTISE_ATTR, baa);
  54 }
  55
  56 static void *
  57 baa_hash_alloc (void *p)
  58 {
  59   struct bgp_advertise_attr * ref = (struct bgp_advertise_attr *) p;
  60   struct bgp_advertise_attr *baa;
  61
  62   baa = baa_new ();
  63   baa->attr = ref->attr;
  64   return baa;
  65 }
  66
  67 static unsigned int
  68 baa_hash_key (void *p)
  69 {
  70   struct bgp_advertise_attr * baa = (struct bgp_advertise_attr *) p;
  71
  72   return attrhash_key_make (baa->attr);
  73 }
  74
  75 static int
  76 baa_hash_cmp (const void *p1, const void *p2)
  77 {
  78   const struct bgp_advertise_attr * baa1 = p1;
  79   const struct bgp_advertise_attr * baa2 = p2;
  80
  81   return attrhash_cmp (baa1->attr, baa2->attr);
  82 }
  83
  84 /* BGP update and withdraw information is stored in BGP advertise
  85    structure.  This structure is referred from BGP adjacency
  86    information.  */
  87 static struct bgp_advertise *
  88 bgp_advertise_new (void)
  89 {
  90   return (struct bgp_advertise *)
  91     XCALLOC (MTYPE_BGP_ADVERTISE, sizeof (struct bgp_advertise));
  92 }
  93
  94 static void
  95 bgp_advertise_free (struct bgp_advertise *adv)
  96 {
  97   if (adv->binfo)
  98     bgp_info_unlock (adv->binfo); /* bgp_advertise bgp_info reference */
  99   XFREE (MTYPE_BGP_ADVERTISE, adv);
 100 }
 101
 102 static void
 103 bgp_advertise_add (struct bgp_advertise_attr *baa,
 104                    struct bgp_advertise *adv)
 105 {
 106   adv->next = baa->adv;
 107   if (baa->adv)
 108     baa->adv->prev = adv;
 109   baa->adv = adv;
 110 }
 111
 112 static void
 113 bgp_advertise_delete (struct bgp_advertise_attr *baa,
 114                       struct bgp_advertise *adv)
 115 {
 116   if (adv->next)
 117     adv->next->prev = adv->prev;
 118   if (adv->prev)
 119     adv->prev->next = adv->next;
 120   else
 121     baa->adv = adv->next;
 122 }
 123
 124 static struct bgp_advertise_attr *
 125 bgp_advertise_intern (struct hash *hash, struct attr *attr)
 126 {
 127   struct bgp_advertise_attr ref;
 128   struct bgp_advertise_attr *baa;
 129
 130   ref.attr = bgp_attr_intern (attr);
 131   baa = (struct bgp_advertise_attr *) hash_get (hash, &ref, baa_hash_alloc);
 132   baa->refcnt++;
 133
 134   return baa;
 135 }
 136
 137 static void
 138 bgp_advertise_unintern (struct hash *hash, struct bgp_advertise_attr *baa)
 139 {
 140   if (baa->refcnt)
 141     baa->refcnt--;
 142
 143   if (baa->refcnt && baa->attr)
 144     bgp_attr_unintern (&baa->attr);
 145   else
 146     {
 147       if (baa->attr)
 148         {
 149           hash_release (hash, baa);
 150           bgp_attr_unintern (&baa->attr);
 151         }
 152       baa_free (baa);
 153     }
 154 }
 155
 156 /* BGP adjacency keeps minimal advertisement information.  */
 157 static void
 158 bgp_adj_out_free (struct bgp_adj_out *adj)
 159 {
 160   peer_unlock (adj->peer); /* adj_out peer reference */
 161   XFREE (MTYPE_BGP_ADJ_OUT, adj);
 162 }
 163
 164 int
 165 bgp_adj_out_lookup (struct peer *peer, struct prefix *p,
 166                     afi_t afi, safi_t safi, struct bgp_node *rn)
 167 {
 168   struct bgp_adj_out *adj;
 169
 170   for (adj = rn->adj_out; adj; adj = adj->next)
 171     if (adj->peer == peer)
 172       break;
 173
 174   if (! adj)
 175     return 0;
 176
 177   return (adj->adv
 178           ? (adj->adv->baa ? 1 : 0)
 179           : (adj->attr ? 1 : 0));
 180 }
 181
 182 struct bgp_advertise *
 183 bgp_advertise_clean (struct peer *peer, struct bgp_adj_out *adj,
 184                      afi_t afi, safi_t safi)
 185 {
 186   struct bgp_advertise *adv;
 187   struct bgp_advertise_attr *baa;
 188   struct bgp_advertise *next;
 189   struct bgp_advertise_fifo *fhead;
 190
 191   adv = adj->adv;
 192   baa = adv->baa;
 193   next = NULL;
 194   fhead = (struct bgp_advertise_fifo *)&peer->sync[afi][safi]->withdraw;
 195
 196   if (baa)
 197     {
 198       /* Unlink myself from advertise attribute FIFO.  */
 199       bgp_advertise_delete (baa, adv);
 200
 201       /* Fetch next advertise candidate. */
 202       next = baa->adv;
 203
 204       /* Unintern BGP advertise attribute.  */
 205       bgp_advertise_unintern (peer->hash[afi][safi], baa);
 206
 207       fhead = (struct bgp_advertise_fifo *)&peer->sync[afi][safi]->update;
 208     }
 209
 210   /* Unlink myself from advertisement FIFO.  */
 211   BGP_ADV_FIFO_DEL (fhead, adv);
 212
 213   /* Free memory.  */
 214   bgp_advertise_free (adj->adv);
 215   adj->adv = NULL;
 216
 217   return next;
 218 }
 219
 220 void
 221 bgp_adj_out_set (struct bgp_node *rn, struct peer *peer, struct prefix *p,
 222                  struct attr *attr, afi_t afi, safi_t safi,
 223                  struct bgp_info *binfo)
 224 {
 225   struct bgp_adj_out *adj = NULL;
 226   struct bgp_advertise *adv;
 227
 228   if (DISABLE_BGP_ANNOUNCE)
 229     return;
 230
 231   /* Look for adjacency information. */
 232   if (rn)
 233     {
 234       for (adj = rn->adj_out; adj; adj = adj->next)
 235         if (adj->peer == peer)
 236           break;
 237     }
 238
 239   if (! adj)
 240     {
 241       adj = XCALLOC (MTYPE_BGP_ADJ_OUT, sizeof (struct bgp_adj_out));
 242       adj->peer = peer_lock (peer); /* adj_out peer reference */
 243
 244       if (rn)
 245         {
 246           BGP_ADJ_OUT_ADD (rn, adj);
 247           bgp_lock_node (rn);
 248         }
 249     }
 250
 251   if (adj->adv)
 252     bgp_advertise_clean (peer, adj, afi, safi);
 253
 254   adj->adv = bgp_advertise_new ();
 255
 256   adv = adj->adv;
 257   adv->rn = rn;
 258
 259   assert (adv->binfo == NULL);
 260   adv->binfo = bgp_info_lock (binfo); /* bgp_info adj_out reference */
 261
 262   if (attr)
 263     adv->baa = bgp_advertise_intern (peer->hash[afi][safi], attr);
 264   else
 265     adv->baa = baa_new ();
 266   adv->adj = adj;
 267
 268   /* Add new advertisement to advertisement attribute list. */
 269   bgp_advertise_add (adv->baa, adv);
 270
 271   BGP_ADV_FIFO_ADD (&peer->sync[afi][safi]->update, &adv->fifo);
 272 }
 273
 274 void
 275 bgp_adj_out_unset (struct bgp_node *rn, struct peer *peer, struct prefix *p,
 276                    afi_t afi, safi_t safi)
 277 {
 278   struct bgp_adj_out *adj;
 279   struct bgp_advertise *adv;
 280
 281   if (DISABLE_BGP_ANNOUNCE)
 282     return;
 283
 284   /* Lookup existing adjacency, if it is not there return immediately.  */
 285   for (adj = rn->adj_out; adj; adj = adj->next)
 286     if (adj->peer == peer)
 287       break;
 288
 289   if (! adj)
 290     return;
 291
 292   /* Clearn up previous advertisement.  */
 293   if (adj->adv)
 294     bgp_advertise_clean (peer, adj, afi, safi);
 295
 296   if (adj->attr)
 297     {
 298       /* We need advertisement structure.  */
 299       adj->adv = bgp_advertise_new ();
 300       adv = adj->adv;
 301       adv->rn = rn;
 302       adv->adj = adj;
 303
 304       /* Add to synchronization entry for withdraw announcement.  */
 305       BGP_ADV_FIFO_ADD (&peer->sync[afi][safi]->withdraw, &adv->fifo);
 306
 307       /* Schedule packet write. */
 308       BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
 309     }
 310   else
 311     {
 312       /* Remove myself from adjacency. */
 313       BGP_ADJ_OUT_DEL (rn, adj);
 314
 315       /* Free allocated information.  */
 316       bgp_adj_out_free (adj);
 317
 318       bgp_unlock_node (rn);
 319     }
 320 }
 321
 322 void
 323 bgp_adj_out_remove (struct bgp_node *rn, struct bgp_adj_out *adj,
 324                     struct peer *peer, afi_t afi, safi_t safi)
 325 {
 326   if (adj->attr)
 327     bgp_attr_unintern (&adj->attr);
 328
 329   if (adj->adv)
 330     bgp_advertise_clean (peer, adj, afi, safi);
 331
 332   BGP_ADJ_OUT_DEL (rn, adj);
 333   bgp_adj_out_free (adj);
 334 }
 335
 336 void
 337 bgp_adj_in_set (struct bgp_node *rn, struct peer *peer, struct attr *attr)
 338 {
 339   struct bgp_adj_in *adj;
 340
 341   for (adj = rn->adj_in; adj; adj = adj->next)
 342     {
 343       if (adj->peer == peer)
 344         {
 345           if (adj->attr != attr)
 346             {
 347               bgp_attr_unintern (&adj->attr);
 348               adj->attr = bgp_attr_intern (attr);
 349             }
 350           return;
 351         }
 352     }
 353   adj = XCALLOC (MTYPE_BGP_ADJ_IN, sizeof (struct bgp_adj_in));
 354   adj->peer = peer_lock (peer); /* adj_in peer reference */
 355   adj->attr = bgp_attr_intern (attr);
 356   BGP_ADJ_IN_ADD (rn, adj);
 357   bgp_lock_node (rn);
 358 }
 359
 360 void
 361 bgp_adj_in_remove (struct bgp_node *rn, struct bgp_adj_in *bai)
 362 {
 363   bgp_attr_unintern (&bai->attr);
 364   BGP_ADJ_IN_DEL (rn, bai);
 365   peer_unlock (bai->peer); /* adj_in peer reference */
 366   XFREE (MTYPE_BGP_ADJ_IN, bai);
 367 }
 368
 369 int
 370 bgp_adj_in_unset (struct bgp_node *rn, struct peer *peer)
 371 {
 372   struct bgp_adj_in *adj;
 373
 374   for (adj = rn->adj_in; adj; adj = adj->next)
 375     if (adj->peer == peer)
 376       break;
 377
 378   if (! adj)
 379     return 0;
 380
 381   bgp_adj_in_remove (rn, adj);
 382   bgp_unlock_node (rn);
 383   return 1;
 384 }
 385
 386 void
 387 bgp_sync_init (struct peer *peer)
 388 {
 389   afi_t afi;
 390   safi_t safi;
 391   struct bgp_synchronize *sync;
 392
 393   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 394     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
 395       {
 396         sync = XCALLOC (MTYPE_BGP_SYNCHRONISE,
 397                         sizeof (struct bgp_synchronize));
 398         BGP_ADV_FIFO_INIT (&sync->update);
 399         BGP_ADV_FIFO_INIT (&sync->withdraw);
 400         BGP_ADV_FIFO_INIT (&sync->withdraw_low);
 401         peer->sync[afi][safi] = sync;
 402         peer->hash[afi][safi] = hash_create (baa_hash_key, baa_hash_cmp);
 403       }
 404 }
 405
 406 void
 407 bgp_sync_delete (struct peer *peer)
 408 {
 409   afi_t afi;
 410   safi_t safi;
 411
 412   for (afi = AFI_IP; afi < AFI_MAX; afi++)
 413     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
 414       {
 415         if (peer->sync[afi][safi])
 416           XFREE (MTYPE_BGP_SYNCHRONISE, peer->sync[afi][safi]);
 417         peer->sync[afi][safi] = NULL;
 418
 419         if (peer->hash[afi][safi])
 420           hash_free (peer->hash[afi][safi]);
 421         peer->hash[afi][safi] = NULL;
 422       }
 423 }