Line data    Source code

       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 along
      17             :  * with this program; see the file COPYING; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      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 "queue.h"
      29             : #include "filter.h"
      30             : 
      31             : #include "bgpd/bgpd.h"
      32             : #include "bgpd/bgp_table.h"
      33             : #include "bgpd/bgp_route.h"
      34             : #include "bgpd/bgp_advertise.h"
      35             : #include "bgpd/bgp_attr.h"
      36             : #include "bgpd/bgp_debug.h"
      37             : #include "bgpd/bgp_aspath.h"
      38             : #include "bgpd/bgp_packet.h"
      39             : #include "bgpd/bgp_fsm.h"
      40             : #include "bgpd/bgp_mplsvpn.h"
      41             : #include "bgpd/bgp_updgrp.h"
      42             : 
      43             : /* BGP advertise attribute is used for pack same attribute update into
      44             :    one packet.  To do that we maintain attribute hash in struct
      45             :    peer.  */
      46           0 : struct bgp_advertise_attr *bgp_advertise_attr_new(void)
      47             : {
      48           0 :         return XCALLOC(MTYPE_BGP_ADVERTISE_ATTR,
      49             :                        sizeof(struct bgp_advertise_attr));
      50             : }
      51             : 
      52           0 : void bgp_advertise_attr_free(struct bgp_advertise_attr *baa)
      53             : {
      54           0 :         XFREE(MTYPE_BGP_ADVERTISE_ATTR, baa);
      55           0 : }
      56             : 
      57           0 : static void *bgp_advertise_attr_hash_alloc(void *p)
      58             : {
      59           0 :         struct bgp_advertise_attr *ref = (struct bgp_advertise_attr *)p;
      60           0 :         struct bgp_advertise_attr *baa;
      61             : 
      62           0 :         baa = bgp_advertise_attr_new();
      63           0 :         baa->attr = ref->attr;
      64           0 :         return baa;
      65             : }
      66             : 
      67           0 : unsigned int bgp_advertise_attr_hash_key(const void *p)
      68             : {
      69           0 :         const struct bgp_advertise_attr *baa = p;
      70             : 
      71           0 :         return attrhash_key_make(baa->attr);
      72             : }
      73             : 
      74           0 : bool bgp_advertise_attr_hash_cmp(const void *p1, const void *p2)
      75             : {
      76           0 :         const struct bgp_advertise_attr *baa1 = p1;
      77           0 :         const struct bgp_advertise_attr *baa2 = p2;
      78             : 
      79           0 :         return attrhash_cmp(baa1->attr, baa2->attr);
      80             : }
      81             : 
      82             : /* BGP update and withdraw information is stored in BGP advertise
      83             :    structure.  This structure is referred from BGP adjacency
      84             :    information.  */
      85           0 : struct bgp_advertise *bgp_advertise_new(void)
      86             : {
      87           0 :         return XCALLOC(MTYPE_BGP_ADVERTISE, sizeof(struct bgp_advertise));
      88             : }
      89             : 
      90           0 : void bgp_advertise_free(struct bgp_advertise *adv)
      91             : {
      92           0 :         if (adv->pathi)
      93             :                 /* bgp_advertise bgp_path_info reference */
      94           0 :                 bgp_path_info_unlock(adv->pathi);
      95           0 :         XFREE(MTYPE_BGP_ADVERTISE, adv);
      96           0 : }
      97             : 
      98           0 : void bgp_advertise_add(struct bgp_advertise_attr *baa,
      99             :                        struct bgp_advertise *adv)
     100             : {
     101           0 :         adv->next = baa->adv;
     102           0 :         if (baa->adv)
     103           0 :                 baa->adv->prev = adv;
     104           0 :         baa->adv = adv;
     105           0 : }
     106             : 
     107           0 : void bgp_advertise_delete(struct bgp_advertise_attr *baa,
     108             :                           struct bgp_advertise *adv)
     109             : {
     110           0 :         if (adv->next)
     111           0 :                 adv->next->prev = adv->prev;
     112           0 :         if (adv->prev)
     113           0 :                 adv->prev->next = adv->next;
     114             :         else
     115           0 :                 baa->adv = adv->next;
     116           0 : }
     117             : 
     118           0 : struct bgp_advertise_attr *bgp_advertise_attr_intern(struct hash *hash,
     119             :                                                      struct attr *attr)
     120             : {
     121           0 :         struct bgp_advertise_attr ref;
     122           0 :         struct bgp_advertise_attr *baa;
     123             : 
     124           0 :         ref.attr = bgp_attr_intern(attr);
     125           0 :         baa = (struct bgp_advertise_attr *)hash_get(
     126             :                 hash, &ref, bgp_advertise_attr_hash_alloc);
     127           0 :         baa->refcnt++;
     128             : 
     129           0 :         return baa;
     130             : }
     131             : 
     132           0 : void bgp_advertise_attr_unintern(struct hash *hash,
     133             :                                  struct bgp_advertise_attr *baa)
     134             : {
     135           0 :         if (baa->refcnt)
     136           0 :                 baa->refcnt--;
     137             : 
     138           0 :         if (baa->refcnt && baa->attr)
     139           0 :                 bgp_attr_unintern(&baa->attr);
     140             :         else {
     141           0 :                 if (baa->attr) {
     142           0 :                         hash_release(hash, baa);
     143           0 :                         bgp_attr_unintern(&baa->attr);
     144             :                 }
     145           0 :                 bgp_advertise_attr_free(baa);
     146             :         }
     147           0 : }
     148             : 
     149           0 : bool bgp_adj_out_lookup(struct peer *peer, struct bgp_dest *dest,
     150             :                         uint32_t addpath_tx_id)
     151             : {
     152           0 :         struct bgp_adj_out *adj;
     153           0 :         struct peer_af *paf;
     154           0 :         afi_t afi;
     155           0 :         safi_t safi;
     156           0 :         bool addpath_capable;
     157             : 
     158           0 :         RB_FOREACH (adj, bgp_adj_out_rb, &dest->adj_out)
     159           0 :                 SUBGRP_FOREACH_PEER (adj->subgroup, paf)
     160           0 :                         if (paf->peer == peer) {
     161           0 :                                 afi = SUBGRP_AFI(adj->subgroup);
     162           0 :                                 safi = SUBGRP_SAFI(adj->subgroup);
     163           0 :                                 addpath_capable =
     164           0 :                                         bgp_addpath_encode_tx(peer, afi, safi);
     165             : 
     166             :                                 /* Match on a specific addpath_tx_id if we are
     167             :                                  * using addpath for
     168             :                                  * this
     169             :                                  * peer and if an addpath_tx_id was specified */
     170           0 :                                 if (addpath_capable && addpath_tx_id
     171           0 :                                     && adj->addpath_tx_id != addpath_tx_id)
     172           0 :                                         continue;
     173             : 
     174           0 :                                 return (adj->adv
     175           0 :                                                 ? (adj->adv->baa ? true : false)
     176           0 :                                                 : (adj->attr ? true : false));
     177             :                         }
     178             : 
     179             :         return false;
     180             : }
     181             : 
     182             : 
     183           0 : void bgp_adj_in_set(struct bgp_dest *dest, struct peer *peer, struct attr *attr,
     184             :                     uint32_t addpath_id)
     185             : {
     186           0 :         struct bgp_adj_in *adj;
     187             : 
     188           0 :         for (adj = dest->adj_in; adj; adj = adj->next) {
     189           0 :                 if (adj->peer == peer && adj->addpath_rx_id == addpath_id) {
     190           0 :                         if (adj->attr != attr) {
     191           0 :                                 bgp_attr_unintern(&adj->attr);
     192           0 :                                 adj->attr = bgp_attr_intern(attr);
     193             :                         }
     194           0 :                         return;
     195             :                 }
     196             :         }
     197           0 :         adj = XCALLOC(MTYPE_BGP_ADJ_IN, sizeof(struct bgp_adj_in));
     198           0 :         adj->peer = peer_lock(peer); /* adj_in peer reference */
     199           0 :         adj->attr = bgp_attr_intern(attr);
     200           0 :         adj->uptime = monotime(NULL);
     201           0 :         adj->addpath_rx_id = addpath_id;
     202           0 :         BGP_ADJ_IN_ADD(dest, adj);
     203           0 :         bgp_dest_lock_node(dest);
     204             : }
     205             : 
     206           0 : void bgp_adj_in_remove(struct bgp_dest *dest, struct bgp_adj_in *bai)
     207             : {
     208           0 :         bgp_attr_unintern(&bai->attr);
     209           0 :         BGP_ADJ_IN_DEL(dest, bai);
     210           0 :         bgp_dest_unlock_node(dest);
     211           0 :         peer_unlock(bai->peer); /* adj_in peer reference */
     212           0 :         XFREE(MTYPE_BGP_ADJ_IN, bai);
     213           0 : }
     214             : 
     215           0 : bool bgp_adj_in_unset(struct bgp_dest *dest, struct peer *peer,
     216             :                       uint32_t addpath_id)
     217             : {
     218           0 :         struct bgp_adj_in *adj;
     219           0 :         struct bgp_adj_in *adj_next;
     220             : 
     221           0 :         adj = dest->adj_in;
     222             : 
     223           0 :         if (!adj)
     224             :                 return false;
     225             : 
     226           0 :         while (adj) {
     227           0 :                 adj_next = adj->next;
     228             : 
     229           0 :                 if (adj->peer == peer && adj->addpath_rx_id == addpath_id)
     230           0 :                         bgp_adj_in_remove(dest, adj);
     231             : 
     232             :                 adj = adj_next;
     233             :         }
     234             : 
     235             :         return true;
     236             : }
     237             : 
     238           3 : void bgp_sync_init(struct peer *peer)
     239             : {
     240           3 :         afi_t afi;
     241           3 :         safi_t safi;
     242           3 :         struct bgp_synchronize *sync;
     243             : 
     244          75 :         FOREACH_AFI_SAFI (afi, safi) {
     245          63 :                 sync = XCALLOC(MTYPE_BGP_SYNCHRONISE,
     246             :                                sizeof(struct bgp_synchronize));
     247          63 :                 bgp_adv_fifo_init(&sync->update);
     248          63 :                 bgp_adv_fifo_init(&sync->withdraw);
     249          63 :                 bgp_adv_fifo_init(&sync->withdraw_low);
     250          63 :                 peer->sync[afi][safi] = sync;
     251             :         }
     252           3 : }
     253             : 
     254           2 : void bgp_sync_delete(struct peer *peer)
     255             : {
     256           2 :         afi_t afi;
     257           2 :         safi_t safi;
     258             : 
     259          50 :         FOREACH_AFI_SAFI (afi, safi) {
     260          42 :                 XFREE(MTYPE_BGP_SYNCHRONISE, peer->sync[afi][safi]);
     261             :         }
     262           2 : }