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 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 struct bgp_advertise_attr *bgp_advertise_attr_new(void)
  47 {
  48         return XCALLOC(MTYPE_BGP_ADVERTISE_ATTR,
  49                        sizeof(struct bgp_advertise_attr));
  50 }
  51
  52 void bgp_advertise_attr_free(struct bgp_advertise_attr *baa)
  53 {
  54         XFREE(MTYPE_BGP_ADVERTISE_ATTR, baa);
  55 }
  56
  57 static void *bgp_advertise_attr_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 = bgp_advertise_attr_new();
  63         baa->attr = ref->attr;
  64         return baa;
  65 }
  66
  67 unsigned int bgp_advertise_attr_hash_key(const void *p)
  68 {
  69         const struct bgp_advertise_attr *baa = p;
  70
  71         return attrhash_key_make(baa->attr);
  72 }
  73
  74 bool bgp_advertise_attr_hash_cmp(const void *p1, const void *p2)
  75 {
  76         const struct bgp_advertise_attr *baa1 = p1;
  77         const struct bgp_advertise_attr *baa2 = p2;
  78
  79         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 struct bgp_advertise *bgp_advertise_new(void)
  86 {
  87         return XCALLOC(MTYPE_BGP_ADVERTISE, sizeof(struct bgp_advertise));
  88 }
  89
  90 void bgp_advertise_free(struct bgp_advertise *adv)
  91 {
  92         if (adv->pathi)
  93                 /* bgp_advertise bgp_path_info reference */
  94                 bgp_path_info_unlock(adv->pathi);
  95         XFREE(MTYPE_BGP_ADVERTISE, adv);
  96 }
  97
  98 void bgp_advertise_add(struct bgp_advertise_attr *baa,
  99                        struct bgp_advertise *adv)
 100 {
 101         adv->next = baa->adv;
 102         if (baa->adv)
 103                 baa->adv->prev = adv;
 104         baa->adv = adv;
 105 }
 106
 107 void bgp_advertise_delete(struct bgp_advertise_attr *baa,
 108                           struct bgp_advertise *adv)
 109 {
 110         if (adv->next)
 111                 adv->next->prev = adv->prev;
 112         if (adv->prev)
 113                 adv->prev->next = adv->next;
 114         else
 115                 baa->adv = adv->next;
 116 }
 117
 118 struct bgp_advertise_attr *bgp_advertise_attr_intern(struct hash *hash,
 119                                                      struct attr *attr)
 120 {
 121         struct bgp_advertise_attr ref;
 122         struct bgp_advertise_attr *baa;
 123
 124         ref.attr = bgp_attr_intern(attr);
 125         baa = (struct bgp_advertise_attr *)hash_get(
 126                 hash, &ref, bgp_advertise_attr_hash_alloc);
 127         baa->refcnt++;
 128
 129         return baa;
 130 }
 131
 132 void bgp_advertise_attr_unintern(struct hash *hash,
 133                                  struct bgp_advertise_attr *baa)
 134 {
 135         if (baa->refcnt)
 136                 baa->refcnt--;
 137
 138         if (baa->refcnt && baa->attr)
 139                 bgp_attr_unintern(&baa->attr);
 140         else {
 141                 if (baa->attr) {
 142                         hash_release(hash, baa);
 143                         bgp_attr_unintern(&baa->attr);
 144                 }
 145                 bgp_advertise_attr_free(baa);
 146         }
 147 }
 148
 149 bool bgp_adj_out_lookup(struct peer *peer, struct bgp_dest *dest,
 150                         uint32_t addpath_tx_id)
 151 {
 152         struct bgp_adj_out *adj;
 153         struct peer_af *paf;
 154         afi_t afi;
 155         safi_t safi;
 156         bool addpath_capable;
 157
 158         RB_FOREACH (adj, bgp_adj_out_rb, &dest->adj_out)
 159                 SUBGRP_FOREACH_PEER (adj->subgroup, paf)
 160                         if (paf->peer == peer) {
 161                                 afi = SUBGRP_AFI(adj->subgroup);
 162                                 safi = SUBGRP_SAFI(adj->subgroup);
 163                                 addpath_capable =
 164                                         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                                 if (addpath_capable && addpath_tx_id
 171                                     && adj->addpath_tx_id != addpath_tx_id)
 172                                         continue;
 173
 174                                 return (adj->adv
 175                                                 ? (adj->adv->baa ? true : false)
 176                                                 : (adj->attr ? true : false));
 177                         }
 178
 179         return false;
 180 }
 181
 182
 183 void bgp_adj_in_set(struct bgp_dest *dest, struct peer *peer, struct attr *attr,
 184                     uint32_t addpath_id)
 185 {
 186         struct bgp_adj_in *adj;
 187
 188         for (adj = dest->adj_in; adj; adj = adj->next) {
 189                 if (adj->peer == peer && adj->addpath_rx_id == addpath_id) {
 190                         if (adj->attr != attr) {
 191                                 bgp_attr_unintern(&adj->attr);
 192                                 adj->attr = bgp_attr_intern(attr);
 193                         }
 194                         return;
 195                 }
 196         }
 197         adj = XCALLOC(MTYPE_BGP_ADJ_IN, sizeof(struct bgp_adj_in));
 198         adj->peer = peer_lock(peer); /* adj_in peer reference */
 199         adj->attr = bgp_attr_intern(attr);
 200         adj->uptime = monotime(NULL);
 201         adj->addpath_rx_id = addpath_id;
 202         BGP_ADJ_IN_ADD(dest, adj);
 203         bgp_dest_lock_node(dest);
 204 }
 205
 206 void bgp_adj_in_remove(struct bgp_dest *dest, struct bgp_adj_in *bai)
 207 {
 208         bgp_attr_unintern(&bai->attr);
 209         BGP_ADJ_IN_DEL(dest, bai);
 210         bgp_dest_unlock_node(dest);
 211         peer_unlock(bai->peer); /* adj_in peer reference */
 212         XFREE(MTYPE_BGP_ADJ_IN, bai);
 213 }
 214
 215 bool bgp_adj_in_unset(struct bgp_dest *dest, struct peer *peer,
 216                       uint32_t addpath_id)
 217 {
 218         struct bgp_adj_in *adj;
 219         struct bgp_adj_in *adj_next;
 220
 221         adj = dest->adj_in;
 222
 223         if (!adj)
 224                 return false;
 225
 226         while (adj) {
 227                 adj_next = adj->next;
 228
 229                 if (adj->peer == peer && adj->addpath_rx_id == addpath_id)
 230                         bgp_adj_in_remove(dest, adj);
 231
 232                 adj = adj_next;
 233         }
 234
 235         return true;
 236 }
 237
 238 void bgp_sync_init(struct peer *peer)
 239 {
 240         afi_t afi;
 241         safi_t safi;
 242         struct bgp_synchronize *sync;
 243
 244         FOREACH_AFI_SAFI (afi, safi) {
 245                 sync = XCALLOC(MTYPE_BGP_SYNCHRONISE,
 246                                sizeof(struct bgp_synchronize));
 247                 bgp_adv_fifo_init(&sync->update);
 248                 bgp_adv_fifo_init(&sync->withdraw);
 249                 bgp_adv_fifo_init(&sync->withdraw_low);
 250                 peer->sync[afi][safi] = sync;
 251         }
 252 }
 253
 254 void bgp_sync_delete(struct peer *peer)
 255 {
 256         afi_t afi;
 257         safi_t safi;
 258
 259         FOREACH_AFI_SAFI (afi, safi) {
 260                 XFREE(MTYPE_BGP_SYNCHRONISE, peer->sync[afi][safi]);
 261         }
 262 }