bgpd/bgp_updgrp.h

   1 /**
   2  * bgp_updgrp.c: BGP update group structures
   3  *
   4  * @copyright Copyright (C) 2014 Cumulus Networks, Inc.
   5  *
   6  * @author Avneesh Sachdev <avneesh@sproute.net>
   7  * @author Rajesh Varadarajan <rajesh@sproute.net>
   8  * @author Pradosh Mohapatra <pradosh@sproute.net>
   9  *
  10  * This file is part of GNU Zebra.
  11  *
  12  * GNU Zebra is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License as published by the
  14  * Free Software Foundation; either version 2, or (at your option) any
  15  * later version.
  16  *
  17  * GNU Zebra is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License along
  23  * with this program; see the file COPYING; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  25  */
  26
  27 #ifndef _QUAGGA_BGP_UPDGRP_H
  28 #define _QUAGGA_BGP_UPDGRP_H
  29
  30 #include "bgp_advertise.h"
  31
  32 #define BGP_DEFAULT_SUBGROUP_COALESCE_TIME 200
  33
  34 #define PEER_UPDGRP_FLAGS                                                      \
  35         (PEER_FLAG_LOCAL_AS_NO_PREPEND | PEER_FLAG_LOCAL_AS_REPLACE_AS)
  36
  37 #define PEER_UPDGRP_AF_FLAGS                                                   \
  38         (PEER_FLAG_SEND_COMMUNITY | PEER_FLAG_SEND_EXT_COMMUNITY               \
  39          | PEER_FLAG_DEFAULT_ORIGINATE | PEER_FLAG_REFLECTOR_CLIENT            \
  40          | PEER_FLAG_RSERVER_CLIENT | PEER_FLAG_NEXTHOP_SELF                   \
  41          | PEER_FLAG_NEXTHOP_UNCHANGED | PEER_FLAG_FORCE_NEXTHOP_SELF          \
  42          | PEER_FLAG_AS_PATH_UNCHANGED | PEER_FLAG_MED_UNCHANGED               \
  43          | PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED | PEER_FLAG_REMOVE_PRIVATE_AS     \
  44          | PEER_FLAG_REMOVE_PRIVATE_AS_ALL                                     \
  45          | PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE                                 \
  46          | PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE                             \
  47          | PEER_FLAG_ADDPATH_TX_ALL_PATHS                                      \
  48          | PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS | PEER_FLAG_AS_OVERRIDE)
  49
  50 #define PEER_UPDGRP_CAP_FLAGS (PEER_CAP_AS4_RCV)
  51
  52 #define PEER_UPDGRP_AF_CAP_FLAGS                                               \
  53         (PEER_CAP_ORF_PREFIX_SM_RCV | PEER_CAP_ORF_PREFIX_SM_OLD_RCV           \
  54          | PEER_CAP_ADDPATH_AF_TX_ADV | PEER_CAP_ADDPATH_AF_RX_RCV             \
  55          | PEER_CAP_ENHE_AF_NEGO)
  56
  57 typedef enum { BGP_ATTR_VEC_NH = 0, BGP_ATTR_VEC_MAX } bpacket_attr_vec_type;
  58
  59 typedef struct {
  60         u_int32_t flags;
  61         unsigned long offset;
  62 } bpacket_attr_vec;
  63
  64 #define BPKT_ATTRVEC_FLAGS_UPDATED        (1 << 0)
  65 #define BPKT_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS   (1 << 1)
  66 #define BPKT_ATTRVEC_FLAGS_REFLECTED (1 << 2)
  67 #define BPKT_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED   (1 << 3)
  68 #define BPKT_ATTRVEC_FLAGS_RMAP_IPV4_NH_CHANGED   (1 << 4)
  69 #define BPKT_ATTRVEC_FLAGS_RMAP_IPV6_GNH_CHANGED  (1 << 5)
  70 #define BPKT_ATTRVEC_FLAGS_RMAP_IPV6_LNH_CHANGED  (1 << 6)
  71
  72 typedef struct bpacket_attr_vec_arr {
  73         bpacket_attr_vec entries[BGP_ATTR_VEC_MAX];
  74 } bpacket_attr_vec_arr;
  75
  76 struct bpacket {
  77         /* for being part of an update subgroup's message list */
  78         TAILQ_ENTRY(bpacket) pkt_train;
  79
  80         /* list of peers (well, peer_afs) that the packet needs to be sent to */
  81         LIST_HEAD(pkt_peer_list, peer_af) peers;
  82
  83         struct stream *buffer;
  84         bpacket_attr_vec_arr arr;
  85
  86         unsigned int ver;
  87 };
  88
  89 struct bpacket_queue {
  90         TAILQ_HEAD(pkt_queue, bpacket) pkts;
  91
  92 #if 0
  93   /* A dummy packet that is used to thread all peers that have
  94      completed their work */
  95   struct bpacket sentinel;
  96 #endif
  97
  98         unsigned int conf_max_count;
  99         unsigned int curr_count;
 100         unsigned int hwm_count;
 101         unsigned int max_count_reached_count;
 102 };
 103
 104 struct update_group {
 105         /* back pointer to the BGP instance */
 106         struct bgp *bgp;
 107
 108         /* list of subgroups that belong to the update group */
 109         LIST_HEAD(subgrp_list, update_subgroup) subgrps;
 110
 111         /* lazy way to store configuration common to all peers
 112            hash function will compute from this data */
 113         struct peer *conf;
 114
 115         afi_t afi;
 116         safi_t safi;
 117         int afid;
 118
 119         uint64_t id;
 120         time_t uptime;
 121
 122         u_int32_t join_events;
 123         u_int32_t prune_events;
 124         u_int32_t merge_events;
 125         u_int32_t updgrp_switch_events;
 126         u_int32_t peer_refreshes_combined;
 127         u_int32_t adj_count;
 128         u_int32_t split_events;
 129         u_int32_t merge_checks_triggered;
 130
 131         u_int32_t subgrps_created;
 132         u_int32_t subgrps_deleted;
 133
 134         u_int32_t num_dbg_en_peers;
 135 };
 136
 137 /*
 138  * Shorthand for a global statistics counter.
 139  */
 140 #define UPDGRP_GLOBAL_STAT(updgrp, stat)                                       \
 141         ((updgrp)->bgp->update_group_stats.stat)
 142
 143 /*
 144  * Add the given value to a counter on an update group and the bgp
 145  * instance.
 146  */
 147 #define UPDGRP_INCR_STAT_BY(updgrp, stat, value)                               \
 148         do {                                                                   \
 149                 (updgrp)->stat += (value);                                     \
 150                 UPDGRP_GLOBAL_STAT(updgrp, stat) += (value);                   \
 151         } while (0)
 152
 153 /*
 154  * Increment a counter on a update group and its parent structures.
 155  */
 156 #define UPDGRP_INCR_STAT(subgrp, stat) UPDGRP_INCR_STAT_BY(subgrp, stat, 1)
 157
 158 struct update_subgroup {
 159         /* back pointer to the parent update group */
 160         struct update_group *update_group;
 161
 162         /* list of peers that belong to the subgroup */
 163         LIST_HEAD(peer_list, peer_af) peers;
 164         int peer_count;
 165
 166         /* for being part of an update group's subgroup list */
 167         LIST_ENTRY(update_subgroup) updgrp_train;
 168
 169         struct bpacket_queue pkt_queue;
 170
 171         /*
 172          * List of adj-out structures for this subgroup.
 173          * It essentially represents the snapshot of every prefix that
 174          * has been advertised to the members of the subgroup
 175          */
 176         TAILQ_HEAD(adjout_queue, bgp_adj_out) adjq;
 177
 178         /* packet buffer for update generation */
 179         struct stream *work;
 180
 181         /* We use a separate stream to encode MP_REACH_NLRI for efficient
 182          * NLRI packing. peer->work stores all the other attributes. The
 183          * actual packet is then constructed by concatenating the two.
 184          */
 185         struct stream *scratch;
 186
 187         /* synchronization list and time */
 188         struct bgp_synchronize *sync;
 189
 190         /* send prefix count */
 191         unsigned long scount;
 192
 193         /* announcement attribute hash */
 194         struct hash *hash;
 195
 196         struct thread *t_coalesce;
 197         u_int32_t v_coalesce;
 198
 199         struct thread *t_merge_check;
 200
 201         /* table version that the subgroup has caught up to. */
 202         uint64_t version;
 203
 204         /* version maintained to record adj changes */
 205         uint64_t adj_version;
 206
 207         time_t uptime;
 208
 209         /*
 210          * Identifying information about the subgroup that this subgroup was
 211          * split
 212          * from, if any.
 213          */
 214         struct {
 215                 uint64_t update_group_id;
 216                 uint64_t subgroup_id;
 217         } split_from;
 218
 219         u_int32_t join_events;
 220         u_int32_t prune_events;
 221
 222         /*
 223          * This is bumped up when another subgroup merges into this one.
 224          */
 225         u_int32_t merge_events;
 226         u_int32_t updgrp_switch_events;
 227         u_int32_t peer_refreshes_combined;
 228         u_int32_t adj_count;
 229         u_int32_t split_events;
 230         u_int32_t merge_checks_triggered;
 231
 232         uint64_t id;
 233
 234         u_int16_t sflags;
 235
 236         /* Subgroup flags, see below  */
 237         u_int16_t flags;
 238 };
 239
 240 /*
 241  * We need to do an outbound refresh to get this subgroup into a
 242  * consistent state.
 243  */
 244 #define SUBGRP_FLAG_NEEDS_REFRESH         (1 << 0)
 245
 246 #define SUBGRP_STATUS_DEFAULT_ORIGINATE   (1 << 0)
 247
 248 /*
 249  * Add the given value to the specified counter on a subgroup and its
 250  * parent structures.
 251  */
 252 #define SUBGRP_INCR_STAT_BY(subgrp, stat, value)                               \
 253         do {                                                                   \
 254                 (subgrp)->stat += (value);                                     \
 255                 if ((subgrp)->update_group)                                    \
 256                         UPDGRP_INCR_STAT_BY((subgrp)->update_group, stat,      \
 257                                             value);                            \
 258         } while (0)
 259
 260 /*
 261  * Increment a counter on a subgroup and its parent structures.
 262  */
 263 #define SUBGRP_INCR_STAT(subgrp, stat) SUBGRP_INCR_STAT_BY(subgrp, stat, 1)
 264
 265 /*
 266  * Decrement a counter on a subgroup and its parent structures.
 267  */
 268 #define SUBGRP_DECR_STAT(subgrp, stat) SUBGRP_INCR_STAT_BY(subgrp, stat, -1)
 269
 270 typedef int (*updgrp_walkcb)(struct update_group *updgrp, void *ctx);
 271
 272 /* really a private structure */
 273 struct updwalk_context {
 274         struct vty *vty;
 275         struct bgp_node *rn;
 276         struct bgp_info *ri;
 277         uint64_t updgrp_id;
 278         uint64_t subgrp_id;
 279         bgp_policy_type_e policy_type;
 280         const char *policy_name;
 281         int policy_event_start_flag;
 282         int policy_route_update;
 283         updgrp_walkcb cb;
 284         void *context;
 285         u_int8_t flags;
 286
 287 #define UPDWALK_FLAGS_ADVQUEUE   (1 << 0)
 288 #define UPDWALK_FLAGS_ADVERTISED (1 << 1)
 289 };
 290
 291 #define UPDWALK_CONTINUE HASHWALK_CONTINUE
 292 #define UPDWALK_ABORT HASHWALK_ABORT
 293
 294 #define PAF_PEER(p)        ((p)->peer)
 295 #define PAF_SUBGRP(p)      ((p)->subgroup)
 296 #define PAF_UPDGRP(p)      ((p)->subgroup->update_group)
 297 #define PAF_PKTQ(f)        SUBGRP_PKTQ((f)->subgroup)
 298
 299 #define UPDGRP_PEER(u)     ((u)->conf)
 300 #define UPDGRP_AFI(u)      ((u)->afi)
 301 #define UPDGRP_SAFI(u)     ((u)->safi)
 302 #define UPDGRP_INST(u)     ((u)->bgp)
 303 #define UPDGRP_AFFLAGS(u) ((u)->conf->af_flags[UPDGRP_AFI(u)][UPDGRP_SAFI(u)])
 304 #define UPDGRP_DBG_ON(u)   ((u)->num_dbg_en_peers)
 305 #define UPDGRP_PEER_DBG_EN(u)  (((u)->num_dbg_en_peers)++)
 306 #define UPDGRP_PEER_DBG_DIS(u) (((u)->num_dbg_en_peers)--)
 307 #define UPDGRP_PEER_DBG_OFF(u) (u)->num_dbg_en_peers = 0
 308
 309 #define SUBGRP_AFI(s)      UPDGRP_AFI((s)->update_group)
 310 #define SUBGRP_SAFI(s)     UPDGRP_SAFI((s)->update_group)
 311 #define SUBGRP_PEER(s)     UPDGRP_PEER((s)->update_group)
 312 #define SUBGRP_PCOUNT(s)   ((s)->peer_count)
 313 #define SUBGRP_PFIRST(s)   LIST_FIRST(&((s)->peers))
 314 #define SUBGRP_PKTQ(s)     &((s)->pkt_queue)
 315 #define SUBGRP_INST(s)     UPDGRP_INST((s)->update_group)
 316 #define SUBGRP_AFFLAGS(s)  UPDGRP_AFFLAGS((s)->update_group)
 317 #define SUBGRP_UPDGRP(s)   ((s)->update_group)
 318
 319 /*
 320  * Walk all subgroups in an update group.
 321  */
 322 #define UPDGRP_FOREACH_SUBGRP(updgrp, subgrp)                                  \
 323         LIST_FOREACH(subgrp, &((updgrp)->subgrps), updgrp_train)
 324
 325 #define UPDGRP_FOREACH_SUBGRP_SAFE(updgrp, subgrp, tmp_subgrp)                 \
 326         LIST_FOREACH_SAFE(subgrp, &((updgrp)->subgrps), updgrp_train,          \
 327                           tmp_subgrp)
 328
 329 #define SUBGRP_FOREACH_PEER(subgrp, paf)                                       \
 330         LIST_FOREACH(paf, &(subgrp->peers), subgrp_train)
 331
 332 #define SUBGRP_FOREACH_PEER_SAFE(subgrp, paf, temp_paf)                        \
 333         LIST_FOREACH_SAFE(paf, &(subgrp->peers), subgrp_train, temp_paf)
 334
 335 #define SUBGRP_FOREACH_ADJ(subgrp, adj)                                        \
 336         TAILQ_FOREACH(adj, &(subgrp->adjq), subgrp_adj_train)
 337
 338 #define SUBGRP_FOREACH_ADJ_SAFE(subgrp, adj, adj_temp)                         \
 339         TAILQ_FOREACH_SAFE(adj, &(subgrp->adjq), subgrp_adj_train, adj_temp)
 340
 341 /* Prototypes.  */
 342 /* bgp_updgrp.c */
 343 extern void update_bgp_group_init(struct bgp *);
 344 extern void udpate_bgp_group_free(struct bgp *);
 345
 346 extern void update_group_show(struct bgp *bgp, afi_t afi, safi_t safi,
 347                               struct vty *vty, uint64_t subgrp_id);
 348 extern void update_group_show_stats(struct bgp *bgp, struct vty *vty);
 349 extern void update_group_adjust_peer(struct peer_af *paf);
 350 extern int update_group_adjust_soloness(struct peer *peer, int set);
 351
 352 extern void update_subgroup_remove_peer(struct update_subgroup *,
 353                                         struct peer_af *);
 354 extern struct bgp_table *update_subgroup_rib(struct update_subgroup *);
 355 extern void update_subgroup_split_peer(struct peer_af *, struct update_group *);
 356 extern int update_subgroup_check_merge(struct update_subgroup *, const char *);
 357 extern int update_subgroup_trigger_merge_check(struct update_subgroup *,
 358                                                int force);
 359 extern void update_group_policy_update(struct bgp *bgp, bgp_policy_type_e ptype,
 360                                        const char *pname, int route_update,
 361                                        int start_event);
 362 extern void update_group_af_walk(struct bgp *bgp, afi_t afi, safi_t safi,
 363                                  updgrp_walkcb cb, void *ctx);
 364 extern void update_group_walk(struct bgp *bgp, updgrp_walkcb cb, void *ctx);
 365 extern void update_group_periodic_merge(struct bgp *bgp);
 366 extern int
 367 update_group_refresh_default_originate_route_map(struct thread *thread);
 368 extern void update_group_start_advtimer(struct bgp *bgp);
 369
 370 extern void update_subgroup_inherit_info(struct update_subgroup *to,
 371                                          struct update_subgroup *from);
 372
 373 /* bgp_updgrp_packet.c */
 374 extern struct bpacket *bpacket_alloc(void);
 375 extern void bpacket_free(struct bpacket *pkt);
 376 extern void bpacket_queue_init(struct bpacket_queue *q);
 377 extern void bpacket_queue_cleanup(struct bpacket_queue *q);
 378 extern void bpacket_queue_sanity_check(struct bpacket_queue *q);
 379 extern struct bpacket *bpacket_queue_add(struct bpacket_queue *q,
 380                                          struct stream *s,
 381                                          struct bpacket_attr_vec_arr *vecarr);
 382 struct bpacket *bpacket_queue_remove(struct bpacket_queue *q);
 383 extern struct bpacket *bpacket_queue_first(struct bpacket_queue *q);
 384 struct bpacket *bpacket_queue_last(struct bpacket_queue *q);
 385 unsigned int bpacket_queue_length(struct bpacket_queue *q);
 386 unsigned int bpacket_queue_hwm_length(struct bpacket_queue *q);
 387 int bpacket_queue_is_full(struct bgp *bgp, struct bpacket_queue *q);
 388 extern void bpacket_queue_advance_peer(struct peer_af *paf);
 389 extern void bpacket_queue_remove_peer(struct peer_af *paf);
 390 extern void bpacket_add_peer(struct bpacket *pkt, struct peer_af *paf);
 391 unsigned int bpacket_queue_virtual_length(struct peer_af *paf);
 392 extern void bpacket_queue_show_vty(struct bpacket_queue *q, struct vty *vty);
 393 int subgroup_packets_to_build(struct update_subgroup *subgrp);
 394 extern struct bpacket *subgroup_update_packet(struct update_subgroup *s);
 395 extern struct bpacket *subgroup_withdraw_packet(struct update_subgroup *s);
 396 extern struct stream *bpacket_reformat_for_peer(struct bpacket *pkt,
 397                                                 struct peer_af *paf);
 398 extern void bpacket_attr_vec_arr_reset(struct bpacket_attr_vec_arr *vecarr);
 399 extern void bpacket_attr_vec_arr_set_vec(struct bpacket_attr_vec_arr *vecarr,
 400                                          bpacket_attr_vec_type type,
 401                                          struct stream *s, struct attr *attr);
 402 extern void subgroup_default_update_packet(struct update_subgroup *subgrp,
 403                                            struct attr *attr,
 404                                            struct peer *from);
 405 extern void subgroup_default_withdraw_packet(struct update_subgroup *subgrp);
 406
 407 /* bgp_updgrp_adv.c */
 408 extern struct bgp_advertise *
 409 bgp_advertise_clean_subgroup(struct update_subgroup *subgrp,
 410                              struct bgp_adj_out *adj);
 411 extern void update_group_show_adj_queue(struct bgp *bgp, afi_t afi, safi_t safi,
 412                                         struct vty *vty, uint64_t id);
 413 extern void update_group_show_advertised(struct bgp *bgp, afi_t afi,
 414                                          safi_t safi, struct vty *vty,
 415                                          uint64_t id);
 416 extern void update_group_show_packet_queue(struct bgp *bgp, afi_t afi,
 417                                            safi_t safi, struct vty *vty,
 418                                            uint64_t id);
 419 extern void subgroup_announce_route(struct update_subgroup *subgrp);
 420 extern void subgroup_announce_all(struct update_subgroup *subgrp);
 421
 422 extern void subgroup_default_originate(struct update_subgroup *subgrp,
 423                                        int withdraw);
 424 extern void group_announce_route(struct bgp *bgp, afi_t afi, safi_t safi,
 425                                  struct bgp_node *rn, struct bgp_info *ri);
 426 extern void subgroup_clear_table(struct update_subgroup *subgrp);
 427 extern void update_group_announce(struct bgp *bgp);
 428 extern void update_group_announce_rrclients(struct bgp *bgp);
 429 extern void peer_af_announce_route(struct peer_af *paf, int combine);
 430 extern struct bgp_adj_out *bgp_adj_out_alloc(struct update_subgroup *subgrp,
 431                                              struct bgp_node *rn,
 432                                              u_int32_t addpath_tx_id);
 433 extern void bgp_adj_out_remove_subgroup(struct bgp_node *rn,
 434                                         struct bgp_adj_out *adj,
 435                                         struct update_subgroup *subgrp);
 436 extern void bgp_adj_out_set_subgroup(struct bgp_node *rn,
 437                                      struct update_subgroup *subgrp,
 438                                      struct attr *attr, struct bgp_info *binfo);
 439 extern void bgp_adj_out_unset_subgroup(struct bgp_node *rn,
 440                                        struct update_subgroup *subgrp,
 441                                        char withdraw, u_int32_t addpath_tx_id);
 442 void subgroup_announce_table(struct update_subgroup *subgrp,
 443                              struct bgp_table *table);
 444 extern void subgroup_trigger_write(struct update_subgroup *subgrp);
 445
 446 extern int update_group_clear_update_dbg(struct update_group *updgrp,
 447                                          void *arg);
 448
 449 extern void update_bgp_group_free(struct bgp *bgp);
 450 extern int bgp_addpath_encode_tx(struct peer *peer, afi_t afi, safi_t safi);
 451 extern int bgp_addpath_tx_path(struct peer *peer, afi_t afi, safi_t safi,
 452                                struct bgp_info *ri);
 453
 454 /*
 455  * Inline functions
 456  */
 457
 458 /*
 459  * bpacket_queue_is_empty
 460  */
 461 static inline int bpacket_queue_is_empty(struct bpacket_queue *queue)
 462 {
 463
 464         /*
 465          * The packet queue is empty if it only contains a sentinel.
 466          */
 467         if (queue->curr_count != 1)
 468                 return 0;
 469
 470         assert(bpacket_queue_first(queue)->buffer == NULL);
 471         return 1;
 472 }
 473
 474 /*
 475  * bpacket_next
 476  *
 477  * Returns the packet after the given packet in a bpacket queue.
 478  */
 479 static inline struct bpacket *bpacket_next(struct bpacket *pkt)
 480 {
 481         return TAILQ_NEXT(pkt, pkt_train);
 482 }
 483
 484 /*
 485  * update_group_adjust_peer_afs
 486  *
 487  * Adjust all peer_af structures for the given peer.
 488  */
 489 static inline void update_group_adjust_peer_afs(struct peer *peer)
 490 {
 491         struct peer_af *paf;
 492         int afidx;
 493
 494         for (afidx = BGP_AF_START; afidx < BGP_AF_MAX; afidx++) {
 495                 paf = peer->peer_af_array[afidx];
 496                 if (paf != NULL)
 497                         update_group_adjust_peer(paf);
 498         }
 499 }
 500
 501 /*
 502  * update_group_remove_peer_afs
 503  *
 504  * Remove all peer_af structures for the given peer from their subgroups.
 505  */
 506 static inline void update_group_remove_peer_afs(struct peer *peer)
 507 {
 508         struct peer_af *paf;
 509         int afidx;
 510
 511         for (afidx = BGP_AF_START; afidx < BGP_AF_MAX; afidx++) {
 512                 paf = peer->peer_af_array[afidx];
 513                 if (paf != NULL)
 514                         update_subgroup_remove_peer(PAF_SUBGRP(paf), paf);
 515         }
 516 }
 517
 518 /*
 519  * update_subgroup_needs_refresh
 520  */
 521 static inline int
 522 update_subgroup_needs_refresh(const struct update_subgroup *subgrp)
 523 {
 524         if (CHECK_FLAG(subgrp->flags, SUBGRP_FLAG_NEEDS_REFRESH))
 525                 return 1;
 526         else
 527                 return 0;
 528 }
 529
 530 /*
 531  * update_subgroup_set_needs_refresh
 532  */
 533 static inline void
 534 update_subgroup_set_needs_refresh(struct update_subgroup *subgrp, int value)
 535 {
 536         if (value)
 537                 SET_FLAG(subgrp->flags, SUBGRP_FLAG_NEEDS_REFRESH);
 538         else
 539                 UNSET_FLAG(subgrp->flags, SUBGRP_FLAG_NEEDS_REFRESH);
 540 }
 541
 542 static inline struct update_subgroup *peer_subgroup(struct peer *peer,
 543                                                     afi_t afi, safi_t safi)
 544 {
 545         struct peer_af *paf;
 546
 547         paf = peer_af_find(peer, afi, safi);
 548         if (paf)
 549                 return PAF_SUBGRP(paf);
 550         return NULL;
 551 }
 552
 553 /*
 554  * update_group_adjust_peer_afs
 555  *
 556  * Adjust all peer_af structures for the given peer.
 557  */
 558 static inline void bgp_announce_peer(struct peer *peer)
 559 {
 560         struct peer_af *paf;
 561         int afidx;
 562
 563         for (afidx = BGP_AF_START; afidx < BGP_AF_MAX; afidx++) {
 564                 paf = peer->peer_af_array[afidx];
 565                 if (paf != NULL)
 566                         subgroup_announce_all(PAF_SUBGRP(paf));
 567         }
 568 }
 569
 570 /**
 571  * advertise_list_is_empty
 572  */
 573 static inline int advertise_list_is_empty(struct update_subgroup *subgrp)
 574 {
 575         if (!BGP_ADV_FIFO_EMPTY(&subgrp->sync->update)
 576             || !BGP_ADV_FIFO_EMPTY(&subgrp->sync->withdraw)
 577             || !BGP_ADV_FIFO_EMPTY(&subgrp->sync->withdraw_low)) {
 578                 return 0;
 579         }
 580
 581         return 1;
 582 }
 583
 584 #endif /* _QUAGGA_BGP_UPDGRP_H */