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