bgpd/bgp_updgrp_packet.c

   1 /**
   2  * bgp_updgrp_packet.c: BGP update group packet handling routines
   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
  23  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  25  * 02111-1307, USA.
  26  */
  27
  28 #include <zebra.h>
  29
  30 #include "prefix.h"
  31 #include "thread.h"
  32 #include "buffer.h"
  33 #include "stream.h"
  34 #include "command.h"
  35 #include "sockunion.h"
  36 #include "network.h"
  37 #include "memory.h"
  38 #include "filter.h"
  39 #include "routemap.h"
  40 #include "str.h"
  41 #include "log.h"
  42 #include "plist.h"
  43 #include "linklist.h"
  44 #include "workqueue.h"
  45 #include "hash.h"
  46 #include "queue.h"
  47
  48 #include "bgpd/bgpd.h"
  49 #include "bgpd/bgp_debug.h"
  50 #include "bgpd/bgp_fsm.h"
  51 #include "bgpd/bgp_route.h"
  52 #include "bgpd/bgp_packet.h"
  53 #include "bgpd/bgp_advertise.h"
  54 #include "bgpd/bgp_updgrp.h"
  55 #include "bgpd/bgp_nexthop.h"
  56 #include "bgpd/bgp_nht.h"
  57
  58 /********************
  59  * PRIVATE FUNCTIONS
  60  ********************/
  61
  62 /********************
  63  * PUBLIC FUNCTIONS
  64  ********************/
  65 struct bpacket *
  66 bpacket_alloc ()
  67 {
  68   struct bpacket *pkt;
  69
  70   pkt =
  71     (struct bpacket *) XCALLOC (MTYPE_BGP_PACKET, sizeof (struct bpacket));
  72
  73   return pkt;
  74 }
  75
  76 void
  77 bpacket_free (struct bpacket *pkt)
  78 {
  79   if (pkt->buffer)
  80     stream_free (pkt->buffer);
  81   pkt->buffer = NULL;
  82   XFREE (MTYPE_BGP_PACKET, pkt);
  83 }
  84
  85 void
  86 bpacket_queue_init (struct bpacket_queue *q)
  87 {
  88   TAILQ_INIT (&(q->pkts));
  89 }
  90
  91 /*
  92  * bpacket_queue_sanity_check
  93  */
  94 void
  95 bpacket_queue_sanity_check (struct bpacket_queue __attribute__ ((__unused__)) *q)
  96 {
  97 #if 0
  98   struct bpacket *pkt;
  99
 100   pkt = bpacket_queue_last (q);
 101   assert (pkt);
 102   assert (!pkt->buffer);
 103
 104   /*
 105    * Make sure the count of packets is correct.
 106    */
 107   int num_pkts = 0;
 108
 109   pkt = bpacket_queue_first (q);
 110   while (pkt)
 111     {
 112       num_pkts++;
 113
 114       if (num_pkts > q->curr_count)
 115         assert (0);
 116
 117       pkt = TAILQ_NEXT (pkt, pkt_train);
 118     }
 119
 120   assert (num_pkts == q->curr_count);
 121 #endif
 122 }
 123
 124 /*
 125  * bpacket_queue_add_packet
 126  *
 127  * Internal function of bpacket_queue - and adds a
 128  * packet entry to the end of the list.
 129  *
 130  * Users of bpacket_queue should use bpacket_queue_add instead.
 131  */
 132 static void
 133 bpacket_queue_add_packet (struct bpacket_queue *q, struct bpacket *pkt)
 134 {
 135   struct bpacket *last_pkt;
 136
 137   if (TAILQ_EMPTY (&(q->pkts)))
 138     TAILQ_INSERT_TAIL (&(q->pkts), pkt, pkt_train);
 139   else
 140     {
 141       last_pkt = bpacket_queue_last (q);
 142       TAILQ_INSERT_AFTER (&(q->pkts), last_pkt, pkt, pkt_train);
 143     }
 144   q->curr_count++;
 145   if (q->hwm_count < q->curr_count)
 146     q->hwm_count = q->curr_count;
 147 }
 148
 149 /*
 150  * Adds a packet to the bpacket_queue.
 151  *
 152  * The stream passed is consumed by this function. So, the caller should
 153  * not free or use the stream after
 154  * invoking this function.
 155  */
 156 struct bpacket *
 157 bpacket_queue_add (struct bpacket_queue *q, struct stream *s,
 158                    struct bpacket_attr_vec_arr *vecarrp)
 159 {
 160   struct bpacket *pkt;
 161   struct bpacket *last_pkt;
 162
 163
 164   pkt = bpacket_alloc ();
 165   if (TAILQ_EMPTY (&(q->pkts)))
 166     {
 167       pkt->ver = 1;
 168       pkt->buffer = s;
 169       if (vecarrp)
 170         memcpy (&pkt->arr, vecarrp, sizeof (struct bpacket_attr_vec_arr));
 171       else
 172         bpacket_attr_vec_arr_reset (&pkt->arr);
 173       bpacket_queue_add_packet (q, pkt);
 174       bpacket_queue_sanity_check (q);
 175       return pkt;
 176     }
 177
 178   /*
 179    * Fill in the new information into the current sentinel and create a
 180    * new sentinel.
 181    */
 182   bpacket_queue_sanity_check (q);
 183   last_pkt = bpacket_queue_last (q);
 184   assert (last_pkt->buffer == NULL);
 185   last_pkt->buffer = s;
 186   if (vecarrp)
 187     memcpy (&last_pkt->arr, vecarrp, sizeof (struct bpacket_attr_vec_arr));
 188   else
 189     bpacket_attr_vec_arr_reset (&last_pkt->arr);
 190
 191   pkt->ver = last_pkt->ver;
 192   pkt->ver++;
 193   bpacket_queue_add_packet (q, pkt);
 194
 195   bpacket_queue_sanity_check (q);
 196   return last_pkt;
 197 }
 198
 199 struct bpacket *
 200 bpacket_queue_first (struct bpacket_queue *q)
 201 {
 202   return (TAILQ_FIRST (&(q->pkts)));
 203 }
 204
 205 struct bpacket *
 206 bpacket_queue_last (struct bpacket_queue *q)
 207 {
 208   return TAILQ_LAST (&(q->pkts), pkt_queue);
 209 }
 210
 211 struct bpacket *
 212 bpacket_queue_remove (struct bpacket_queue *q)
 213 {
 214   struct bpacket *first;
 215
 216   first = bpacket_queue_first (q);
 217   if (first)
 218     {
 219       TAILQ_REMOVE (&(q->pkts), first, pkt_train);
 220       q->curr_count--;
 221     }
 222   return first;
 223 }
 224
 225 unsigned int
 226 bpacket_queue_length (struct bpacket_queue *q)
 227 {
 228   return q->curr_count - 1;
 229 }
 230
 231 unsigned int
 232 bpacket_queue_hwm_length (struct bpacket_queue *q)
 233 {
 234   return q->hwm_count - 1;
 235 }
 236
 237 int
 238 bpacket_queue_is_full (struct bgp *bgp, struct bpacket_queue *q)
 239 {
 240   if (q->curr_count >= bgp->default_subgroup_pkt_queue_max)
 241     return 1;
 242   return 0;
 243 }
 244
 245 void
 246 bpacket_add_peer (struct bpacket *pkt, struct peer_af *paf)
 247 {
 248   if (!pkt || !paf)
 249     return;
 250
 251   LIST_INSERT_HEAD (&(pkt->peers), paf, pkt_train);
 252   paf->next_pkt_to_send = pkt;
 253 }
 254
 255 /*
 256  * bpacket_queue_cleanup
 257  */
 258 void
 259 bpacket_queue_cleanup (struct bpacket_queue *q)
 260 {
 261   struct bpacket *pkt;
 262
 263   while ((pkt = bpacket_queue_remove (q)))
 264     {
 265       bpacket_free (pkt);
 266     }
 267 }
 268
 269 /*
 270  * bpacket_queue_compact
 271  *
 272  * Delete packets that do not need to be transmitted to any peer from
 273  * the queue.
 274  *
 275  * @return the number of packets deleted.
 276  */
 277 static int
 278 bpacket_queue_compact (struct bpacket_queue *q)
 279 {
 280   int num_deleted;
 281   struct bpacket *pkt, *removed_pkt;
 282
 283   num_deleted = 0;
 284
 285   while (1)
 286     {
 287       pkt = bpacket_queue_first (q);
 288       if (!pkt)
 289         break;
 290
 291       /*
 292        * Don't delete the sentinel.
 293        */
 294       if (!pkt->buffer)
 295         break;
 296
 297       if (!LIST_EMPTY (&(pkt->peers)))
 298         break;
 299
 300       removed_pkt = bpacket_queue_remove (q);
 301       assert (pkt == removed_pkt);
 302       bpacket_free (removed_pkt);
 303
 304       num_deleted++;
 305     }
 306
 307   bpacket_queue_sanity_check (q);
 308   return num_deleted;
 309 }
 310
 311 void
 312 bpacket_queue_advance_peer (struct peer_af *paf)
 313 {
 314   struct bpacket *pkt;
 315   struct bpacket *old_pkt;
 316
 317   old_pkt = paf->next_pkt_to_send;
 318   if (old_pkt->buffer == NULL)
 319     /* Already at end of list */
 320     return;
 321
 322   LIST_REMOVE (paf, pkt_train);
 323   pkt = TAILQ_NEXT (old_pkt, pkt_train);
 324   bpacket_add_peer (pkt, paf);
 325
 326   if (!bpacket_queue_compact (PAF_PKTQ (paf)))
 327     return;
 328
 329   /*
 330    * Deleted one or more packets. Check if we can now merge this
 331    * peer's subgroup into another subgroup.
 332    */
 333   update_subgroup_check_merge (paf->subgroup, "advanced peer in queue");
 334 }
 335
 336 /*
 337  * bpacket_queue_remove_peer
 338  *
 339  * Remove the peer from the packet queue of the subgroup it belongs
 340  * to.
 341  */
 342 void
 343 bpacket_queue_remove_peer (struct peer_af *paf)
 344 {
 345   struct bpacket_queue *q;
 346
 347   q = PAF_PKTQ (paf);
 348   assert (q);
 349   if (!q)
 350     return;
 351
 352   LIST_REMOVE (paf, pkt_train);
 353   paf->next_pkt_to_send = NULL;
 354
 355   bpacket_queue_compact (q);
 356 }
 357
 358 unsigned int
 359 bpacket_queue_virtual_length (struct peer_af *paf)
 360 {
 361   struct bpacket *pkt;
 362   struct bpacket *last;
 363   struct bpacket_queue *q;
 364
 365   pkt = paf->next_pkt_to_send;
 366   if (!pkt || (pkt->buffer == NULL))
 367     /* Already at end of list */
 368     return 0;
 369
 370   q = PAF_PKTQ (paf);
 371   if (TAILQ_EMPTY (&(q->pkts)))
 372     return 0;
 373
 374   last = TAILQ_LAST (&(q->pkts), pkt_queue);
 375   if (last->ver >= pkt->ver)
 376     return last->ver - pkt->ver;
 377
 378   /* sequence # rolled over */
 379   return (UINT_MAX - pkt->ver + 1) + last->ver;
 380 }
 381
 382 /*
 383  * Dump the bpacket queue
 384  */
 385 void
 386 bpacket_queue_show_vty (struct bpacket_queue *q, struct vty *vty)
 387 {
 388   struct bpacket *pkt;
 389   struct peer_af *paf;
 390
 391   pkt = bpacket_queue_first (q);
 392   while (pkt)
 393     {
 394       vty_out (vty, "  Packet %p ver %u buffer %p%s", pkt, pkt->ver,
 395                pkt->buffer, VTY_NEWLINE);
 396
 397       LIST_FOREACH (paf, &(pkt->peers), pkt_train)
 398       {
 399         vty_out (vty, "      - %s%s", paf->peer->host, VTY_NEWLINE);
 400       }
 401       pkt = bpacket_next (pkt);
 402     }
 403   return;
 404 }
 405
 406 struct stream *
 407 bpacket_reformat_for_peer (struct bpacket *pkt, struct peer_af *paf)
 408 {
 409   struct stream *s = NULL;
 410   bpacket_attr_vec *vec;
 411
 412   s = stream_dup (pkt->buffer);
 413
 414   vec = &pkt->arr.entries[BGP_ATTR_VEC_NH];
 415   if (CHECK_FLAG (vec->flags, BPACKET_ATTRVEC_FLAGS_UPDATED))
 416     {
 417       u_int8_t nhlen;
 418       int route_map_sets_nh;
 419       nhlen = stream_getc_from (s, vec->offset);
 420
 421       route_map_sets_nh = CHECK_FLAG (vec->flags,
 422                                       BPACKET_ATTRVEC_FLAGS_RMAP_CHANGED);
 423
 424       if (paf->afi == AFI_IP)
 425         {
 426           struct in_addr v4nh;
 427
 428           stream_get_from (&v4nh, s, vec->offset + 1, 4);
 429
 430           /* If NH unavailable from attribute or the route-map has set it to
 431            * be the peering address, use peer's NH. The "NH unavailable" case
 432            * also covers next-hop-self and some other scenarios -- see
 433            * subgroup_announce_check(). The only other case where we use the
 434            * peer's NH is if it is an EBGP multiaccess scenario and there is
 435            * no next-hop-unchanged setting.
 436            */
 437           if (!v4nh.s_addr ||
 438               (route_map_sets_nh &&
 439                CHECK_FLAG(vec->flags,
 440                           BPACKET_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS)))
 441             stream_put_in_addr_at (s, vec->offset + 1, &paf->peer->nexthop.v4);
 442           else if (!CHECK_FLAG(vec->flags,
 443                           BPACKET_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED) &&
 444                    paf->peer->sort == BGP_PEER_EBGP &&
 445                    !peer_af_flag_check (paf->peer, paf->afi, paf->safi,
 446                                          PEER_FLAG_NEXTHOP_UNCHANGED))
 447             {
 448               if (bgp_multiaccess_check_v4 (v4nh, paf->peer) == 0)
 449                 stream_put_in_addr_at (s, vec->offset + 1,
 450                                        &paf->peer->nexthop.v4);
 451             }
 452
 453 #if 0
 454           if (!v4nh.s_addr)
 455             nhtouse = paf->peer->nexthop.v4;
 456
 457           /*
 458            * If NH is available from attribute (which is after outbound
 459            * policy application), always use it if it has been specified
 460            * by the policy. Otherwise, the decision to make is whether
 461            * we need to set ourselves as the next-hop or not. Here are
 462            * the conditions for that (1 OR 2):
 463            *
 464            * (1) if the configuration says: 'next-hop-self'
 465            * (2) if the peer is EBGP AND not a third-party-nexthop type
 466            *
 467            * There are some exceptions even if the above conditions apply.
 468            * Those are:
 469            * (a) if the configuration says: 'next-hop-unchanged'. Honor that
 470            *        always. Not set 'self' as next-hop.
 471            * (b) if we are reflecting the routes (IBGP->IBGP) and the config
 472            *        is _not_ forcing next-hop-self. We should pass on the
 473            *        next-hop unchanged for reflected routes.
 474            */
 475           if (route_map_sets_nh)
 476             {
 477               /*
 478                * If address is specified, nothing to do; if specified as
 479                * 'peer-address', compute the value to use.
 480                *
 481                * NOTE: If we are reflecting routes, the policy could have set
 482                * this only if outbound policy has been allowed for route
 483                * reflection -- handled in announce_check().
 484                */
 485               if (CHECK_FLAG(vec->flags,
 486                              BPACKET_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS))
 487                 nhtouse = paf->peer->nexthop.v4;
 488             }
 489           else if (peer_af_flag_check (paf->peer, paf->afi, paf->safi,
 490                    PEER_FLAG_NEXTHOP_SELF)
 491             || (paf->peer->sort == BGP_PEER_EBGP &&
 492                 (bgp_multiaccess_check_v4 (v4nh, paf->peer) == 0)))
 493             {
 494               if (!(peer_af_flag_check (paf->peer, paf->afi, paf->safi,
 495                                         PEER_FLAG_NEXTHOP_UNCHANGED)
 496                 || (CHECK_FLAG(vec->flags, BPACKET_ATTRVEC_FLAGS_REFLECTED) &&
 497                     !peer_af_flag_check(paf->peer, paf->afi, paf->safi,
 498                                         PEER_FLAG_FORCE_NEXTHOP_SELF))))
 499                 nhtouse = paf->peer->nexthop.v4;
 500             }
 501 #endif
 502
 503         }
 504       else if (paf->afi == AFI_IP6)
 505         {
 506           struct in6_addr v6nhglobal;
 507           struct in6_addr v6nhlocal;
 508
 509           /*
 510            * The logic here is rather similar to that for IPv4, the
 511            * additional work being to handle 1 or 2 nexthops.
 512            */
 513           stream_get_from (&v6nhglobal, s, vec->offset + 1, 16);
 514           if (IN6_IS_ADDR_UNSPECIFIED (&v6nhglobal) ||
 515               (route_map_sets_nh &&
 516                CHECK_FLAG(vec->flags,
 517                           BPACKET_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS)))
 518             stream_put_in6_addr_at (s, vec->offset + 1,
 519                                     &paf->peer->nexthop.v6_global);
 520           else if (!CHECK_FLAG(vec->flags,
 521                           BPACKET_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED) &&
 522                    paf->peer->sort == BGP_PEER_EBGP &&
 523                    !peer_af_flag_check (paf->peer, paf->afi, paf->safi,
 524                                          PEER_FLAG_NEXTHOP_UNCHANGED))
 525             {
 526               stream_put_in6_addr_at (s, vec->offset + 1,
 527                                       &paf->peer->nexthop.v6_global);
 528             }
 529
 530           if (nhlen == 32)
 531             {
 532               stream_get_from (&v6nhlocal, s, vec->offset + 1 + 16, 16);
 533               if (IN6_IS_ADDR_UNSPECIFIED (&v6nhlocal))
 534                 stream_put_in6_addr_at (s, vec->offset + 1 + 16,
 535                                         &paf->peer->nexthop.v6_local);
 536             }
 537         }
 538     }
 539
 540   bgp_packet_add (paf->peer, s);
 541   return s;
 542 }
 543
 544 /*
 545  * Update the vecarr offsets to go beyond 'pos' bytes, i.e. add 'pos'
 546  * to each offset.
 547  */
 548 static void
 549 bpacket_attr_vec_arr_update (struct bpacket_attr_vec_arr *vecarr, size_t pos)
 550 {
 551   int i;
 552
 553   if (!vecarr)
 554     return;
 555
 556   for (i = 0; i < BGP_ATTR_VEC_MAX; i++)
 557     vecarr->entries[i].offset += pos;
 558 }
 559
 560 /*
 561  * Return if there are packets to build for this subgroup.
 562  */
 563 int
 564 subgroup_packets_to_build (struct update_subgroup *subgrp)
 565 {
 566   struct bgp_advertise *adv;
 567
 568   if (!subgrp)
 569     return 0;
 570
 571   adv = BGP_ADV_FIFO_HEAD (&subgrp->sync->withdraw);
 572   if (adv)
 573     return 1;
 574
 575   adv = BGP_ADV_FIFO_HEAD (&subgrp->sync->update);
 576   if (adv)
 577     return 1;
 578
 579   return 0;
 580 }
 581
 582 /* Make BGP update packet.  */
 583 struct bpacket *
 584 subgroup_update_packet (struct update_subgroup *subgrp)
 585 {
 586   struct bpacket_attr_vec_arr vecarr;
 587   struct bpacket *pkt;
 588   struct peer *peer;
 589   struct stream *s;
 590   struct stream *snlri;
 591   struct stream *packet;
 592   struct bgp_adj_out *adj;
 593   struct bgp_advertise *adv;
 594   struct bgp_node *rn = NULL;
 595   struct bgp_info *binfo = NULL;
 596   bgp_size_t total_attr_len = 0;
 597   unsigned long attrlen_pos = 0;
 598   size_t mpattrlen_pos = 0;
 599   size_t mpattr_pos = 0;
 600   afi_t afi;
 601   safi_t safi;
 602   int space_remaining = 0;
 603   int space_needed = 0;
 604   char send_attr_str[BUFSIZ];
 605   int send_attr_printed;
 606   int num_pfx = 0;
 607
 608
 609   if (!subgrp)
 610     return NULL;
 611
 612   if (bpacket_queue_is_full (SUBGRP_INST (subgrp), SUBGRP_PKTQ (subgrp)))
 613     return NULL;
 614
 615
 616   peer = SUBGRP_PEER (subgrp);
 617   afi = SUBGRP_AFI (subgrp);
 618   safi = SUBGRP_SAFI (subgrp);
 619   s = subgrp->work;
 620   stream_reset (s);
 621   snlri = subgrp->scratch;
 622   stream_reset (snlri);
 623
 624   bpacket_attr_vec_arr_reset (&vecarr);
 625
 626   adv = BGP_ADV_FIFO_HEAD (&subgrp->sync->update);
 627   while (adv)
 628     {
 629       assert (adv->rn);
 630       rn = adv->rn;
 631       adj = adv->adj;
 632       if (adv->binfo)
 633         binfo = adv->binfo;
 634
 635       space_remaining = STREAM_CONCAT_REMAIN (s, snlri, STREAM_SIZE(s)) -
 636                         BGP_MAX_PACKET_SIZE_OVERFLOW;
 637       space_needed = BGP_NLRI_LENGTH + PSIZE (rn->p.prefixlen);
 638
 639       /* When remaining space can't include NLRI and it's length.  */
 640       if (space_remaining < space_needed)
 641         break;
 642
 643       /* If packet is empty, set attribute. */
 644       if (stream_empty (s))
 645         {
 646           struct peer *from = NULL;
 647
 648           if (binfo)
 649             from = binfo->peer;
 650
 651           /* 1: Write the BGP message header - 16 bytes marker, 2 bytes length,
 652            * one byte message type.
 653            */
 654           bgp_packet_set_marker (s, BGP_MSG_UPDATE);
 655
 656           /* 2: withdrawn routes length */
 657           stream_putw (s, 0);
 658
 659           /* 3: total attributes length - attrlen_pos stores the position */
 660           attrlen_pos = stream_get_endp (s);
 661           stream_putw (s, 0);
 662
 663           /* 4: if there is MP_REACH_NLRI attribute, that should be the first
 664            * attribute, according to draft-ietf-idr-error-handling. Save the
 665            * position.
 666            */
 667           mpattr_pos = stream_get_endp (s);
 668
 669           /* 5: Encode all the attributes, except MP_REACH_NLRI attr. */
 670           total_attr_len = bgp_packet_attribute (NULL, peer, s,
 671                                                  adv->baa->attr, &vecarr,
 672                                                  NULL, afi, safi,
 673                                                  from, NULL, NULL);
 674
 675           space_remaining = STREAM_CONCAT_REMAIN (s, snlri, STREAM_SIZE(s)) -
 676                             BGP_MAX_PACKET_SIZE_OVERFLOW;
 677           space_needed = BGP_NLRI_LENGTH + PSIZE (rn->p.prefixlen);
 678
 679           /* If the attributes alone do not leave any room for NLRI then
 680            * return */
 681           if (space_remaining < space_needed)
 682             {
 683               zlog_err ("u%llu:s%llu attributes too long, cannot send UPDATE",
 684                         subgrp->update_group->id, subgrp->id);
 685
 686               /* Flush the FIFO update queue */
 687               while (adv)
 688                 adv = bgp_advertise_clean_subgroup (subgrp, adj);
 689               return NULL;
 690             }
 691
 692           if (BGP_DEBUG (update, UPDATE_OUT) ||
 693               BGP_DEBUG (update, UPDATE_PREFIX))
 694             {
 695               memset (send_attr_str, 0, BUFSIZ);
 696               send_attr_printed = 0;
 697               bgp_dump_attr (peer, adv->baa->attr, send_attr_str, BUFSIZ);
 698             }
 699         }
 700
 701       if (afi == AFI_IP && safi == SAFI_UNICAST)
 702         stream_put_prefix (s, &rn->p);
 703       else
 704         {
 705           /* Encode the prefix in MP_REACH_NLRI attribute */
 706           struct prefix_rd *prd = NULL;
 707           u_char *tag = NULL;
 708
 709           if (rn->prn)
 710             prd = (struct prefix_rd *) &rn->prn->p;
 711           if (binfo && binfo->extra)
 712             tag = binfo->extra->tag;
 713
 714           if (stream_empty (snlri))
 715             mpattrlen_pos = bgp_packet_mpattr_start (snlri, afi, safi,
 716                                                      &vecarr, adv->baa->attr);
 717           bgp_packet_mpattr_prefix (snlri, afi, safi, &rn->p, prd, tag);
 718         }
 719
 720       num_pfx++;
 721
 722       if (bgp_debug_update(NULL, &rn->p, subgrp->update_group, 0))
 723         {
 724           char buf[INET6_BUFSIZ];
 725
 726           if (!send_attr_printed)
 727             {
 728               zlog_debug ("u%llu:s%llu send UPDATE w/ attr: %s",
 729                 subgrp->update_group->id, subgrp->id, send_attr_str);
 730               send_attr_printed = 1;
 731             }
 732
 733           zlog_debug ("u%llu:s%llu send UPDATE %s/%d",
 734                 subgrp->update_group->id, subgrp->id,
 735                 inet_ntop (rn->p.family, &(rn->p.u.prefix), buf,
 736                            INET6_BUFSIZ), rn->p.prefixlen);
 737         }
 738
 739       /* Synchnorize attribute.  */
 740       if (adj->attr)
 741         bgp_attr_unintern (&adj->attr);
 742       else
 743         subgrp->scount++;
 744
 745       adj->attr = bgp_attr_intern (adv->baa->attr);
 746
 747       adv = bgp_advertise_clean_subgroup (subgrp, adj);
 748     }
 749
 750   if (!stream_empty (s))
 751     {
 752       if (!stream_empty (snlri))
 753         {
 754           bgp_packet_mpattr_end (snlri, mpattrlen_pos);
 755           total_attr_len += stream_get_endp (snlri);
 756         }
 757
 758       /* set the total attribute length correctly */
 759       stream_putw_at (s, attrlen_pos, total_attr_len);
 760
 761       if (!stream_empty (snlri))
 762         {
 763           packet = stream_dupcat (s, snlri, mpattr_pos);
 764           bpacket_attr_vec_arr_update (&vecarr, mpattr_pos);
 765         }
 766       else
 767         packet = stream_dup (s);
 768       bgp_packet_set_size (packet);
 769       if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0))
 770         zlog_debug ("u%llu:s%llu UPDATE len %d numpfx %d",
 771                 subgrp->update_group->id, subgrp->id,
 772                 (stream_get_endp(packet) - stream_get_getp(packet)), num_pfx);
 773       pkt = bpacket_queue_add (SUBGRP_PKTQ (subgrp), packet, &vecarr);
 774       stream_reset (s);
 775       stream_reset (snlri);
 776       return pkt;
 777     }
 778   return NULL;
 779 }
 780
 781 /* Make BGP withdraw packet.  */
 782 /* For ipv4 unicast:
 783    16-octet marker | 2-octet length | 1-octet type |
 784     2-octet withdrawn route length | withdrawn prefixes | 2-octet attrlen (=0)
 785 */
 786 /* For other afi/safis:
 787    16-octet marker | 2-octet length | 1-octet type |
 788     2-octet withdrawn route length (=0) | 2-octet attrlen |
 789      mp_unreach attr type | attr len | afi | safi | withdrawn prefixes
 790 */
 791 struct bpacket *
 792 subgroup_withdraw_packet (struct update_subgroup *subgrp)
 793 {
 794   struct bpacket *pkt;
 795   struct stream *s;
 796   struct bgp_adj_out *adj;
 797   struct bgp_advertise *adv;
 798   struct peer *peer;
 799   struct bgp_node *rn;
 800   bgp_size_t unfeasible_len;
 801   bgp_size_t total_attr_len;
 802   size_t mp_start = 0;
 803   size_t attrlen_pos = 0;
 804   size_t mplen_pos = 0;
 805   u_char first_time = 1;
 806   afi_t afi;
 807   safi_t safi;
 808   int space_remaining = 0;
 809   int space_needed = 0;
 810   int num_pfx = 0;
 811
 812   if (!subgrp)
 813     return NULL;
 814
 815   if (bpacket_queue_is_full (SUBGRP_INST (subgrp), SUBGRP_PKTQ (subgrp)))
 816     return NULL;
 817
 818
 819   peer = SUBGRP_PEER (subgrp);
 820   afi = SUBGRP_AFI (subgrp);
 821   safi = SUBGRP_SAFI (subgrp);
 822   s = subgrp->work;
 823   stream_reset (s);
 824
 825   while ((adv = BGP_ADV_FIFO_HEAD (&subgrp->sync->withdraw)) != NULL)
 826     {
 827       assert (adv->rn);
 828       adj = adv->adj;
 829       rn = adv->rn;
 830
 831       space_remaining = STREAM_REMAIN (s) -
 832                         BGP_MAX_PACKET_SIZE_OVERFLOW;
 833       space_needed = (BGP_NLRI_LENGTH + BGP_TOTAL_ATTR_LEN +
 834                       PSIZE (rn->p.prefixlen));
 835
 836       if (space_remaining < space_needed)
 837         break;
 838
 839       if (stream_empty (s))
 840         {
 841           bgp_packet_set_marker (s, BGP_MSG_UPDATE);
 842           stream_putw (s, 0);   /* unfeasible routes length */
 843         }
 844       else
 845         first_time = 0;
 846
 847       if (afi == AFI_IP && safi == SAFI_UNICAST)
 848         stream_put_prefix (s, &rn->p);
 849       else
 850         {
 851           struct prefix_rd *prd = NULL;
 852
 853           if (rn->prn)
 854             prd = (struct prefix_rd *) &rn->prn->p;
 855
 856           /* If first time, format the MP_UNREACH header */
 857           if (first_time)
 858             {
 859               attrlen_pos = stream_get_endp (s);
 860               /* total attr length = 0 for now. reevaluate later */
 861               stream_putw (s, 0);
 862               mp_start = stream_get_endp (s);
 863               mplen_pos = bgp_packet_mpunreach_start (s, afi, safi);
 864             }
 865
 866           bgp_packet_mpunreach_prefix (s, &rn->p, afi, safi, prd, NULL);
 867         }
 868
 869       num_pfx++;
 870
 871       if (bgp_debug_update(NULL, &rn->p, subgrp->update_group, 0))
 872         {
 873           char buf[INET6_BUFSIZ];
 874
 875           zlog_debug ("u%llu:s%llu send UPDATE %s/%d -- unreachable",
 876                 subgrp->update_group->id, subgrp->id,
 877                 inet_ntop (rn->p.family, &(rn->p.u.prefix), buf,
 878                            INET6_BUFSIZ), rn->p.prefixlen);
 879         }
 880
 881       subgrp->scount--;
 882
 883       bgp_adj_out_remove_subgroup (rn, adj, subgrp);
 884       bgp_unlock_node (rn);
 885     }
 886
 887   if (!stream_empty (s))
 888     {
 889       if (afi == AFI_IP && safi == SAFI_UNICAST)
 890         {
 891           unfeasible_len
 892             = stream_get_endp (s) - BGP_HEADER_SIZE - BGP_UNFEASIBLE_LEN;
 893           stream_putw_at (s, BGP_HEADER_SIZE, unfeasible_len);
 894           stream_putw (s, 0);
 895         }
 896       else
 897         {
 898           /* Set the mp_unreach attr's length */
 899           bgp_packet_mpunreach_end (s, mplen_pos);
 900
 901           /* Set total path attribute length. */
 902           total_attr_len = stream_get_endp (s) - mp_start;
 903           stream_putw_at (s, attrlen_pos, total_attr_len);
 904         }
 905       bgp_packet_set_size (s);
 906       if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0))
 907         zlog_debug ("u%llu:s%llu UPDATE (withdraw) len %d numpfx %d",
 908                     subgrp->update_group->id, subgrp->id,
 909                     (stream_get_endp(s) - stream_get_getp(s)), num_pfx);
 910       pkt = bpacket_queue_add (SUBGRP_PKTQ (subgrp), stream_dup (s), NULL);
 911       stream_reset (s);
 912       return pkt;
 913     }
 914
 915   return NULL;
 916 }
 917
 918 void
 919 subgroup_default_update_packet (struct update_subgroup *subgrp,
 920                                 struct attr *attr, struct peer *from)
 921 {
 922   struct stream *s;
 923   struct stream *packet;
 924   struct peer *peer;
 925   struct prefix p;
 926   unsigned long pos;
 927   bgp_size_t total_attr_len;
 928   afi_t afi;
 929   safi_t safi;
 930   struct bpacket_attr_vec_arr vecarr;
 931
 932   if (DISABLE_BGP_ANNOUNCE)
 933     return;
 934
 935   if (!subgrp)
 936     return;
 937
 938   peer = SUBGRP_PEER (subgrp);
 939   afi = SUBGRP_AFI (subgrp);
 940   safi = SUBGRP_SAFI (subgrp);
 941   bpacket_attr_vec_arr_reset (&vecarr);
 942
 943   if (afi == AFI_IP)
 944     str2prefix ("0.0.0.0/0", &p);
 945 #ifdef HAVE_IPV6
 946   else
 947     str2prefix ("::/0", &p);
 948 #endif /* HAVE_IPV6 */
 949
 950   /* Logging the attribute. */
 951   if (bgp_debug_update(NULL, &p, subgrp->update_group, 0))
 952     {
 953       char attrstr[BUFSIZ];
 954       char buf[INET6_BUFSIZ];
 955       attrstr[0] = '\0';
 956
 957       bgp_dump_attr (peer, attr, attrstr, BUFSIZ);
 958       zlog_debug ("u%llu:s%llu send UPDATE %s/%d %s",
 959             (SUBGRP_UPDGRP (subgrp))->id, subgrp->id,
 960             inet_ntop (p.family, &(p.u.prefix), buf, INET6_BUFSIZ),
 961             p.prefixlen, attrstr);
 962     }
 963
 964   s = stream_new (BGP_MAX_PACKET_SIZE);
 965
 966   /* Make BGP update packet. */
 967   bgp_packet_set_marker (s, BGP_MSG_UPDATE);
 968
 969   /* Unfeasible Routes Length. */
 970   stream_putw (s, 0);
 971
 972   /* Make place for total attribute length.  */
 973   pos = stream_get_endp (s);
 974   stream_putw (s, 0);
 975   total_attr_len = bgp_packet_attribute (NULL, peer, s, attr, &vecarr, &p,
 976                                          afi, safi, from, NULL, NULL);
 977
 978   /* Set Total Path Attribute Length. */
 979   stream_putw_at (s, pos, total_attr_len);
 980
 981   /* NLRI set. */
 982   if (p.family == AF_INET && safi == SAFI_UNICAST)
 983     stream_put_prefix (s, &p);
 984
 985   /* Set size. */
 986   bgp_packet_set_size (s);
 987
 988   packet = stream_dup (s);
 989   stream_free (s);
 990   (void) bpacket_queue_add (SUBGRP_PKTQ (subgrp), packet, &vecarr);
 991   subgroup_trigger_write(subgrp);
 992 }
 993
 994 void
 995 subgroup_default_withdraw_packet (struct update_subgroup *subgrp)
 996 {
 997   struct peer *peer;
 998   struct stream *s;
 999   struct stream *packet;
1000   struct prefix p;
1001   unsigned long attrlen_pos = 0;
1002   unsigned long cp;
1003   bgp_size_t unfeasible_len;
1004   bgp_size_t total_attr_len;
1005   size_t mp_start = 0;
1006   size_t mplen_pos = 0;
1007   afi_t afi;
1008   safi_t safi;
1009
1010   if (DISABLE_BGP_ANNOUNCE)
1011     return;
1012
1013   peer = SUBGRP_PEER (subgrp);
1014   afi = SUBGRP_AFI (subgrp);
1015   safi = SUBGRP_SAFI (subgrp);
1016
1017   if (afi == AFI_IP)
1018     str2prefix ("0.0.0.0/0", &p);
1019 #ifdef HAVE_IPV6
1020   else
1021     str2prefix ("::/0", &p);
1022 #endif /* HAVE_IPV6 */
1023
1024   total_attr_len = 0;
1025
1026   if (bgp_debug_update(NULL, &p, subgrp->update_group, 0))
1027     {
1028       char buf[INET6_BUFSIZ];
1029
1030       zlog_debug ("u%llu:s%llu send UPDATE %s/%d -- unreachable",
1031             (SUBGRP_UPDGRP (subgrp))->id, subgrp->id, inet_ntop (p.family,
1032                                                                  &(p.u.
1033                                                                    prefix),
1034                                                                  buf,
1035                                                                  INET6_BUFSIZ),
1036             p.prefixlen);
1037     }
1038
1039   s = stream_new (BGP_MAX_PACKET_SIZE);
1040
1041   /* Make BGP update packet. */
1042   bgp_packet_set_marker (s, BGP_MSG_UPDATE);
1043
1044   /* Unfeasible Routes Length. */ ;
1045   cp = stream_get_endp (s);
1046   stream_putw (s, 0);
1047
1048   /* Withdrawn Routes. */
1049   if (p.family == AF_INET && safi == SAFI_UNICAST)
1050     {
1051       stream_put_prefix (s, &p);
1052
1053       unfeasible_len = stream_get_endp (s) - cp - 2;
1054
1055       /* Set unfeasible len.  */
1056       stream_putw_at (s, cp, unfeasible_len);
1057
1058       /* Set total path attribute length. */
1059       stream_putw (s, 0);
1060     }
1061   else
1062     {
1063       attrlen_pos = stream_get_endp (s);
1064       stream_putw (s, 0);
1065       mp_start = stream_get_endp (s);
1066       mplen_pos = bgp_packet_mpunreach_start (s, afi, safi);
1067       bgp_packet_mpunreach_prefix (s, &p, afi, safi, NULL, NULL);
1068
1069       /* Set the mp_unreach attr's length */
1070       bgp_packet_mpunreach_end (s, mplen_pos);
1071
1072       /* Set total path attribute length. */
1073       total_attr_len = stream_get_endp (s) - mp_start;
1074       stream_putw_at (s, attrlen_pos, total_attr_len);
1075     }
1076
1077   bgp_packet_set_size (s);
1078
1079   packet = stream_dup (s);
1080   stream_free (s);
1081
1082   (void) bpacket_queue_add (SUBGRP_PKTQ (subgrp), packet, NULL);
1083   subgroup_trigger_write(subgrp);
1084 }
1085
1086 static void
1087 bpacket_vec_arr_inherit_attr_flags (struct bpacket_attr_vec_arr *vecarr,
1088                                     bpacket_attr_vec_type type,
1089                                     struct attr *attr)
1090 {
1091   if (CHECK_FLAG (attr->rmap_change_flags,
1092                   BATTR_RMAP_NEXTHOP_CHANGED))
1093     SET_FLAG (vecarr->entries[BGP_ATTR_VEC_NH].flags,
1094               BPACKET_ATTRVEC_FLAGS_RMAP_CHANGED);
1095
1096   if (CHECK_FLAG (attr->rmap_change_flags,
1097                   BATTR_RMAP_NEXTHOP_PEER_ADDRESS))
1098     SET_FLAG (vecarr->entries[BGP_ATTR_VEC_NH].flags,
1099               BPACKET_ATTRVEC_FLAGS_RMAP_NH_PEER_ADDRESS);
1100
1101   if (CHECK_FLAG (attr->rmap_change_flags, BATTR_REFLECTED))
1102     SET_FLAG (vecarr->entries[BGP_ATTR_VEC_NH].flags,
1103               BPACKET_ATTRVEC_FLAGS_REFLECTED);
1104
1105   if (CHECK_FLAG (attr->rmap_change_flags,
1106                   BATTR_RMAP_NEXTHOP_UNCHANGED))
1107     SET_FLAG (vecarr->entries[BGP_ATTR_VEC_NH].flags,
1108               BPACKET_ATTRVEC_FLAGS_RMAP_NH_UNCHANGED);
1109 }
1110
1111 /* Reset the Attributes vector array. The vector array is used to override
1112  * certain output parameters in the packet for a particular peer
1113  */
1114 void
1115 bpacket_attr_vec_arr_reset (struct bpacket_attr_vec_arr *vecarr)
1116 {
1117   int i;
1118
1119   if (!vecarr)
1120     return;
1121
1122   i = 0;
1123   while (i < BGP_ATTR_VEC_MAX)
1124     {
1125       vecarr->entries[i].flags = 0;
1126       vecarr->entries[i].offset = 0;
1127       i++;
1128     }
1129 }
1130
1131 /* Setup a particular node entry in the vecarr */
1132 void
1133 bpacket_attr_vec_arr_set_vec (struct bpacket_attr_vec_arr *vecarr,
1134                               bpacket_attr_vec_type type, struct stream *s,
1135                               struct attr *attr)
1136 {
1137   if (!vecarr)
1138     return;
1139   assert (type < BGP_ATTR_VEC_MAX);
1140
1141   SET_FLAG (vecarr->entries[type].flags, BPACKET_ATTRVEC_FLAGS_UPDATED);
1142   vecarr->entries[type].offset = stream_get_endp (s);
1143   if (attr)
1144     bpacket_vec_arr_inherit_attr_flags(vecarr, type, attr);
1145 }