]> git.proxmox.com Git - mirror_frr.git/blobdiff - bgpd/bgp_advertise.c
*: reindent
[mirror_frr.git] / bgpd / bgp_advertise.c
index c44e06773264dc6709146262ad0ff0e3ab057b2c..c7c9631512a0fb359892253e8cec323d9763788a 100644 (file)
 /* BGP advertise attribute is used for pack same attribute update into
    one packet.  To do that we maintain attribute hash in struct
    peer.  */
-struct bgp_advertise_attr *
-baa_new (void)
+struct bgp_advertise_attr *baa_new(void)
 {
-  return (struct bgp_advertise_attr *)
-    XCALLOC (MTYPE_BGP_ADVERTISE_ATTR, sizeof (struct bgp_advertise_attr));
+       return (struct bgp_advertise_attr *)XCALLOC(
+               MTYPE_BGP_ADVERTISE_ATTR, sizeof(struct bgp_advertise_attr));
 }
 
-static void
-baa_free (struct bgp_advertise_attr *baa)
+static void baa_free(struct bgp_advertise_attr *baa)
 {
-  XFREE (MTYPE_BGP_ADVERTISE_ATTR, baa);
+       XFREE(MTYPE_BGP_ADVERTISE_ATTR, baa);
 }
 
-static void *
-baa_hash_alloc (void *p)
+static void *baa_hash_alloc(void *p)
 {
-  struct bgp_advertise_attr * ref = (struct bgp_advertise_attr *) p;
-  struct bgp_advertise_attr *baa;
+       struct bgp_advertise_attr *ref = (struct bgp_advertise_attr *)p;
+       struct bgp_advertise_attr *baa;
 
-  baa = baa_new ();
-  baa->attr = ref->attr;
-  return baa;
+       baa = baa_new();
+       baa->attr = ref->attr;
+       return baa;
 }
 
-unsigned int
-baa_hash_key (void *p)
+unsigned int baa_hash_key(void *p)
 {
-  struct bgp_advertise_attr * baa = (struct bgp_advertise_attr *) p;
+       struct bgp_advertise_attr *baa = (struct bgp_advertise_attr *)p;
 
-  return attrhash_key_make (baa->attr);
+       return attrhash_key_make(baa->attr);
 }
 
-int
-baa_hash_cmp (const void *p1, const void *p2)
+int baa_hash_cmp(const void *p1, const void *p2)
 {
-  const struct bgp_advertise_attr * baa1 = p1;
-  const struct bgp_advertise_attr * baa2 = p2;
+       const struct bgp_advertise_attr *baa1 = p1;
+       const struct bgp_advertise_attr *baa2 = p2;
 
-  return attrhash_cmp (baa1->attr, baa2->attr);
+       return attrhash_cmp(baa1->attr, baa2->attr);
 }
 
 /* BGP update and withdraw information is stored in BGP advertise
    structure.  This structure is referred from BGP adjacency
    information.  */
-struct bgp_advertise *
-bgp_advertise_new (void)
+struct bgp_advertise *bgp_advertise_new(void)
 {
-  return (struct bgp_advertise *)
-    XCALLOC (MTYPE_BGP_ADVERTISE, sizeof (struct bgp_advertise));
+       return (struct bgp_advertise *)XCALLOC(MTYPE_BGP_ADVERTISE,
+                                              sizeof(struct bgp_advertise));
 }
 
-void
-bgp_advertise_free (struct bgp_advertise *adv)
+void bgp_advertise_free(struct bgp_advertise *adv)
 {
-  if (adv->binfo)
-    bgp_info_unlock (adv->binfo); /* bgp_advertise bgp_info reference */
-  XFREE (MTYPE_BGP_ADVERTISE, adv);
+       if (adv->binfo)
+               bgp_info_unlock(
+                       adv->binfo); /* bgp_advertise bgp_info reference */
+       XFREE(MTYPE_BGP_ADVERTISE, adv);
 }
 
-void
-bgp_advertise_add (struct bgp_advertise_attr *baa,
-                  struct bgp_advertise *adv)
+void bgp_advertise_add(struct bgp_advertise_attr *baa,
+                      struct bgp_advertise *adv)
 {
-  adv->next = baa->adv;
-  if (baa->adv)
-    baa->adv->prev = adv;
-  baa->adv = adv;
+       adv->next = baa->adv;
+       if (baa->adv)
+               baa->adv->prev = adv;
+       baa->adv = adv;
 }
 
-void
-bgp_advertise_delete (struct bgp_advertise_attr *baa,
-                     struct bgp_advertise *adv)
+void bgp_advertise_delete(struct bgp_advertise_attr *baa,
+                         struct bgp_advertise *adv)
 {
-  if (adv->next)
-    adv->next->prev = adv->prev;
-  if (adv->prev)
-    adv->prev->next = adv->next;
-  else
-    baa->adv = adv->next;
+       if (adv->next)
+               adv->next->prev = adv->prev;
+       if (adv->prev)
+               adv->prev->next = adv->next;
+       else
+               baa->adv = adv->next;
 }
 
-struct bgp_advertise_attr *
-bgp_advertise_intern (struct hash *hash, struct attr *attr)
+struct bgp_advertise_attr *bgp_advertise_intern(struct hash *hash,
+                                               struct attr *attr)
 {
-  struct bgp_advertise_attr ref;
-  struct bgp_advertise_attr *baa;
+       struct bgp_advertise_attr ref;
+       struct bgp_advertise_attr *baa;
 
-  ref.attr = bgp_attr_intern (attr);
-  baa = (struct bgp_advertise_attr *) hash_get (hash, &ref, baa_hash_alloc);
-  baa->refcnt++;
+       ref.attr = bgp_attr_intern(attr);
+       baa = (struct bgp_advertise_attr *)hash_get(hash, &ref, baa_hash_alloc);
+       baa->refcnt++;
 
-  return baa;
+       return baa;
 }
 
-void
-bgp_advertise_unintern (struct hash *hash, struct bgp_advertise_attr *baa)
+void bgp_advertise_unintern(struct hash *hash, struct bgp_advertise_attr *baa)
 {
-  if (baa->refcnt)
-    baa->refcnt--;
-
-  if (baa->refcnt && baa->attr)
-    bgp_attr_unintern (&baa->attr);
-  else
-    {
-      if (baa->attr)
-       {
-         hash_release (hash, baa);
-         bgp_attr_unintern (&baa->attr);
+       if (baa->refcnt)
+               baa->refcnt--;
+
+       if (baa->refcnt && baa->attr)
+               bgp_attr_unintern(&baa->attr);
+       else {
+               if (baa->attr) {
+                       hash_release(hash, baa);
+                       bgp_attr_unintern(&baa->attr);
+               }
+               baa_free(baa);
        }
-      baa_free (baa);
-    }
 }
 
-int
-bgp_adj_out_lookup (struct peer *peer, struct bgp_node *rn,
-                    u_int32_t addpath_tx_id)
+int bgp_adj_out_lookup(struct peer *peer, struct bgp_node *rn,
+                      u_int32_t addpath_tx_id)
 {
-  struct bgp_adj_out *adj;
-  struct peer_af *paf;
-  afi_t afi;
-  safi_t safi;
-  int addpath_capable;
-
-  for (adj = rn->adj_out; adj; adj = adj->next)
-    SUBGRP_FOREACH_PEER(adj->subgroup, paf)
-      if (paf->peer == peer)
-       {
-          afi = SUBGRP_AFI (adj->subgroup);
-          safi = SUBGRP_SAFI (adj->subgroup);
-          addpath_capable = bgp_addpath_encode_tx (peer, afi, safi);
-
-          /* Match on a specific addpath_tx_id if we are using addpath for this
-           * peer and if an addpath_tx_id was specified */
-          if (addpath_capable && addpath_tx_id && adj->addpath_tx_id != addpath_tx_id)
-            continue;
-
-         return (adj->adv
-                 ? (adj->adv->baa ? 1 : 0)
-                 : (adj->attr ? 1 : 0));
+       struct bgp_adj_out *adj;
+       struct peer_af *paf;
+       afi_t afi;
+       safi_t safi;
+       int addpath_capable;
+
+       for (adj = rn->adj_out; adj; adj = adj->next)
+               SUBGRP_FOREACH_PEER(adj->subgroup, paf)
+       if (paf->peer == peer) {
+               afi = SUBGRP_AFI(adj->subgroup);
+               safi = SUBGRP_SAFI(adj->subgroup);
+               addpath_capable = bgp_addpath_encode_tx(peer, afi, safi);
+
+               /* Match on a specific addpath_tx_id if we are using addpath for
+                * this
+                * peer and if an addpath_tx_id was specified */
+               if (addpath_capable && addpath_tx_id
+                   && adj->addpath_tx_id != addpath_tx_id)
+                       continue;
+
+               return (adj->adv ? (adj->adv->baa ? 1 : 0)
+                                : (adj->attr ? 1 : 0));
        }
 
-  return 0;
+       return 0;
 }
 
 
-void
-bgp_adj_in_set (struct bgp_node *rn, struct peer *peer, struct attr *attr,
-                u_int32_t addpath_id)
+void bgp_adj_in_set(struct bgp_node *rn, struct peer *peer, struct attr *attr,
+                   u_int32_t addpath_id)
 {
-  struct bgp_adj_in *adj;
-
-  for (adj = rn->adj_in; adj; adj = adj->next)
-    {
-      if (adj->peer == peer && adj->addpath_rx_id == addpath_id)
-       {
-         if (adj->attr != attr)
-           {
-             bgp_attr_unintern (&adj->attr);
-             adj->attr = bgp_attr_intern (attr);
-           }
-         return;
+       struct bgp_adj_in *adj;
+
+       for (adj = rn->adj_in; adj; adj = adj->next) {
+               if (adj->peer == peer && adj->addpath_rx_id == addpath_id) {
+                       if (adj->attr != attr) {
+                               bgp_attr_unintern(&adj->attr);
+                               adj->attr = bgp_attr_intern(attr);
+                       }
+                       return;
+               }
        }
-    }
-  adj = XCALLOC (MTYPE_BGP_ADJ_IN, sizeof (struct bgp_adj_in));
-  adj->peer = peer_lock (peer); /* adj_in peer reference */
-  adj->attr = bgp_attr_intern (attr);
-  adj->addpath_rx_id = addpath_id;
-  BGP_ADJ_IN_ADD (rn, adj);
-  bgp_lock_node (rn);
+       adj = XCALLOC(MTYPE_BGP_ADJ_IN, sizeof(struct bgp_adj_in));
+       adj->peer = peer_lock(peer); /* adj_in peer reference */
+       adj->attr = bgp_attr_intern(attr);
+       adj->addpath_rx_id = addpath_id;
+       BGP_ADJ_IN_ADD(rn, adj);
+       bgp_lock_node(rn);
 }
 
-void
-bgp_adj_in_remove (struct bgp_node *rn, struct bgp_adj_in *bai)
+void bgp_adj_in_remove(struct bgp_node *rn, struct bgp_adj_in *bai)
 {
-  bgp_attr_unintern (&bai->attr);
-  BGP_ADJ_IN_DEL (rn, bai);
-  peer_unlock (bai->peer); /* adj_in peer reference */
-  XFREE (MTYPE_BGP_ADJ_IN, bai);
+       bgp_attr_unintern(&bai->attr);
+       BGP_ADJ_IN_DEL(rn, bai);
+       peer_unlock(bai->peer); /* adj_in peer reference */
+       XFREE(MTYPE_BGP_ADJ_IN, bai);
 }
 
-int
-bgp_adj_in_unset (struct bgp_node *rn, struct peer *peer,
-                  u_int32_t addpath_id)
+int bgp_adj_in_unset(struct bgp_node *rn, struct peer *peer,
+                    u_int32_t addpath_id)
 {
-  struct bgp_adj_in *adj;
-  struct bgp_adj_in *adj_next;
+       struct bgp_adj_in *adj;
+       struct bgp_adj_in *adj_next;
 
-  adj = rn->adj_in;
+       adj = rn->adj_in;
 
-  if (!adj)
-    return 0;
+       if (!adj)
+               return 0;
 
-  while (adj)
-    {
-      adj_next = adj->next;
+       while (adj) {
+               adj_next = adj->next;
 
-      if (adj->peer == peer && adj->addpath_rx_id == addpath_id)
-        {
-          bgp_adj_in_remove (rn, adj);
-          bgp_unlock_node (rn);
-        }
+               if (adj->peer == peer && adj->addpath_rx_id == addpath_id) {
+                       bgp_adj_in_remove(rn, adj);
+                       bgp_unlock_node(rn);
+               }
 
-      adj = adj_next;
-    }
+               adj = adj_next;
+       }
 
-  return 1;
+       return 1;
 }
 
-void
-bgp_sync_init (struct peer *peer)
+void bgp_sync_init(struct peer *peer)
 {
-  afi_t afi;
-  safi_t safi;
-  struct bgp_synchronize *sync;
-
-  for (afi = AFI_IP; afi < AFI_MAX; afi++)
-    for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
-      {
-       sync = XCALLOC (MTYPE_BGP_SYNCHRONISE, 
-                       sizeof (struct bgp_synchronize));
-       BGP_ADV_FIFO_INIT (&sync->update);
-       BGP_ADV_FIFO_INIT (&sync->withdraw);
-       BGP_ADV_FIFO_INIT (&sync->withdraw_low);
-       peer->sync[afi][safi] = sync;
-       peer->hash[afi][safi] = hash_create (baa_hash_key, baa_hash_cmp, NULL);
-      }
+       afi_t afi;
+       safi_t safi;
+       struct bgp_synchronize *sync;
+
+       for (afi = AFI_IP; afi < AFI_MAX; afi++)
+               for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
+                       sync = XCALLOC(MTYPE_BGP_SYNCHRONISE,
+                                      sizeof(struct bgp_synchronize));
+                       BGP_ADV_FIFO_INIT(&sync->update);
+                       BGP_ADV_FIFO_INIT(&sync->withdraw);
+                       BGP_ADV_FIFO_INIT(&sync->withdraw_low);
+                       peer->sync[afi][safi] = sync;
+                       peer->hash[afi][safi] =
+                               hash_create(baa_hash_key, baa_hash_cmp, NULL);
+               }
 }
 
-void
-bgp_sync_delete (struct peer *peer)
+void bgp_sync_delete(struct peer *peer)
 {
-  afi_t afi;
-  safi_t safi;
-
-  for (afi = AFI_IP; afi < AFI_MAX; afi++)
-    for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
-      {
-       if (peer->sync[afi][safi])
-         XFREE (MTYPE_BGP_SYNCHRONISE, peer->sync[afi][safi]);
-       peer->sync[afi][safi] = NULL;
-       
-       if (peer->hash[afi][safi])
-         hash_free (peer->hash[afi][safi]);
-       peer->hash[afi][safi] = NULL;
-      }
+       afi_t afi;
+       safi_t safi;
+
+       for (afi = AFI_IP; afi < AFI_MAX; afi++)
+               for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
+                       if (peer->sync[afi][safi])
+                               XFREE(MTYPE_BGP_SYNCHRONISE,
+                                     peer->sync[afi][safi]);
+                       peer->sync[afi][safi] = NULL;
+
+                       if (peer->hash[afi][safi])
+                               hash_free(peer->hash[afi][safi]);
+                       peer->hash[afi][safi] = NULL;
+               }
 }