1 /* BGP attributes management routines.
2 * Copyright (C) 1996, 97, 98, 1999 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
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
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.
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
36 #include "bgpd/bgpd.h"
37 #include "bgpd/bgp_attr.h"
38 #include "bgpd/bgp_route.h"
39 #include "bgpd/bgp_aspath.h"
40 #include "bgpd/bgp_community.h"
41 #include "bgpd/bgp_debug.h"
42 #include "bgpd/bgp_packet.h"
43 #include "bgpd/bgp_ecommunity.h"
44 #include "bgpd/bgp_lcommunity.h"
45 #include "bgpd/bgp_updgrp.h"
46 #include "bgpd/bgp_encap_types.h"
48 # include "bgpd/rfapi/bgp_rfapi_cfg.h"
49 # include "bgp_encap_types.h"
50 # include "bgp_vnc_types.h"
52 #include "bgp_encap_types.h"
55 /* Attribute strings for logging. */
56 static const struct message attr_str
[] =
58 { BGP_ATTR_ORIGIN
, "ORIGIN" },
59 { BGP_ATTR_AS_PATH
, "AS_PATH" },
60 { BGP_ATTR_NEXT_HOP
, "NEXT_HOP" },
61 { BGP_ATTR_MULTI_EXIT_DISC
, "MULTI_EXIT_DISC" },
62 { BGP_ATTR_LOCAL_PREF
, "LOCAL_PREF" },
63 { BGP_ATTR_ATOMIC_AGGREGATE
, "ATOMIC_AGGREGATE" },
64 { BGP_ATTR_AGGREGATOR
, "AGGREGATOR" },
65 { BGP_ATTR_COMMUNITIES
, "COMMUNITY" },
66 { BGP_ATTR_ORIGINATOR_ID
, "ORIGINATOR_ID" },
67 { BGP_ATTR_CLUSTER_LIST
, "CLUSTER_LIST" },
68 { BGP_ATTR_DPA
, "DPA" },
69 { BGP_ATTR_ADVERTISER
, "ADVERTISER"} ,
70 { BGP_ATTR_RCID_PATH
, "RCID_PATH" },
71 { BGP_ATTR_MP_REACH_NLRI
, "MP_REACH_NLRI" },
72 { BGP_ATTR_MP_UNREACH_NLRI
, "MP_UNREACH_NLRI" },
73 { BGP_ATTR_EXT_COMMUNITIES
, "EXT_COMMUNITIES" },
74 { BGP_ATTR_AS4_PATH
, "AS4_PATH" },
75 { BGP_ATTR_AS4_AGGREGATOR
, "AS4_AGGREGATOR" },
76 { BGP_ATTR_AS_PATHLIMIT
, "AS_PATHLIMIT" },
77 { BGP_ATTR_ENCAP
, "ENCAP" },
79 { BGP_ATTR_VNC
, "VNC" },
81 { BGP_ATTR_LARGE_COMMUNITIES
, "LARGE_COMMUNITY" },
82 { BGP_ATTR_PREFIX_SID
, "PREFIX_SID" }
84 static const int attr_str_max
= array_size(attr_str
);
86 static const struct message attr_flag_str
[] =
88 { BGP_ATTR_FLAG_OPTIONAL
, "Optional" },
89 { BGP_ATTR_FLAG_TRANS
, "Transitive" },
90 { BGP_ATTR_FLAG_PARTIAL
, "Partial" },
91 /* bgp_attr_flags_diagnose() relies on this bit being last in this list */
92 { BGP_ATTR_FLAG_EXTLEN
, "Extended Length" },
95 static struct hash
*cluster_hash
;
98 cluster_hash_alloc (void *p
)
100 const struct cluster_list
*val
= (const struct cluster_list
*) p
;
101 struct cluster_list
*cluster
;
103 cluster
= XMALLOC (MTYPE_CLUSTER
, sizeof (struct cluster_list
));
104 cluster
->length
= val
->length
;
108 cluster
->list
= XMALLOC (MTYPE_CLUSTER_VAL
, val
->length
);
109 memcpy (cluster
->list
, val
->list
, val
->length
);
112 cluster
->list
= NULL
;
119 /* Cluster list related functions. */
120 static struct cluster_list
*
121 cluster_parse (struct in_addr
* pnt
, int length
)
123 struct cluster_list tmp
;
124 struct cluster_list
*cluster
;
129 cluster
= hash_get (cluster_hash
, &tmp
, cluster_hash_alloc
);
135 cluster_loop_check (struct cluster_list
*cluster
, struct in_addr originator
)
139 for (i
= 0; i
< cluster
->length
/ 4; i
++)
140 if (cluster
->list
[i
].s_addr
== originator
.s_addr
)
146 cluster_hash_key_make (void *p
)
148 const struct cluster_list
*cluster
= p
;
150 return jhash(cluster
->list
, cluster
->length
, 0);
154 cluster_hash_cmp (const void *p1
, const void *p2
)
156 const struct cluster_list
* cluster1
= p1
;
157 const struct cluster_list
* cluster2
= p2
;
159 return (cluster1
->length
== cluster2
->length
&&
160 memcmp (cluster1
->list
, cluster2
->list
, cluster1
->length
) == 0);
164 cluster_free (struct cluster_list
*cluster
)
167 XFREE (MTYPE_CLUSTER_VAL
, cluster
->list
);
168 XFREE (MTYPE_CLUSTER
, cluster
);
171 static struct cluster_list
*
172 cluster_dup (struct cluster_list
*cluster
)
174 struct cluster_list
*new;
176 new = XCALLOC (MTYPE_CLUSTER
, sizeof (struct cluster_list
));
177 new->length
= cluster
->length
;
181 new->list
= XMALLOC (MTYPE_CLUSTER_VAL
, cluster
->length
);
182 memcpy (new->list
, cluster
->list
, cluster
->length
);
190 static struct cluster_list
*
191 cluster_intern (struct cluster_list
*cluster
)
193 struct cluster_list
*find
;
195 find
= hash_get (cluster_hash
, cluster
, cluster_hash_alloc
);
202 cluster_unintern (struct cluster_list
*cluster
)
207 if (cluster
->refcnt
== 0)
209 hash_release (cluster_hash
, cluster
);
210 cluster_free (cluster
);
217 cluster_hash
= hash_create (cluster_hash_key_make
, cluster_hash_cmp
);
221 cluster_finish (void)
223 hash_clean (cluster_hash
, (void (*)(void *))cluster_free
);
224 hash_free (cluster_hash
);
228 static struct hash
*encap_hash
= NULL
;
230 static struct hash
*vnc_hash
= NULL
;
233 struct bgp_attr_encap_subtlv
*
234 encap_tlv_dup(struct bgp_attr_encap_subtlv
*orig
)
236 struct bgp_attr_encap_subtlv
*new;
237 struct bgp_attr_encap_subtlv
*tail
;
238 struct bgp_attr_encap_subtlv
*p
;
240 for (p
= orig
, tail
= new = NULL
; p
; p
= p
->next
) {
241 int size
= sizeof(struct bgp_attr_encap_subtlv
) - 1 + p
->length
;
243 tail
->next
= XCALLOC(MTYPE_ENCAP_TLV
, size
);
246 tail
= new = XCALLOC(MTYPE_ENCAP_TLV
, size
);
249 memcpy(tail
, p
, size
);
257 encap_free(struct bgp_attr_encap_subtlv
*p
)
259 struct bgp_attr_encap_subtlv
*next
;
263 XFREE(MTYPE_ENCAP_TLV
, p
);
269 bgp_attr_flush_encap(struct attr
*attr
)
271 if (!attr
|| !attr
->extra
)
274 if (attr
->extra
->encap_subtlvs
) {
275 encap_free(attr
->extra
->encap_subtlvs
);
276 attr
->extra
->encap_subtlvs
= NULL
;
279 if (attr
->extra
->vnc_subtlvs
) {
280 encap_free(attr
->extra
->vnc_subtlvs
);
281 attr
->extra
->vnc_subtlvs
= NULL
;
287 * Compare encap sub-tlv chains
292 * This algorithm could be made faster if needed
295 encap_same(struct bgp_attr_encap_subtlv
*h1
, struct bgp_attr_encap_subtlv
*h2
)
297 struct bgp_attr_encap_subtlv
*p
;
298 struct bgp_attr_encap_subtlv
*q
;
302 if (h1
== NULL
|| h2
== NULL
)
305 for (p
= h1
; p
; p
= p
->next
) {
306 for (q
= h2
; q
; q
= q
->next
) {
307 if ((p
->type
== q
->type
) &&
308 (p
->length
== q
->length
) &&
309 !memcmp(p
->value
, q
->value
, p
->length
)) {
318 for (p
= h2
; p
; p
= p
->next
) {
319 for (q
= h1
; q
; q
= q
->next
) {
320 if ((p
->type
== q
->type
) &&
321 (p
->length
== q
->length
) &&
322 !memcmp(p
->value
, q
->value
, p
->length
)) {
335 encap_hash_alloc (void *p
)
337 /* Encap structure is already allocated. */
349 static struct bgp_attr_encap_subtlv
*
350 encap_intern (struct bgp_attr_encap_subtlv
*encap
, encap_subtlv_type type
)
352 struct bgp_attr_encap_subtlv
*find
;
353 struct hash
*hash
= encap_hash
;
355 if (type
== VNC_SUBTLV_TYPE
)
359 find
= hash_get (hash
, encap
, encap_hash_alloc
);
368 encap_unintern (struct bgp_attr_encap_subtlv
**encapp
, encap_subtlv_type type
)
370 struct bgp_attr_encap_subtlv
*encap
= *encapp
;
374 if (encap
->refcnt
== 0)
376 struct hash
*hash
= encap_hash
;
378 if (type
== VNC_SUBTLV_TYPE
)
381 hash_release (hash
, encap
);
388 encap_hash_key_make (void *p
)
390 const struct bgp_attr_encap_subtlv
* encap
= p
;
392 return jhash(encap
->value
, encap
->length
, 0);
396 encap_hash_cmp (const void *p1
, const void *p2
)
398 return encap_same((struct bgp_attr_encap_subtlv
*)p1
,
399 (struct bgp_attr_encap_subtlv
*)p2
);
405 encap_hash
= hash_create (encap_hash_key_make
, encap_hash_cmp
);
407 vnc_hash
= hash_create (encap_hash_key_make
, encap_hash_cmp
);
414 hash_clean (encap_hash
, (void (*)(void *))encap_free
);
415 hash_free (encap_hash
);
418 hash_clean (vnc_hash
, (void (*)(void *))encap_free
);
419 hash_free (vnc_hash
);
425 overlay_index_same(const struct attr_extra
*ae1
, const struct attr_extra
*ae2
)
433 return !memcmp(&(ae1
->evpn_overlay
), &(ae2
->evpn_overlay
), sizeof(struct overlay_index
));
436 /* Unknown transit attribute. */
437 static struct hash
*transit_hash
;
440 transit_free (struct transit
*transit
)
443 XFREE (MTYPE_TRANSIT_VAL
, transit
->val
);
444 XFREE (MTYPE_TRANSIT
, transit
);
447 static struct transit
*
448 transit_dup (struct transit
*transit
)
452 new = XCALLOC (MTYPE_TRANSIT
, sizeof (struct transit
));
453 new->length
= transit
->length
;
456 new->val
= XMALLOC (MTYPE_TRANSIT_VAL
, transit
->length
);
457 memcpy (new->val
, transit
->val
, transit
->length
);
466 transit_hash_alloc (void *p
)
468 /* Transit structure is already allocated. */
472 static struct transit
*
473 transit_intern (struct transit
*transit
)
475 struct transit
*find
;
477 find
= hash_get (transit_hash
, transit
, transit_hash_alloc
);
479 transit_free (transit
);
486 transit_unintern (struct transit
*transit
)
491 if (transit
->refcnt
== 0)
493 hash_release (transit_hash
, transit
);
494 transit_free (transit
);
499 transit_hash_key_make (void *p
)
501 const struct transit
* transit
= p
;
503 return jhash(transit
->val
, transit
->length
, 0);
507 transit_hash_cmp (const void *p1
, const void *p2
)
509 const struct transit
* transit1
= p1
;
510 const struct transit
* transit2
= p2
;
512 return (transit1
->length
== transit2
->length
&&
513 memcmp (transit1
->val
, transit2
->val
, transit1
->length
) == 0);
519 transit_hash
= hash_create (transit_hash_key_make
, transit_hash_cmp
);
523 transit_finish (void)
525 hash_clean (transit_hash
, (void (*)(void *))transit_free
);
526 hash_free (transit_hash
);
530 /* Attribute hash routines. */
531 static struct hash
*attrhash
;
533 static struct attr_extra
*
534 bgp_attr_extra_new (void)
536 struct attr_extra
*extra
;
537 extra
= XCALLOC (MTYPE_ATTR_EXTRA
, sizeof (struct attr_extra
));
538 extra
->label_index
= BGP_INVALID_LABEL_INDEX
;
543 bgp_attr_extra_free (struct attr
*attr
)
547 XFREE (MTYPE_ATTR_EXTRA
, attr
->extra
);
553 bgp_attr_extra_get (struct attr
*attr
)
556 attr
->extra
= bgp_attr_extra_new();
560 /* Shallow copy of an attribute
561 * Though, not so shallow that it doesn't copy the contents
562 * of the attr_extra pointed to by 'extra'
565 bgp_attr_dup (struct attr
*new, struct attr
*orig
)
567 struct attr_extra
*extra
= new->extra
;
570 /* if caller provided attr_extra space, use it in any case.
572 * This is neccesary even if orig->extra equals NULL, because otherwise
573 * memory may be later allocated on the heap by bgp_attr_extra_get.
575 * That memory would eventually be leaked, because the caller must not
576 * call bgp_attr_extra_free if he provided attr_extra on the stack.
581 memset(new->extra
, 0, sizeof(struct attr_extra
));
583 *new->extra
= *orig
->extra
;
586 else if (orig
->extra
)
588 new->extra
= bgp_attr_extra_new();
589 *new->extra
= *orig
->extra
;
594 bgp_attr_deep_dup (struct attr
*new, struct attr
*orig
)
597 new->aspath
= aspath_dup(orig
->aspath
);
600 new->community
= community_dup(orig
->community
);
604 if (orig
->extra
->ecommunity
)
605 new->extra
->ecommunity
= ecommunity_dup(orig
->extra
->ecommunity
);
606 if (orig
->extra
->cluster
)
607 new->extra
->cluster
= cluster_dup(orig
->extra
->cluster
);
608 if (orig
->extra
->transit
)
609 new->extra
->transit
= transit_dup(orig
->extra
->transit
);
610 if (orig
->extra
->encap_subtlvs
)
611 new->extra
->encap_subtlvs
= encap_tlv_dup(orig
->extra
->encap_subtlvs
);
613 if (orig
->extra
->vnc_subtlvs
)
614 new->extra
->vnc_subtlvs
= encap_tlv_dup(orig
->extra
->vnc_subtlvs
);
620 bgp_attr_deep_free (struct attr
*attr
)
623 aspath_free(attr
->aspath
);
626 community_free(attr
->community
);
630 if (attr
->extra
->ecommunity
)
631 ecommunity_free(&attr
->extra
->ecommunity
);
632 if (attr
->extra
->cluster
)
633 cluster_free(attr
->extra
->cluster
);
634 if (attr
->extra
->transit
)
635 transit_free(attr
->extra
->transit
);
636 if (attr
->extra
->encap_subtlvs
)
637 encap_free(attr
->extra
->encap_subtlvs
);
639 if (attr
->extra
->vnc_subtlvs
)
640 encap_free(attr
->extra
->vnc_subtlvs
);
648 return attrhash
->count
;
652 attr_unknown_count (void)
654 return transit_hash
->count
;
658 attrhash_key_make (void *p
)
660 const struct attr
*attr
= (struct attr
*) p
;
661 const struct attr_extra
*extra
= attr
->extra
;
663 #define MIX(val) key = jhash_1word(val, key)
666 MIX(attr
->nexthop
.s_addr
);
668 MIX(attr
->local_pref
);
671 key
+= attr
->nexthop
.s_addr
;
673 key
+= attr
->local_pref
;
677 MIX(extra
->aggregator_as
);
678 MIX(extra
->aggregator_addr
.s_addr
);
680 MIX(extra
->mp_nexthop_global_in
.s_addr
);
681 MIX(extra
->originator_id
.s_addr
);
683 MIX(extra
->label_index
);
687 MIX(aspath_key_make (attr
->aspath
));
689 MIX(community_hash_make (attr
->community
));
693 if (extra
->lcommunity
)
694 MIX(lcommunity_hash_make (extra
->lcommunity
));
695 if (extra
->ecommunity
)
696 MIX(ecommunity_hash_make (extra
->ecommunity
));
698 MIX(cluster_hash_key_make (extra
->cluster
));
700 MIX(transit_hash_key_make (extra
->transit
));
701 if (extra
->encap_subtlvs
)
702 MIX(encap_hash_key_make (extra
->encap_subtlvs
));
704 if (extra
->vnc_subtlvs
)
705 MIX(encap_hash_key_make (extra
->vnc_subtlvs
));
707 MIX(extra
->mp_nexthop_len
);
708 key
= jhash(extra
->mp_nexthop_global
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
709 key
= jhash(extra
->mp_nexthop_local
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
716 attrhash_cmp (const void *p1
, const void *p2
)
718 const struct attr
* attr1
= p1
;
719 const struct attr
* attr2
= p2
;
721 if (attr1
->flag
== attr2
->flag
722 && attr1
->origin
== attr2
->origin
723 && attr1
->nexthop
.s_addr
== attr2
->nexthop
.s_addr
724 && attr1
->aspath
== attr2
->aspath
725 && attr1
->community
== attr2
->community
726 && attr1
->med
== attr2
->med
727 && attr1
->local_pref
== attr2
->local_pref
728 && attr1
->rmap_change_flags
== attr2
->rmap_change_flags
)
730 const struct attr_extra
*ae1
= attr1
->extra
;
731 const struct attr_extra
*ae2
= attr2
->extra
;
734 && ae1
->aggregator_as
== ae2
->aggregator_as
735 && ae1
->aggregator_addr
.s_addr
== ae2
->aggregator_addr
.s_addr
736 && ae1
->weight
== ae2
->weight
737 && ae1
->tag
== ae2
->tag
738 && ae1
->label_index
== ae2
->label_index
739 && ae1
->mp_nexthop_len
== ae2
->mp_nexthop_len
740 && IPV6_ADDR_SAME (&ae1
->mp_nexthop_global
, &ae2
->mp_nexthop_global
)
741 && IPV6_ADDR_SAME (&ae1
->mp_nexthop_local
, &ae2
->mp_nexthop_local
)
742 && IPV4_ADDR_SAME (&ae1
->mp_nexthop_global_in
, &ae2
->mp_nexthop_global_in
)
743 && ae1
->ecommunity
== ae2
->ecommunity
744 && ae1
->lcommunity
== ae2
->lcommunity
745 && ae1
->cluster
== ae2
->cluster
746 && ae1
->transit
== ae2
->transit
747 && (ae1
->encap_tunneltype
== ae2
->encap_tunneltype
)
748 && encap_same(ae1
->encap_subtlvs
, ae2
->encap_subtlvs
)
750 && encap_same(ae1
->vnc_subtlvs
, ae2
->vnc_subtlvs
)
752 && IPV4_ADDR_SAME (&ae1
->originator_id
, &ae2
->originator_id
)
753 && overlay_index_same(ae1
, ae2
))
757 /* neither attribute has extra attributes, so they're same */
767 attrhash
= hash_create (attrhash_key_make
, attrhash_cmp
);
771 * special for hash_clean below
774 attr_vfree (void *attr
)
776 bgp_attr_extra_free ((struct attr
*)attr
);
777 XFREE (MTYPE_ATTR
, attr
);
781 attrhash_finish (void)
783 hash_clean(attrhash
, attr_vfree
);
784 hash_free (attrhash
);
789 attr_show_all_iterator (struct hash_backet
*backet
, struct vty
*vty
)
791 struct attr
*attr
= backet
->data
;
793 vty_out (vty
, "attr[%ld] nexthop %s%s", attr
->refcnt
,
794 inet_ntoa (attr
->nexthop
), VTY_NEWLINE
);
798 attr_show_all (struct vty
*vty
)
800 hash_iterate (attrhash
,
801 (void (*)(struct hash_backet
*, void *))
802 attr_show_all_iterator
,
807 bgp_attr_hash_alloc (void *p
)
809 const struct attr
* val
= (const struct attr
*) p
;
812 attr
= XMALLOC (MTYPE_ATTR
, sizeof (struct attr
));
816 attr
->extra
= bgp_attr_extra_new ();
817 *attr
->extra
= *val
->extra
;
818 if (val
->extra
->encap_subtlvs
) {
819 val
->extra
->encap_subtlvs
= NULL
;
822 if (val
->extra
->vnc_subtlvs
) {
823 val
->extra
->vnc_subtlvs
= NULL
;
831 /* Internet argument attribute. */
833 bgp_attr_intern (struct attr
*attr
)
837 /* Intern referenced strucutre. */
840 if (! attr
->aspath
->refcnt
)
841 attr
->aspath
= aspath_intern (attr
->aspath
);
843 attr
->aspath
->refcnt
++;
847 if (! attr
->community
->refcnt
)
848 attr
->community
= community_intern (attr
->community
);
850 attr
->community
->refcnt
++;
854 struct attr_extra
*attre
= attr
->extra
;
856 if (attre
->ecommunity
)
858 if (! attre
->ecommunity
->refcnt
)
859 attre
->ecommunity
= ecommunity_intern (attre
->ecommunity
);
861 attre
->ecommunity
->refcnt
++;
864 if (attre
->lcommunity
)
866 if (! attre
->lcommunity
->refcnt
)
867 attre
->lcommunity
= lcommunity_intern (attre
->lcommunity
);
869 attre
->lcommunity
->refcnt
++;
873 if (! attre
->cluster
->refcnt
)
874 attre
->cluster
= cluster_intern (attre
->cluster
);
876 attre
->cluster
->refcnt
++;
880 if (! attre
->transit
->refcnt
)
881 attre
->transit
= transit_intern (attre
->transit
);
883 attre
->transit
->refcnt
++;
885 if (attre
->encap_subtlvs
)
887 if (! attre
->encap_subtlvs
->refcnt
)
888 attre
->encap_subtlvs
= encap_intern (attre
->encap_subtlvs
, ENCAP_SUBTLV_TYPE
);
890 attre
->encap_subtlvs
->refcnt
++;
893 if (attre
->vnc_subtlvs
)
895 if (! attre
->vnc_subtlvs
->refcnt
)
896 attre
->vnc_subtlvs
= encap_intern (attre
->vnc_subtlvs
, VNC_SUBTLV_TYPE
);
898 attre
->vnc_subtlvs
->refcnt
++;
903 find
= (struct attr
*) hash_get (attrhash
, attr
, bgp_attr_hash_alloc
);
910 * Increment the refcount on various structures that attr holds.
911 * Note on usage: call _only_ when the 'attr' object has already
912 * been 'intern'ed and exists in 'attrhash' table. The function
913 * serves to hold a reference to that (real) object.
914 * Note also that the caller can safely call bgp_attr_unintern()
915 * after calling bgp_attr_refcount(). That would release the
916 * reference and could result in a free() of the attr object.
919 bgp_attr_refcount (struct attr
*attr
)
921 /* Intern referenced strucutre. */
923 attr
->aspath
->refcnt
++;
926 attr
->community
->refcnt
++;
930 struct attr_extra
*attre
= attr
->extra
;
931 if (attre
->ecommunity
)
932 attre
->ecommunity
->refcnt
++;
935 attre
->cluster
->refcnt
++;
938 attre
->transit
->refcnt
++;
940 if (attre
->encap_subtlvs
)
941 attre
->encap_subtlvs
->refcnt
++;
944 if (attre
->vnc_subtlvs
)
945 attre
->vnc_subtlvs
->refcnt
++;
952 /* Make network statement's attribute. */
954 bgp_attr_default_set (struct attr
*attr
, u_char origin
)
956 memset (attr
, 0, sizeof (struct attr
));
957 bgp_attr_extra_get (attr
);
959 attr
->origin
= origin
;
960 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN
);
961 attr
->aspath
= aspath_empty ();
962 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH
);
963 attr
->extra
->weight
= BGP_ATTR_DEFAULT_WEIGHT
;
964 attr
->extra
->tag
= 0;
965 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP
);
966 attr
->extra
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
971 /* Create the attributes for an aggregate */
973 bgp_attr_aggregate_intern (struct bgp
*bgp
, u_char origin
,
974 struct aspath
*aspath
,
975 struct community
*community
, int as_set
,
976 u_char atomic_aggregate
)
980 struct attr_extra attre
;
982 memset (&attr
, 0, sizeof (struct attr
));
983 memset (&attre
, 0, sizeof (struct attr_extra
));
986 /* Origin attribute. */
987 attr
.origin
= origin
;
988 attr
.flag
|= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN
);
990 /* AS path attribute. */
992 attr
.aspath
= aspath_intern (aspath
);
994 attr
.aspath
= aspath_empty ();
995 attr
.flag
|= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH
);
997 /* Next hop attribute. */
998 attr
.flag
|= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP
);
1002 attr
.community
= community
;
1003 attr
.flag
|= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES
);
1006 attre
.weight
= BGP_ATTR_DEFAULT_WEIGHT
;
1007 attre
.mp_nexthop_len
= IPV6_MAX_BYTELEN
;
1008 if (! as_set
|| atomic_aggregate
)
1009 attr
.flag
|= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE
);
1010 attr
.flag
|= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR
);
1011 if (CHECK_FLAG (bgp
->config
, BGP_CONFIG_CONFEDERATION
))
1012 attre
.aggregator_as
= bgp
->confed_id
;
1014 attre
.aggregator_as
= bgp
->as
;
1015 attre
.aggregator_addr
= bgp
->router_id
;
1017 new = bgp_attr_intern (&attr
);
1019 aspath_unintern (&new->aspath
);
1023 /* Unintern just the sub-components of the attr, but not the attr */
1025 bgp_attr_unintern_sub (struct attr
*attr
)
1027 /* aspath refcount shoud be decrement. */
1029 aspath_unintern (&attr
->aspath
);
1030 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH
));
1032 if (attr
->community
)
1033 community_unintern (&attr
->community
);
1034 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES
));
1038 if (attr
->extra
->ecommunity
)
1039 ecommunity_unintern (&attr
->extra
->ecommunity
);
1040 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES
));
1042 if (attr
->extra
->lcommunity
)
1043 lcommunity_unintern (&attr
->extra
->lcommunity
);
1044 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES
));
1046 if (attr
->extra
->cluster
)
1047 cluster_unintern (attr
->extra
->cluster
);
1048 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST
));
1050 if (attr
->extra
->transit
)
1051 transit_unintern (attr
->extra
->transit
);
1053 if (attr
->extra
->encap_subtlvs
)
1054 encap_unintern (&attr
->extra
->encap_subtlvs
, ENCAP_SUBTLV_TYPE
);
1057 if (attr
->extra
->vnc_subtlvs
)
1058 encap_unintern (&attr
->extra
->vnc_subtlvs
, VNC_SUBTLV_TYPE
);
1063 /* Free bgp attribute and aspath. */
1065 bgp_attr_unintern (struct attr
**pattr
)
1067 struct attr
*attr
= *pattr
;
1070 struct attr_extra tmp_extra
;
1072 /* Decrement attribute reference. */
1079 tmp
.extra
= &tmp_extra
;
1080 memcpy (tmp
.extra
, attr
->extra
, sizeof (struct attr_extra
));
1083 /* If reference becomes zero then free attribute object. */
1084 if (attr
->refcnt
== 0)
1086 ret
= hash_release (attrhash
, attr
);
1087 assert (ret
!= NULL
);
1088 bgp_attr_extra_free (attr
);
1089 XFREE (MTYPE_ATTR
, attr
);
1093 bgp_attr_unintern_sub (&tmp
);
1097 bgp_attr_flush (struct attr
*attr
)
1099 if (attr
->aspath
&& ! attr
->aspath
->refcnt
)
1101 aspath_free (attr
->aspath
);
1102 attr
->aspath
= NULL
;
1104 if (attr
->community
&& ! attr
->community
->refcnt
)
1106 community_free (attr
->community
);
1107 attr
->community
= NULL
;
1111 struct attr_extra
*attre
= attr
->extra
;
1113 if (attre
->ecommunity
&& ! attre
->ecommunity
->refcnt
)
1114 ecommunity_free (&attre
->ecommunity
);
1115 if (attre
->lcommunity
&& ! attre
->lcommunity
->refcnt
)
1116 lcommunity_free (&attre
->lcommunity
);
1117 if (attre
->cluster
&& ! attre
->cluster
->refcnt
)
1119 cluster_free (attre
->cluster
);
1120 attre
->cluster
= NULL
;
1122 if (attre
->transit
&& ! attre
->transit
->refcnt
)
1124 transit_free (attre
->transit
);
1125 attre
->transit
= NULL
;
1127 if (attre
->encap_subtlvs
&& ! attre
->encap_subtlvs
->refcnt
)
1129 encap_free(attre
->encap_subtlvs
);
1130 attre
->encap_subtlvs
= NULL
;
1133 if (attre
->vnc_subtlvs
&& ! attre
->vnc_subtlvs
->refcnt
)
1135 encap_free(attre
->vnc_subtlvs
);
1136 attre
->vnc_subtlvs
= NULL
;
1142 /* Implement draft-scudder-idr-optional-transitive behaviour and
1143 * avoid resetting sessions for malformed attributes which are
1144 * are partial/optional and hence where the error likely was not
1145 * introduced by the sending neighbour.
1147 static bgp_attr_parse_ret_t
1148 bgp_attr_malformed (struct bgp_attr_parser_args
*args
, u_char subcode
,
1151 struct peer
*const peer
= args
->peer
;
1152 const u_int8_t flags
= args
->flags
;
1153 /* startp and length must be special-cased, as whether or not to
1154 * send the attribute data with the NOTIFY depends on the error,
1155 * the caller therefore signals this with the seperate length argument
1157 u_char
*notify_datap
= (length
> 0 ? args
->startp
: NULL
);
1159 /* Only relax error handling for eBGP peers */
1160 if (peer
->sort
!= BGP_PEER_EBGP
)
1162 bgp_notify_send_with_data (peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1163 notify_datap
, length
);
1164 return BGP_ATTR_PARSE_ERROR
;
1168 /* Adjust the stream getp to the end of the attribute, in case we can
1169 * still proceed but the caller hasn't read all the attribute.
1171 stream_set_getp (BGP_INPUT (peer
),
1172 (args
->startp
- STREAM_DATA (BGP_INPUT (peer
)))
1175 switch (args
->type
) {
1176 /* where an attribute is relatively inconsequential, e.g. it does not
1177 * affect route selection, and can be safely ignored, then any such
1178 * attributes which are malformed should just be ignored and the route
1179 * processed as normal.
1181 case BGP_ATTR_AS4_AGGREGATOR
:
1182 case BGP_ATTR_AGGREGATOR
:
1183 case BGP_ATTR_ATOMIC_AGGREGATE
:
1184 return BGP_ATTR_PARSE_PROCEED
;
1186 /* Core attributes, particularly ones which may influence route
1187 * selection, should always cause session resets
1189 case BGP_ATTR_ORIGIN
:
1190 case BGP_ATTR_AS_PATH
:
1191 case BGP_ATTR_NEXT_HOP
:
1192 case BGP_ATTR_MULTI_EXIT_DISC
:
1193 case BGP_ATTR_LOCAL_PREF
:
1194 case BGP_ATTR_COMMUNITIES
:
1195 case BGP_ATTR_ORIGINATOR_ID
:
1196 case BGP_ATTR_CLUSTER_LIST
:
1197 case BGP_ATTR_MP_REACH_NLRI
:
1198 case BGP_ATTR_MP_UNREACH_NLRI
:
1199 case BGP_ATTR_EXT_COMMUNITIES
:
1200 bgp_notify_send_with_data (peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1201 notify_datap
, length
);
1202 return BGP_ATTR_PARSE_ERROR
;
1205 /* Partial optional attributes that are malformed should not cause
1206 * the whole session to be reset. Instead treat it as a withdrawal
1207 * of the routes, if possible.
1209 if (CHECK_FLAG (flags
, BGP_ATTR_FLAG_TRANS
)
1210 && CHECK_FLAG (flags
, BGP_ATTR_FLAG_OPTIONAL
)
1211 && CHECK_FLAG (flags
, BGP_ATTR_FLAG_PARTIAL
))
1212 return BGP_ATTR_PARSE_WITHDRAW
;
1214 /* default to reset */
1215 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1218 /* Find out what is wrong with the path attribute flag bits and log the error.
1219 "Flag bits" here stand for Optional, Transitive and Partial, but not for
1220 Extended Length. Checking O/T/P bits at once implies, that the attribute
1221 being diagnosed is defined by RFC as either a "well-known" or an "optional,
1222 non-transitive" attribute. */
1224 bgp_attr_flags_diagnose (struct bgp_attr_parser_args
*args
,
1225 u_int8_t desired_flags
/* how RFC says it must be */
1229 u_char real_flags
= args
->flags
;
1230 const u_int8_t attr_code
= args
->type
;
1232 desired_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1233 real_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1234 for (i
= 0; i
<= 2; i
++) /* O,T,P, but not E */
1237 CHECK_FLAG (desired_flags
, attr_flag_str
[i
].key
) !=
1238 CHECK_FLAG (real_flags
, attr_flag_str
[i
].key
)
1241 zlog_err ("%s attribute must%s be flagged as \"%s\"",
1242 LOOKUP (attr_str
, attr_code
),
1243 CHECK_FLAG (desired_flags
, attr_flag_str
[i
].key
) ? "" : " not",
1244 attr_flag_str
[i
].str
);
1249 zlog_debug ("Strange, %s called for attr %s, but no problem found with flags"
1250 " (real flags 0x%x, desired 0x%x)",
1251 __func__
, LOOKUP (attr_str
, attr_code
),
1252 real_flags
, desired_flags
);
1256 /* Required flags for attributes. EXTLEN will be masked off when testing,
1257 * as will PARTIAL for optional+transitive attributes.
1259 const u_int8_t attr_flags_values
[] = {
1260 [BGP_ATTR_ORIGIN
] = BGP_ATTR_FLAG_TRANS
,
1261 [BGP_ATTR_AS_PATH
] = BGP_ATTR_FLAG_TRANS
,
1262 [BGP_ATTR_NEXT_HOP
] = BGP_ATTR_FLAG_TRANS
,
1263 [BGP_ATTR_MULTI_EXIT_DISC
] = BGP_ATTR_FLAG_OPTIONAL
,
1264 [BGP_ATTR_LOCAL_PREF
] = BGP_ATTR_FLAG_TRANS
,
1265 [BGP_ATTR_ATOMIC_AGGREGATE
] = BGP_ATTR_FLAG_TRANS
,
1266 [BGP_ATTR_AGGREGATOR
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1267 [BGP_ATTR_COMMUNITIES
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1268 [BGP_ATTR_ORIGINATOR_ID
] = BGP_ATTR_FLAG_OPTIONAL
,
1269 [BGP_ATTR_CLUSTER_LIST
] = BGP_ATTR_FLAG_OPTIONAL
,
1270 [BGP_ATTR_MP_REACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1271 [BGP_ATTR_MP_UNREACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1272 [BGP_ATTR_EXT_COMMUNITIES
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1273 [BGP_ATTR_AS4_PATH
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1274 [BGP_ATTR_AS4_AGGREGATOR
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1275 [BGP_ATTR_LARGE_COMMUNITIES
]= BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1276 [BGP_ATTR_PREFIX_SID
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1278 static const size_t attr_flags_values_max
= array_size(attr_flags_values
) - 1;
1281 bgp_attr_flag_invalid (struct bgp_attr_parser_args
*args
)
1283 u_int8_t mask
= BGP_ATTR_FLAG_EXTLEN
;
1284 const u_int8_t flags
= args
->flags
;
1285 const u_int8_t attr_code
= args
->type
;
1287 /* there may be attributes we don't know about */
1288 if (attr_code
> attr_flags_values_max
)
1290 if (attr_flags_values
[attr_code
] == 0)
1293 /* RFC4271, "For well-known attributes, the Transitive bit MUST be set to
1296 if (!CHECK_FLAG (BGP_ATTR_FLAG_OPTIONAL
, flags
)
1297 && !CHECK_FLAG (BGP_ATTR_FLAG_TRANS
, flags
))
1299 zlog_err ("%s well-known attributes must have transitive flag set (%x)",
1300 LOOKUP (attr_str
, attr_code
), flags
);
1304 /* "For well-known attributes and for optional non-transitive attributes,
1305 * the Partial bit MUST be set to 0."
1307 if (CHECK_FLAG (flags
, BGP_ATTR_FLAG_PARTIAL
))
1309 if (!CHECK_FLAG (flags
, BGP_ATTR_FLAG_OPTIONAL
))
1311 zlog_err ("%s well-known attribute "
1312 "must NOT have the partial flag set (%x)",
1313 LOOKUP (attr_str
, attr_code
), flags
);
1316 if (CHECK_FLAG (flags
, BGP_ATTR_FLAG_OPTIONAL
)
1317 && !CHECK_FLAG (flags
, BGP_ATTR_FLAG_TRANS
))
1319 zlog_err ("%s optional + transitive attribute "
1320 "must NOT have the partial flag set (%x)",
1321 LOOKUP (attr_str
, attr_code
), flags
);
1326 /* Optional transitive attributes may go through speakers that don't
1327 * reocgnise them and set the Partial bit.
1329 if (CHECK_FLAG (flags
, BGP_ATTR_FLAG_OPTIONAL
)
1330 && CHECK_FLAG (flags
, BGP_ATTR_FLAG_TRANS
))
1331 SET_FLAG (mask
, BGP_ATTR_FLAG_PARTIAL
);
1334 == attr_flags_values
[attr_code
])
1337 bgp_attr_flags_diagnose (args
, attr_flags_values
[attr_code
]);
1341 /* Get origin attribute of the update message. */
1342 static bgp_attr_parse_ret_t
1343 bgp_attr_origin (struct bgp_attr_parser_args
*args
)
1345 struct peer
*const peer
= args
->peer
;
1346 struct attr
*const attr
= args
->attr
;
1347 const bgp_size_t length
= args
->length
;
1349 /* If any recognized attribute has Attribute Length that conflicts
1350 with the expected length (based on the attribute type code), then
1351 the Error Subcode is set to Attribute Length Error. The Data
1352 field contains the erroneous attribute (type, length and
1356 zlog_err ("Origin attribute length is not one %d", length
);
1357 return bgp_attr_malformed (args
,
1358 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1362 /* Fetch origin attribute. */
1363 attr
->origin
= stream_getc (BGP_INPUT (peer
));
1365 /* If the ORIGIN attribute has an undefined value, then the Error
1366 Subcode is set to Invalid Origin Attribute. The Data field
1367 contains the unrecognized attribute (type, length and value). */
1368 if ((attr
->origin
!= BGP_ORIGIN_IGP
)
1369 && (attr
->origin
!= BGP_ORIGIN_EGP
)
1370 && (attr
->origin
!= BGP_ORIGIN_INCOMPLETE
))
1372 zlog_err ("Origin attribute value is invalid %d", attr
->origin
);
1373 return bgp_attr_malformed (args
,
1374 BGP_NOTIFY_UPDATE_INVAL_ORIGIN
,
1378 /* Set oring attribute flag. */
1379 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN
);
1384 /* Parse AS path information. This function is wrapper of
1387 bgp_attr_aspath (struct bgp_attr_parser_args
*args
)
1389 struct attr
*const attr
= args
->attr
;
1390 struct peer
*const peer
= args
->peer
;
1391 const bgp_size_t length
= args
->length
;
1394 * peer with AS4 => will get 4Byte ASnums
1395 * otherwise, will get 16 Bit
1397 attr
->aspath
= aspath_parse (peer
->ibuf
, length
,
1398 CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
));
1400 /* In case of IBGP, length will be zero. */
1403 zlog_err ("Malformed AS path from %s, length is %d", peer
->host
, length
);
1404 return bgp_attr_malformed (args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
, 0);
1407 /* Set aspath attribute flag. */
1408 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH
);
1410 return BGP_ATTR_PARSE_PROCEED
;
1413 static bgp_attr_parse_ret_t
1414 bgp_attr_aspath_check (struct peer
*const peer
, struct attr
*const attr
)
1416 /* These checks were part of bgp_attr_aspath, but with
1417 * as4 we should to check aspath things when
1418 * aspath synthesizing with as4_path has already taken place.
1419 * Otherwise we check ASPATH and use the synthesized thing, and that is
1421 * So do the checks later, i.e. here
1423 struct bgp
*bgp
= peer
->bgp
;
1424 struct aspath
*aspath
;
1426 /* Confederation sanity check. */
1427 if ((peer
->sort
== BGP_PEER_CONFED
&& ! aspath_left_confed_check (attr
->aspath
)) ||
1428 (peer
->sort
== BGP_PEER_EBGP
&& aspath_confed_check (attr
->aspath
)))
1430 zlog_err ("Malformed AS path from %s", peer
->host
);
1431 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1432 BGP_NOTIFY_UPDATE_MAL_AS_PATH
);
1433 return BGP_ATTR_PARSE_ERROR
;
1436 /* First AS check for EBGP. */
1437 if (bgp
!= NULL
&& bgp_flag_check (bgp
, BGP_FLAG_ENFORCE_FIRST_AS
))
1439 if (peer
->sort
== BGP_PEER_EBGP
1440 && ! aspath_firstas_check (attr
->aspath
, peer
->as
))
1442 zlog_err ("%s incorrect first AS (must be %u)", peer
->host
, peer
->as
);
1443 bgp_notify_send (peer
, BGP_NOTIFY_UPDATE_ERR
,
1444 BGP_NOTIFY_UPDATE_MAL_AS_PATH
);
1445 return BGP_ATTR_PARSE_ERROR
;
1449 /* local-as prepend */
1450 if (peer
->change_local_as
&&
1451 ! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
))
1453 aspath
= aspath_dup (attr
->aspath
);
1454 aspath
= aspath_add_seq (aspath
, peer
->change_local_as
);
1455 aspath_unintern (&attr
->aspath
);
1456 attr
->aspath
= aspath_intern (aspath
);
1459 return BGP_ATTR_PARSE_PROCEED
;
1462 /* Parse AS4 path information. This function is another wrapper of
1465 bgp_attr_as4_path (struct bgp_attr_parser_args
*args
, struct aspath
**as4_path
)
1467 struct peer
*const peer
= args
->peer
;
1468 struct attr
*const attr
= args
->attr
;
1469 const bgp_size_t length
= args
->length
;
1471 *as4_path
= aspath_parse (peer
->ibuf
, length
, 1);
1473 /* In case of IBGP, length will be zero. */
1476 zlog_err ("Malformed AS4 path from %s, length is %d", peer
->host
, length
);
1477 return bgp_attr_malformed (args
,
1478 BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1482 /* Set aspath attribute flag. */
1484 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_AS4_PATH
);
1486 return BGP_ATTR_PARSE_PROCEED
;
1489 /* Nexthop attribute. */
1490 static bgp_attr_parse_ret_t
1491 bgp_attr_nexthop (struct bgp_attr_parser_args
*args
)
1493 struct peer
*const peer
= args
->peer
;
1494 struct attr
*const attr
= args
->attr
;
1495 const bgp_size_t length
= args
->length
;
1497 in_addr_t nexthop_h
, nexthop_n
;
1499 /* Check nexthop attribute length. */
1502 zlog_err ("Nexthop attribute length isn't four [%d]", length
);
1504 return bgp_attr_malformed (args
,
1505 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1509 /* According to section 6.3 of RFC4271, syntactically incorrect NEXT_HOP
1510 attribute must result in a NOTIFICATION message (this is implemented below).
1511 At the same time, semantically incorrect NEXT_HOP is more likely to be just
1512 logged locally (this is implemented somewhere else). The UPDATE message
1513 gets ignored in any of these cases. */
1514 nexthop_n
= stream_get_ipv4 (peer
->ibuf
);
1515 nexthop_h
= ntohl (nexthop_n
);
1516 if ((IPV4_NET0 (nexthop_h
) || IPV4_NET127 (nexthop_h
) || IPV4_CLASS_DE (nexthop_h
))
1517 && !BGP_DEBUG (allow_martians
, ALLOW_MARTIANS
)) /* loopbacks may be used in testing */
1519 char buf
[INET_ADDRSTRLEN
];
1520 inet_ntop (AF_INET
, &nexthop_n
, buf
, INET_ADDRSTRLEN
);
1521 zlog_err ("Martian nexthop %s", buf
);
1522 return bgp_attr_malformed (args
,
1523 BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP
,
1527 attr
->nexthop
.s_addr
= nexthop_n
;
1528 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP
);
1530 return BGP_ATTR_PARSE_PROCEED
;
1533 /* MED atrribute. */
1534 static bgp_attr_parse_ret_t
1535 bgp_attr_med (struct bgp_attr_parser_args
*args
)
1537 struct peer
*const peer
= args
->peer
;
1538 struct attr
*const attr
= args
->attr
;
1539 const bgp_size_t length
= args
->length
;
1544 zlog_err ("MED attribute length isn't four [%d]", length
);
1546 return bgp_attr_malformed (args
,
1547 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1551 attr
->med
= stream_getl (peer
->ibuf
);
1553 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC
);
1555 return BGP_ATTR_PARSE_PROCEED
;
1558 /* Local preference attribute. */
1559 static bgp_attr_parse_ret_t
1560 bgp_attr_local_pref (struct bgp_attr_parser_args
*args
)
1562 struct peer
*const peer
= args
->peer
;
1563 struct attr
*const attr
= args
->attr
;
1564 const bgp_size_t length
= args
->length
;
1569 zlog_err ("LOCAL_PREF attribute length isn't 4 [%u]", length
);
1570 return bgp_attr_malformed (args
,
1571 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1575 /* If it is contained in an UPDATE message that is received from an
1576 external peer, then this attribute MUST be ignored by the
1577 receiving speaker. */
1578 if (peer
->sort
== BGP_PEER_EBGP
)
1580 stream_forward_getp (peer
->ibuf
, length
);
1581 return BGP_ATTR_PARSE_PROCEED
;
1584 attr
->local_pref
= stream_getl (peer
->ibuf
);
1586 /* Set atomic aggregate flag. */
1587 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF
);
1589 return BGP_ATTR_PARSE_PROCEED
;
1592 /* Atomic aggregate. */
1594 bgp_attr_atomic (struct bgp_attr_parser_args
*args
)
1596 struct attr
*const attr
= args
->attr
;
1597 const bgp_size_t length
= args
->length
;
1602 zlog_err ("ATOMIC_AGGREGATE attribute length isn't 0 [%u]", length
);
1603 return bgp_attr_malformed (args
,
1604 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1608 /* Set atomic aggregate flag. */
1609 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE
);
1611 return BGP_ATTR_PARSE_PROCEED
;
1614 /* Aggregator attribute */
1616 bgp_attr_aggregator (struct bgp_attr_parser_args
*args
)
1618 struct peer
*const peer
= args
->peer
;
1619 struct attr
*const attr
= args
->attr
;
1620 const bgp_size_t length
= args
->length
;
1623 struct attr_extra
*attre
= bgp_attr_extra_get (attr
);
1625 /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
1626 if (CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
))
1629 if (length
!= wantedlen
)
1631 zlog_err ("AGGREGATOR attribute length isn't %u [%u]", wantedlen
, length
);
1632 return bgp_attr_malformed (args
,
1633 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1637 if ( CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
) )
1638 attre
->aggregator_as
= stream_getl (peer
->ibuf
);
1640 attre
->aggregator_as
= stream_getw (peer
->ibuf
);
1641 attre
->aggregator_addr
.s_addr
= stream_get_ipv4 (peer
->ibuf
);
1643 /* Set atomic aggregate flag. */
1644 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR
);
1646 return BGP_ATTR_PARSE_PROCEED
;
1649 /* New Aggregator attribute */
1650 static bgp_attr_parse_ret_t
1651 bgp_attr_as4_aggregator (struct bgp_attr_parser_args
*args
,
1652 as_t
*as4_aggregator_as
,
1653 struct in_addr
*as4_aggregator_addr
)
1655 struct peer
*const peer
= args
->peer
;
1656 struct attr
*const attr
= args
->attr
;
1657 const bgp_size_t length
= args
->length
;
1661 zlog_err ("New Aggregator length is not 8 [%d]", length
);
1662 return bgp_attr_malformed (args
,
1663 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1667 *as4_aggregator_as
= stream_getl (peer
->ibuf
);
1668 as4_aggregator_addr
->s_addr
= stream_get_ipv4 (peer
->ibuf
);
1670 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR
);
1672 return BGP_ATTR_PARSE_PROCEED
;
1675 /* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
1677 static bgp_attr_parse_ret_t
1678 bgp_attr_munge_as4_attrs (struct peer
*const peer
,
1679 struct attr
*const attr
,
1680 struct aspath
*as4_path
, as_t as4_aggregator
,
1681 struct in_addr
*as4_aggregator_addr
)
1683 int ignore_as4_path
= 0;
1684 struct aspath
*newpath
;
1685 struct attr_extra
*attre
= attr
->extra
;
1689 /* NULL aspath shouldn't be possible as bgp_attr_parse should have
1690 * checked that all well-known, mandatory attributes were present.
1692 * Can only be a problem with peer itself - hard error
1694 return BGP_ATTR_PARSE_ERROR
;
1697 if (CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
))
1699 /* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
1701 * It is worth a warning though, because the peer really
1702 * should not send them
1704 if (BGP_DEBUG(as4
, AS4
))
1706 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))
1707 zlog_debug ("[AS4] %s %s AS4_PATH",
1708 peer
->host
, "AS4 capable peer, yet it sent");
1710 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
)))
1711 zlog_debug ("[AS4] %s %s AS4_AGGREGATOR",
1712 peer
->host
, "AS4 capable peer, yet it sent");
1715 return BGP_ATTR_PARSE_PROCEED
;
1718 /* We have a asn16 peer. First, look for AS4_AGGREGATOR
1719 * because that may override AS4_PATH
1721 if (attr
->flag
& (ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR
) ) )
1723 if (attr
->flag
& (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR
) ) )
1728 * if the as_number in aggregator is not AS_TRANS,
1729 * then AS4_AGGREGATOR and AS4_PATH shall be ignored
1730 * and the Aggregator shall be taken as
1731 * info on the aggregating node, and the AS_PATH
1732 * shall be taken as the AS_PATH
1734 * the Aggregator shall be ignored and the
1735 * AS4_AGGREGATOR shall be taken as the
1736 * Aggregating node and the AS_PATH is to be
1737 * constructed "as in all other cases"
1739 if (attre
->aggregator_as
!= BGP_AS_TRANS
)
1742 if ( BGP_DEBUG(as4
, AS4
))
1743 zlog_debug ("[AS4] %s BGP not AS4 capable peer"
1744 " send AGGREGATOR != AS_TRANS and"
1745 " AS4_AGGREGATOR, so ignore"
1746 " AS4_AGGREGATOR and AS4_PATH", peer
->host
);
1747 ignore_as4_path
= 1;
1751 /* "New_aggregator shall be taken as aggregator" */
1752 attre
->aggregator_as
= as4_aggregator
;
1753 attre
->aggregator_addr
.s_addr
= as4_aggregator_addr
->s_addr
;
1758 /* We received a AS4_AGGREGATOR but no AGGREGATOR.
1759 * That is bogus - but reading the conditions
1760 * we have to handle AS4_AGGREGATOR as if it were
1761 * AGGREGATOR in that case
1763 if ( BGP_DEBUG(as4
, AS4
))
1764 zlog_debug ("[AS4] %s BGP not AS4 capable peer send"
1765 " AS4_AGGREGATOR but no AGGREGATOR, will take"
1766 " it as if AGGREGATOR with AS_TRANS had been there", peer
->host
);
1767 (attre
= bgp_attr_extra_get (attr
))->aggregator_as
= as4_aggregator
;
1768 /* sweep it under the carpet and simulate a "good" AGGREGATOR */
1769 attr
->flag
|= (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR
));
1773 /* need to reconcile NEW_AS_PATH and AS_PATH */
1774 if (!ignore_as4_path
&& (attr
->flag
& (ATTR_FLAG_BIT( BGP_ATTR_AS4_PATH
))))
1776 newpath
= aspath_reconcile_as4 (attr
->aspath
, as4_path
);
1777 aspath_unintern (&attr
->aspath
);
1778 attr
->aspath
= aspath_intern (newpath
);
1780 return BGP_ATTR_PARSE_PROCEED
;
1783 /* Community attribute. */
1784 static bgp_attr_parse_ret_t
1785 bgp_attr_community (struct bgp_attr_parser_args
*args
)
1787 struct peer
*const peer
= args
->peer
;
1788 struct attr
*const attr
= args
->attr
;
1789 const bgp_size_t length
= args
->length
;
1793 attr
->community
= NULL
;
1794 return BGP_ATTR_PARSE_PROCEED
;
1798 community_parse ((u_int32_t
*)stream_pnt (peer
->ibuf
), length
);
1800 /* XXX: fix community_parse to use stream API and remove this */
1801 stream_forward_getp (peer
->ibuf
, length
);
1803 if (!attr
->community
)
1804 return bgp_attr_malformed (args
,
1805 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
1808 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES
);
1810 return BGP_ATTR_PARSE_PROCEED
;
1813 /* Originator ID attribute. */
1814 static bgp_attr_parse_ret_t
1815 bgp_attr_originator_id (struct bgp_attr_parser_args
*args
)
1817 struct peer
*const peer
= args
->peer
;
1818 struct attr
*const attr
= args
->attr
;
1819 const bgp_size_t length
= args
->length
;
1824 zlog_err ("Bad originator ID length %d", length
);
1826 return bgp_attr_malformed (args
,
1827 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1831 (bgp_attr_extra_get (attr
))->originator_id
.s_addr
1832 = stream_get_ipv4 (peer
->ibuf
);
1834 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID
);
1836 return BGP_ATTR_PARSE_PROCEED
;
1839 /* Cluster list attribute. */
1840 static bgp_attr_parse_ret_t
1841 bgp_attr_cluster_list (struct bgp_attr_parser_args
*args
)
1843 struct peer
*const peer
= args
->peer
;
1844 struct attr
*const attr
= args
->attr
;
1845 const bgp_size_t length
= args
->length
;
1850 zlog_err ("Bad cluster list length %d", length
);
1852 return bgp_attr_malformed (args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1856 (bgp_attr_extra_get (attr
))->cluster
1857 = cluster_parse ((struct in_addr
*)stream_pnt (peer
->ibuf
), length
);
1859 /* XXX: Fix cluster_parse to use stream API and then remove this */
1860 stream_forward_getp (peer
->ibuf
, length
);
1862 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST
);
1864 return BGP_ATTR_PARSE_PROCEED
;
1867 /* Multiprotocol reachability information parse. */
1869 bgp_mp_reach_parse (struct bgp_attr_parser_args
*args
,
1870 struct bgp_nlri
*mp_update
)
1874 safi_t pkt_safi
, safi
;
1875 bgp_size_t nlri_len
;
1878 struct peer
*const peer
= args
->peer
;
1879 struct attr
*const attr
= args
->attr
;
1880 const bgp_size_t length
= args
->length
;
1881 struct attr_extra
*attre
= bgp_attr_extra_get(attr
);
1883 /* Set end of packet. */
1884 s
= BGP_INPUT(peer
);
1885 start
= stream_get_getp(s
);
1887 /* safe to read statically sized header? */
1888 #define BGP_MP_REACH_MIN_SIZE 5
1889 #define LEN_LEFT (length - (stream_get_getp(s) - start))
1890 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_REACH_MIN_SIZE
))
1892 zlog_info ("%s: %s sent invalid length, %lu",
1893 __func__
, peer
->host
, (unsigned long)length
);
1894 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1897 /* Load AFI, SAFI. */
1898 pkt_afi
= stream_getw (s
);
1899 pkt_safi
= stream_getc (s
);
1901 /* Convert AFI, SAFI to internal values, check. */
1902 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
1904 /* Log if AFI or SAFI is unrecognized. This is not an error unless
1905 * the attribute is otherwise malformed.
1907 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
1908 zlog_debug ("%s: MP_REACH received AFI %u or SAFI %u is unrecognized",
1909 peer
->host
, pkt_afi
, pkt_safi
);
1910 return BGP_ATTR_PARSE_ERROR
;
1913 /* Get nexthop length. */
1914 attre
->mp_nexthop_len
= stream_getc (s
);
1916 if (LEN_LEFT
< attre
->mp_nexthop_len
)
1918 zlog_info ("%s: %s, MP nexthop length, %u, goes past end of attribute",
1919 __func__
, peer
->host
, attre
->mp_nexthop_len
);
1920 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1923 /* Nexthop length check. */
1924 switch (attre
->mp_nexthop_len
)
1926 case BGP_ATTR_NHLEN_IPV4
:
1927 stream_get (&attre
->mp_nexthop_global_in
, s
, IPV4_MAX_BYTELEN
);
1928 /* Probably needed for RFC 2283 */
1929 if (attr
->nexthop
.s_addr
== 0)
1930 memcpy(&attr
->nexthop
.s_addr
, &attre
->mp_nexthop_global_in
, IPV4_MAX_BYTELEN
);
1932 case BGP_ATTR_NHLEN_VPNV4
:
1933 stream_getl (s
); /* RD high */
1934 stream_getl (s
); /* RD low */
1935 stream_get (&attre
->mp_nexthop_global_in
, s
, IPV4_MAX_BYTELEN
);
1937 case BGP_ATTR_NHLEN_IPV6_GLOBAL
:
1938 case BGP_ATTR_NHLEN_VPNV6_GLOBAL
:
1939 if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV6_GLOBAL
)
1941 stream_getl (s
); /* RD high */
1942 stream_getl (s
); /* RD low */
1944 stream_get (&attre
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
1946 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
:
1947 case BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
:
1948 if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
)
1950 stream_getl (s
); /* RD high */
1951 stream_getl (s
); /* RD low */
1953 stream_get (&attre
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
1954 if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
)
1956 stream_getl (s
); /* RD high */
1957 stream_getl (s
); /* RD low */
1959 stream_get (&attre
->mp_nexthop_local
, s
, IPV6_MAX_BYTELEN
);
1960 if (! IN6_IS_ADDR_LINKLOCAL (&attre
->mp_nexthop_local
))
1962 char buf1
[INET6_ADDRSTRLEN
];
1963 char buf2
[INET6_ADDRSTRLEN
];
1965 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
1966 zlog_debug ("%s rcvd nexthops %s, %s -- ignoring non-LL value",
1968 inet_ntop (AF_INET6
, &attre
->mp_nexthop_global
,
1969 buf1
, INET6_ADDRSTRLEN
),
1970 inet_ntop (AF_INET6
, &attre
->mp_nexthop_local
,
1971 buf2
, INET6_ADDRSTRLEN
));
1973 attre
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
1977 zlog_info ("%s: (%s) Wrong multiprotocol next hop length: %d",
1978 __func__
, peer
->host
, attre
->mp_nexthop_len
);
1979 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1984 zlog_info ("%s: (%s) Failed to read SNPA and NLRI(s)",
1985 __func__
, peer
->host
);
1986 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1991 if ((val
= stream_getc (s
)))
1992 zlog_warn ("%s sent non-zero value, %u, for defunct SNPA-length field",
1996 /* must have nrli_len, what is left of the attribute */
1997 nlri_len
= LEN_LEFT
;
1998 if ((!nlri_len
) || (nlri_len
> STREAM_READABLE(s
)))
2000 zlog_info ("%s: (%s) Failed to read NLRI",
2001 __func__
, peer
->host
);
2002 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2005 mp_update
->afi
= afi
;
2006 mp_update
->safi
= safi
;
2007 mp_update
->nlri
= stream_pnt (s
);
2008 mp_update
->length
= nlri_len
;
2010 stream_forward_getp (s
, nlri_len
);
2012 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_MP_REACH_NLRI
);
2014 return BGP_ATTR_PARSE_PROCEED
;
2018 /* Multiprotocol unreachable parse */
2020 bgp_mp_unreach_parse (struct bgp_attr_parser_args
*args
,
2021 struct bgp_nlri
*mp_withdraw
)
2026 safi_t pkt_safi
, safi
;
2027 u_int16_t withdraw_len
;
2028 struct peer
*const peer
= args
->peer
;
2029 struct attr
*const attr
= args
->attr
;
2030 const bgp_size_t length
= args
->length
;
2034 #define BGP_MP_UNREACH_MIN_SIZE 3
2035 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_UNREACH_MIN_SIZE
))
2036 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2038 pkt_afi
= stream_getw (s
);
2039 pkt_safi
= stream_getc (s
);
2041 /* Convert AFI, SAFI to internal values, check. */
2042 if (bgp_map_afi_safi_iana2int (pkt_afi
, pkt_safi
, &afi
, &safi
))
2044 /* Log if AFI or SAFI is unrecognized. This is not an error unless
2045 * the attribute is otherwise malformed.
2047 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2048 zlog_debug ("%s: MP_UNREACH received AFI %u or SAFI %u is unrecognized",
2049 peer
->host
, pkt_afi
, pkt_safi
);
2050 return BGP_ATTR_PARSE_ERROR
;
2053 withdraw_len
= length
- BGP_MP_UNREACH_MIN_SIZE
;
2055 mp_withdraw
->afi
= afi
;
2056 mp_withdraw
->safi
= safi
;
2057 mp_withdraw
->nlri
= stream_pnt (s
);
2058 mp_withdraw
->length
= withdraw_len
;
2060 stream_forward_getp (s
, withdraw_len
);
2062 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_MP_UNREACH_NLRI
);
2064 return BGP_ATTR_PARSE_PROCEED
;
2067 /* Large Community attribute. */
2068 static bgp_attr_parse_ret_t
2069 bgp_attr_large_community (struct bgp_attr_parser_args
*args
)
2071 struct peer
*const peer
= args
->peer
;
2072 struct attr
*const attr
= args
->attr
;
2073 const bgp_size_t length
= args
->length
;
2076 * Large community follows new attribute format.
2081 attr
->extra
->lcommunity
= NULL
;
2082 /* Empty extcomm doesn't seem to be invalid per se */
2083 return BGP_ATTR_PARSE_PROCEED
;
2086 (bgp_attr_extra_get (attr
))->lcommunity
=
2087 lcommunity_parse ((u_int8_t
*)stream_pnt (peer
->ibuf
), length
);
2088 /* XXX: fix ecommunity_parse to use stream API */
2089 stream_forward_getp (peer
->ibuf
, length
);
2091 if (attr
->extra
&& !attr
->extra
->lcommunity
)
2092 return bgp_attr_malformed (args
,
2093 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2096 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES
);
2098 return BGP_ATTR_PARSE_PROCEED
;
2101 /* Extended Community attribute. */
2102 static bgp_attr_parse_ret_t
2103 bgp_attr_ext_communities (struct bgp_attr_parser_args
*args
)
2105 struct peer
*const peer
= args
->peer
;
2106 struct attr
*const attr
= args
->attr
;
2107 const bgp_size_t length
= args
->length
;
2112 attr
->extra
->ecommunity
= NULL
;
2113 /* Empty extcomm doesn't seem to be invalid per se */
2114 return BGP_ATTR_PARSE_PROCEED
;
2117 (bgp_attr_extra_get (attr
))->ecommunity
=
2118 ecommunity_parse ((u_int8_t
*)stream_pnt (peer
->ibuf
), length
);
2119 /* XXX: fix ecommunity_parse to use stream API */
2120 stream_forward_getp (peer
->ibuf
, length
);
2122 if (attr
->extra
&& !attr
->extra
->ecommunity
)
2123 return bgp_attr_malformed (args
,
2124 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2127 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES
);
2129 return BGP_ATTR_PARSE_PROCEED
;
2132 /* Parse Tunnel Encap attribute in an UPDATE */
2136 struct peer
*peer
, /* IN */
2137 bgp_size_t length
, /* IN: attr's length field */
2138 struct attr
*attr
, /* IN: caller already allocated */
2139 u_char flag
, /* IN: attr's flags field */
2143 struct attr_extra
*attre
= NULL
;
2144 struct bgp_attr_encap_subtlv
*stlv_last
= NULL
;
2145 uint16_t tunneltype
= 0;
2147 total
= length
+ (CHECK_FLAG (flag
, BGP_ATTR_FLAG_EXTLEN
) ? 4 : 3);
2149 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
)
2150 || !CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
))
2152 zlog_info ("Tunnel Encap attribute flag isn't optional and transitive %d", flag
);
2153 bgp_notify_send_with_data (peer
,
2154 BGP_NOTIFY_UPDATE_ERR
,
2155 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
2160 if (BGP_ATTR_ENCAP
== type
) {
2161 /* read outer TLV type and length */
2162 uint16_t tlv_length
;
2165 zlog_info ("Tunnel Encap attribute not long enough to contain outer T,L");
2166 bgp_notify_send_with_data(peer
,
2167 BGP_NOTIFY_UPDATE_ERR
,
2168 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2172 tunneltype
= stream_getw (BGP_INPUT (peer
));
2173 tlv_length
= stream_getw (BGP_INPUT (peer
));
2176 if (tlv_length
!= length
) {
2177 zlog_info ("%s: tlv_length(%d) != length(%d)",
2178 __func__
, tlv_length
, length
);
2182 while (length
>= 4) {
2183 uint16_t subtype
= 0;
2184 uint16_t sublength
= 0;
2185 struct bgp_attr_encap_subtlv
*tlv
;
2187 if (BGP_ATTR_ENCAP
== type
) {
2188 subtype
= stream_getc (BGP_INPUT (peer
));
2189 sublength
= stream_getc (BGP_INPUT (peer
));
2193 subtype
= stream_getw (BGP_INPUT (peer
));
2194 sublength
= stream_getw (BGP_INPUT (peer
));
2199 if (sublength
> length
) {
2200 zlog_info ("Tunnel Encap attribute sub-tlv length %d exceeds remaining length %d",
2202 bgp_notify_send_with_data (peer
,
2203 BGP_NOTIFY_UPDATE_ERR
,
2204 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2209 /* alloc and copy sub-tlv */
2210 /* TBD make sure these are freed when attributes are released */
2211 tlv
= XCALLOC (MTYPE_ENCAP_TLV
, sizeof(struct bgp_attr_encap_subtlv
)-1+sublength
);
2212 tlv
->type
= subtype
;
2213 tlv
->length
= sublength
;
2214 stream_get(tlv
->value
, peer
->ibuf
, sublength
);
2215 length
-= sublength
;
2217 /* attach tlv to encap chain */
2219 attre
= bgp_attr_extra_get(attr
);
2220 if (BGP_ATTR_ENCAP
== type
) {
2221 for (stlv_last
= attre
->encap_subtlvs
; stlv_last
&& stlv_last
->next
;
2222 stlv_last
= stlv_last
->next
);
2224 stlv_last
->next
= tlv
;
2226 attre
->encap_subtlvs
= tlv
;
2230 for (stlv_last
= attre
->vnc_subtlvs
; stlv_last
&& stlv_last
->next
;
2231 stlv_last
= stlv_last
->next
);
2233 stlv_last
->next
= tlv
;
2235 attre
->vnc_subtlvs
= tlv
;
2240 stlv_last
->next
= tlv
;
2245 if (BGP_ATTR_ENCAP
== type
) {
2247 attre
= bgp_attr_extra_get(attr
);
2248 attre
->encap_tunneltype
= tunneltype
;
2252 /* spurious leftover data */
2253 zlog_info ("Tunnel Encap attribute length is bad: %d leftover octets", length
);
2254 bgp_notify_send_with_data (peer
,
2255 BGP_NOTIFY_UPDATE_ERR
,
2256 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2264 /* Prefix SID attribute
2265 * draft-ietf-idr-bgp-prefix-sid-05
2267 static bgp_attr_parse_ret_t
2268 bgp_attr_prefix_sid (struct bgp_attr_parser_args
*args
, struct bgp_nlri
*mp_update
)
2270 struct peer
*const peer
= args
->peer
;
2271 struct attr
*const attr
= args
->attr
;
2274 u_int32_t label_index
;
2275 struct in6_addr ipv6_sid
;
2276 u_int32_t srgb_base
;
2277 u_int32_t srgb_range
;
2280 attr
->flag
|= ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID
);
2282 type
= stream_getc (peer
->ibuf
);
2283 length
= stream_getw (peer
->ibuf
);
2285 if (type
== BGP_PREFIX_SID_LABEL_INDEX
)
2287 if (length
!= BGP_PREFIX_SID_LABEL_INDEX_LENGTH
)
2289 zlog_err ("Prefix SID label index length is %d instead of %d", length
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
2290 return bgp_attr_malformed (args
,
2291 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2295 /* Ignore flags and reserved */
2296 stream_getc (peer
->ibuf
);
2297 stream_getw (peer
->ibuf
);
2299 /* Fetch the label index and see if it is valid. */
2300 label_index
= stream_getl (peer
->ibuf
);
2301 if (label_index
== BGP_INVALID_LABEL_INDEX
)
2302 return bgp_attr_malformed (args
,
2303 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2306 /* Store label index; subsequently, we'll check on address-family */
2307 (bgp_attr_extra_get (attr
))->label_index
= label_index
;
2310 * Ignore the Label index attribute unless received for labeled-unicast
2313 if (!mp_update
->length
|| mp_update
->safi
!= SAFI_LABELED_UNICAST
)
2314 attr
->extra
->label_index
= BGP_INVALID_LABEL_INDEX
;
2317 /* Placeholder code for the IPv6 SID type */
2318 else if (type
== BGP_PREFIX_SID_IPV6
)
2320 if (length
!= BGP_PREFIX_SID_IPV6_LENGTH
)
2322 zlog_err ("Prefix SID IPv6 length is %d instead of %d", length
, BGP_PREFIX_SID_IPV6_LENGTH
);
2323 return bgp_attr_malformed (args
,
2324 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2328 /* Ignore reserved */
2329 stream_getc (peer
->ibuf
);
2330 stream_getw (peer
->ibuf
);
2332 stream_get (&ipv6_sid
, peer
->ibuf
, 16);
2335 /* Placeholder code for the Originator SRGB type */
2336 else if (type
== BGP_PREFIX_SID_ORIGINATOR_SRGB
)
2339 stream_getw (peer
->ibuf
);
2343 if (length
% BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
)
2345 zlog_err ("Prefix SID Originator SRGB length is %d, it must be a multiple of %d ",
2346 length
, BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2347 return bgp_attr_malformed (args
,
2348 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2352 srgb_count
= length
/ BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
;
2354 for (int i
= 0; i
< srgb_count
; i
++)
2356 stream_get (&srgb_base
, peer
->ibuf
, 3);
2357 stream_get (&srgb_range
, peer
->ibuf
, 3);
2361 return BGP_ATTR_PARSE_PROCEED
;
2364 /* BGP unknown attribute treatment. */
2365 static bgp_attr_parse_ret_t
2366 bgp_attr_unknown (struct bgp_attr_parser_args
*args
)
2368 bgp_size_t total
= args
->total
;
2369 struct transit
*transit
;
2370 struct attr_extra
*attre
;
2371 struct peer
*const peer
= args
->peer
;
2372 struct attr
*const attr
= args
->attr
;
2373 u_char
*const startp
= args
->startp
;
2374 const u_char type
= args
->type
;
2375 const u_char flag
= args
->flags
;
2376 const bgp_size_t length
= args
->length
;
2378 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2379 zlog_debug ("%s Unknown attribute is received (type %d, length %d)",
2380 peer
->host
, type
, length
);
2382 /* Forward read pointer of input stream. */
2383 stream_forward_getp (peer
->ibuf
, length
);
2385 /* If any of the mandatory well-known attributes are not recognized,
2386 then the Error Subcode is set to Unrecognized Well-known
2387 Attribute. The Data field contains the unrecognized attribute
2388 (type, length and value). */
2389 if (!CHECK_FLAG (flag
, BGP_ATTR_FLAG_OPTIONAL
))
2391 return bgp_attr_malformed (args
,
2392 BGP_NOTIFY_UPDATE_UNREC_ATTR
,
2396 /* Unrecognized non-transitive optional attributes must be quietly
2397 ignored and not passed along to other BGP peers. */
2398 if (! CHECK_FLAG (flag
, BGP_ATTR_FLAG_TRANS
))
2399 return BGP_ATTR_PARSE_PROCEED
;
2401 /* If a path with recognized transitive optional attribute is
2402 accepted and passed along to other BGP peers and the Partial bit
2403 in the Attribute Flags octet is set to 1 by some previous AS, it
2404 is not set back to 0 by the current AS. */
2405 SET_FLAG (*startp
, BGP_ATTR_FLAG_PARTIAL
);
2407 /* Store transitive attribute to the end of attr->transit. */
2408 if (! ((attre
= bgp_attr_extra_get(attr
))->transit
) )
2409 attre
->transit
= XCALLOC (MTYPE_TRANSIT
, sizeof (struct transit
));
2411 transit
= attre
->transit
;
2414 transit
->val
= XREALLOC (MTYPE_TRANSIT_VAL
, transit
->val
,
2415 transit
->length
+ total
);
2417 transit
->val
= XMALLOC (MTYPE_TRANSIT_VAL
, total
);
2419 memcpy (transit
->val
+ transit
->length
, startp
, total
);
2420 transit
->length
+= total
;
2422 return BGP_ATTR_PARSE_PROCEED
;
2425 /* Well-known attribute check. */
2427 bgp_attr_check (struct peer
*peer
, struct attr
*attr
)
2431 /* BGP Graceful-Restart End-of-RIB for IPv4 unicast is signaled as an
2433 if (CHECK_FLAG (peer
->cap
, PEER_CAP_RESTART_RCV
) && !attr
->flag
)
2434 return BGP_ATTR_PARSE_PROCEED
;
2436 /* "An UPDATE message that contains the MP_UNREACH_NLRI is not required
2437 to carry any other path attributes.", though if MP_REACH_NLRI or NLRI
2438 are present, it should. Check for any other attribute being present
2441 if (attr
->flag
== ATTR_FLAG_BIT (BGP_ATTR_MP_UNREACH_NLRI
))
2442 return BGP_ATTR_PARSE_PROCEED
;
2444 if (! CHECK_FLAG (attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_ORIGIN
)))
2445 type
= BGP_ATTR_ORIGIN
;
2447 if (! CHECK_FLAG (attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH
)))
2448 type
= BGP_ATTR_AS_PATH
;
2450 /* RFC 2858 makes Next-Hop optional/ignored, if MP_REACH_NLRI is present and
2451 * NLRI is empty. We can't easily check NLRI empty here though.
2453 if (!CHECK_FLAG (attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP
))
2454 && !CHECK_FLAG (attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_MP_REACH_NLRI
)))
2455 type
= BGP_ATTR_NEXT_HOP
;
2457 if (peer
->sort
== BGP_PEER_IBGP
2458 && ! CHECK_FLAG (attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF
)))
2459 type
= BGP_ATTR_LOCAL_PREF
;
2463 zlog_warn ("%s Missing well-known attribute %s.", peer
->host
,
2464 LOOKUP (attr_str
, type
));
2465 bgp_notify_send_with_data (peer
,
2466 BGP_NOTIFY_UPDATE_ERR
,
2467 BGP_NOTIFY_UPDATE_MISS_ATTR
,
2469 return BGP_ATTR_PARSE_ERROR
;
2471 return BGP_ATTR_PARSE_PROCEED
;
2474 /* Read attribute of update packet. This function is called from
2475 bgp_update_receive() in bgp_packet.c. */
2476 bgp_attr_parse_ret_t
2477 bgp_attr_parse (struct peer
*peer
, struct attr
*attr
, bgp_size_t size
,
2478 struct bgp_nlri
*mp_update
, struct bgp_nlri
*mp_withdraw
)
2484 u_char
*startp
, *endp
;
2486 u_char seen
[BGP_ATTR_BITMAP_SIZE
];
2487 /* we need the as4_path only until we have synthesized the as_path with it */
2488 /* same goes for as4_aggregator */
2489 struct aspath
*as4_path
= NULL
;
2490 as_t as4_aggregator
= 0;
2491 struct in_addr as4_aggregator_addr
= { .s_addr
= 0 };
2493 /* Initialize bitmap. */
2494 memset (seen
, 0, BGP_ATTR_BITMAP_SIZE
);
2496 /* End pointer of BGP attribute. */
2497 endp
= BGP_INPUT_PNT (peer
) + size
;
2499 /* Get attributes to the end of attribute length. */
2500 while (BGP_INPUT_PNT (peer
) < endp
)
2502 /* Check remaining length check.*/
2503 if (endp
- BGP_INPUT_PNT (peer
) < BGP_ATTR_MIN_LEN
)
2505 /* XXX warning: long int format, int arg (arg 5) */
2506 zlog_warn ("%s: error BGP attribute length %lu is smaller than min len",
2508 (unsigned long) (endp
- STREAM_PNT (BGP_INPUT (peer
))));
2510 bgp_notify_send (peer
,
2511 BGP_NOTIFY_UPDATE_ERR
,
2512 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
2513 return BGP_ATTR_PARSE_ERROR
;
2516 /* Fetch attribute flag and type. */
2517 startp
= BGP_INPUT_PNT (peer
);
2518 /* "The lower-order four bits of the Attribute Flags octet are
2519 unused. They MUST be zero when sent and MUST be ignored when
2521 flag
= 0xF0 & stream_getc (BGP_INPUT (peer
));
2522 type
= stream_getc (BGP_INPUT (peer
));
2524 /* Check whether Extended-Length applies and is in bounds */
2525 if (CHECK_FLAG (flag
, BGP_ATTR_FLAG_EXTLEN
)
2526 && ((endp
- startp
) < (BGP_ATTR_MIN_LEN
+ 1)))
2528 zlog_warn ("%s: Extended length set, but just %lu bytes of attr header",
2530 (unsigned long) (endp
- STREAM_PNT (BGP_INPUT (peer
))));
2532 bgp_notify_send (peer
,
2533 BGP_NOTIFY_UPDATE_ERR
,
2534 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
2535 return BGP_ATTR_PARSE_ERROR
;
2538 /* Check extended attribue length bit. */
2539 if (CHECK_FLAG (flag
, BGP_ATTR_FLAG_EXTLEN
))
2540 length
= stream_getw (BGP_INPUT (peer
));
2542 length
= stream_getc (BGP_INPUT (peer
));
2544 /* If any attribute appears more than once in the UPDATE
2545 message, then the Error Subcode is set to Malformed Attribute
2548 if (CHECK_BITMAP (seen
, type
))
2550 zlog_warn ("%s: error BGP attribute type %d appears twice in a message",
2553 bgp_notify_send (peer
,
2554 BGP_NOTIFY_UPDATE_ERR
,
2555 BGP_NOTIFY_UPDATE_MAL_ATTR
);
2556 return BGP_ATTR_PARSE_ERROR
;
2559 /* Set type to bitmap to check duplicate attribute. `type' is
2560 unsigned char so it never overflow bitmap range. */
2562 SET_BITMAP (seen
, type
);
2564 /* Overflow check. */
2565 attr_endp
= BGP_INPUT_PNT (peer
) + length
;
2567 if (attr_endp
> endp
)
2569 zlog_warn ("%s: BGP type %d length %d is too large, attribute total length is %d. attr_endp is %p. endp is %p", peer
->host
, type
, length
, size
, attr_endp
, endp
);
2570 bgp_notify_send_with_data (peer
,
2571 BGP_NOTIFY_UPDATE_ERR
,
2572 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2573 startp
, attr_endp
- startp
);
2574 return BGP_ATTR_PARSE_ERROR
;
2577 struct bgp_attr_parser_args attr_args
= {
2584 .total
= attr_endp
- startp
,
2588 /* If any recognized attribute has Attribute Flags that conflict
2589 with the Attribute Type Code, then the Error Subcode is set to
2590 Attribute Flags Error. The Data field contains the erroneous
2591 attribute (type, length and value). */
2592 if (bgp_attr_flag_invalid (&attr_args
))
2594 bgp_attr_parse_ret_t ret
;
2595 ret
= bgp_attr_malformed (&attr_args
,
2596 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
2598 if (ret
== BGP_ATTR_PARSE_PROCEED
)
2603 /* OK check attribute and store it's value. */
2606 case BGP_ATTR_ORIGIN
:
2607 ret
= bgp_attr_origin (&attr_args
);
2609 case BGP_ATTR_AS_PATH
:
2610 ret
= bgp_attr_aspath (&attr_args
);
2612 case BGP_ATTR_AS4_PATH
:
2613 ret
= bgp_attr_as4_path (&attr_args
, &as4_path
);
2615 case BGP_ATTR_NEXT_HOP
:
2616 ret
= bgp_attr_nexthop (&attr_args
);
2618 case BGP_ATTR_MULTI_EXIT_DISC
:
2619 ret
= bgp_attr_med (&attr_args
);
2621 case BGP_ATTR_LOCAL_PREF
:
2622 ret
= bgp_attr_local_pref (&attr_args
);
2624 case BGP_ATTR_ATOMIC_AGGREGATE
:
2625 ret
= bgp_attr_atomic (&attr_args
);
2627 case BGP_ATTR_AGGREGATOR
:
2628 ret
= bgp_attr_aggregator (&attr_args
);
2630 case BGP_ATTR_AS4_AGGREGATOR
:
2631 ret
= bgp_attr_as4_aggregator (&attr_args
,
2633 &as4_aggregator_addr
);
2635 case BGP_ATTR_COMMUNITIES
:
2636 ret
= bgp_attr_community (&attr_args
);
2638 case BGP_ATTR_LARGE_COMMUNITIES
:
2639 ret
= bgp_attr_large_community (&attr_args
);
2641 case BGP_ATTR_ORIGINATOR_ID
:
2642 ret
= bgp_attr_originator_id (&attr_args
);
2644 case BGP_ATTR_CLUSTER_LIST
:
2645 ret
= bgp_attr_cluster_list (&attr_args
);
2647 case BGP_ATTR_MP_REACH_NLRI
:
2648 ret
= bgp_mp_reach_parse (&attr_args
, mp_update
);
2650 case BGP_ATTR_MP_UNREACH_NLRI
:
2651 ret
= bgp_mp_unreach_parse (&attr_args
, mp_withdraw
);
2653 case BGP_ATTR_EXT_COMMUNITIES
:
2654 ret
= bgp_attr_ext_communities (&attr_args
);
2659 case BGP_ATTR_ENCAP
:
2660 ret
= bgp_attr_encap (type
, peer
, length
, attr
, flag
, startp
);
2662 case BGP_ATTR_PREFIX_SID
:
2663 ret
= bgp_attr_prefix_sid (&attr_args
, mp_update
);
2666 ret
= bgp_attr_unknown (&attr_args
);
2670 if (ret
== BGP_ATTR_PARSE_ERROR_NOTIFYPLS
)
2672 bgp_notify_send (peer
,
2673 BGP_NOTIFY_UPDATE_ERR
,
2674 BGP_NOTIFY_UPDATE_MAL_ATTR
);
2675 ret
= BGP_ATTR_PARSE_ERROR
;
2678 /* If hard error occured immediately return to the caller. */
2679 if (ret
== BGP_ATTR_PARSE_ERROR
)
2681 zlog_warn ("%s: Attribute %s, parse error",
2683 LOOKUP (attr_str
, type
));
2685 aspath_unintern (&as4_path
);
2688 if (ret
== BGP_ATTR_PARSE_WITHDRAW
)
2691 zlog_warn ("%s: Attribute %s, parse error - treating as withdrawal",
2693 LOOKUP (attr_str
, type
));
2695 aspath_unintern (&as4_path
);
2699 /* Check the fetched length. */
2700 if (BGP_INPUT_PNT (peer
) != attr_endp
)
2702 zlog_warn ("%s: BGP attribute %s, fetch error",
2703 peer
->host
, LOOKUP (attr_str
, type
));
2704 bgp_notify_send (peer
,
2705 BGP_NOTIFY_UPDATE_ERR
,
2706 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
2708 aspath_unintern (&as4_path
);
2709 return BGP_ATTR_PARSE_ERROR
;
2713 /* Check final read pointer is same as end pointer. */
2714 if (BGP_INPUT_PNT (peer
) != endp
)
2716 zlog_warn ("%s: BGP attribute %s, length mismatch",
2717 peer
->host
, LOOKUP (attr_str
, type
));
2718 bgp_notify_send (peer
,
2719 BGP_NOTIFY_UPDATE_ERR
,
2720 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
2722 aspath_unintern (&as4_path
);
2723 return BGP_ATTR_PARSE_ERROR
;
2726 /* Check all mandatory well-known attributes are present */
2728 bgp_attr_parse_ret_t ret
;
2729 if ((ret
= bgp_attr_check (peer
, attr
)) < 0)
2732 aspath_unintern (&as4_path
);
2738 * At this place we can see whether we got AS4_PATH and/or
2739 * AS4_AGGREGATOR from a 16Bit peer and act accordingly.
2740 * We can not do this before we've read all attributes because
2741 * the as4 handling does not say whether AS4_PATH has to be sent
2742 * after AS_PATH or not - and when AS4_AGGREGATOR will be send
2743 * in relationship to AGGREGATOR.
2744 * So, to be defensive, we are not relying on any order and read
2745 * all attributes first, including these 32bit ones, and now,
2746 * afterwards, we look what and if something is to be done for as4.
2748 * It is possible to not have AS_PATH, e.g. GR EoR and sole
2751 /* actually... this doesn't ever return failure currently, but
2752 * better safe than sorry */
2753 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH
))
2754 && bgp_attr_munge_as4_attrs (peer
, attr
, as4_path
,
2755 as4_aggregator
, &as4_aggregator_addr
))
2757 bgp_notify_send (peer
,
2758 BGP_NOTIFY_UPDATE_ERR
,
2759 BGP_NOTIFY_UPDATE_MAL_ATTR
);
2761 aspath_unintern (&as4_path
);
2762 return BGP_ATTR_PARSE_ERROR
;
2765 /* At this stage, we have done all fiddling with as4, and the
2766 * resulting info is in attr->aggregator resp. attr->aspath
2767 * so we can chuck as4_aggregator and as4_path alltogether in
2768 * order to save memory
2772 aspath_unintern (&as4_path
); /* unintern - it is in the hash */
2773 /* The flag that we got this is still there, but that does not
2778 * The "rest" of the code does nothing with as4_aggregator.
2779 * there is no memory attached specifically which is not part
2781 * so ignoring just means do nothing.
2784 * Finally do the checks on the aspath we did not do yet
2785 * because we waited for a potentially synthesized aspath.
2787 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
)))
2789 ret
= bgp_attr_aspath_check (peer
, attr
);
2790 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
2795 /* Finally intern unknown attribute. */
2796 if (attr
->extra
->transit
)
2797 attr
->extra
->transit
= transit_intern (attr
->extra
->transit
);
2798 if (attr
->extra
->encap_subtlvs
)
2799 attr
->extra
->encap_subtlvs
= encap_intern (attr
->extra
->encap_subtlvs
, ENCAP_SUBTLV_TYPE
);
2801 if (attr
->extra
->vnc_subtlvs
)
2802 attr
->extra
->vnc_subtlvs
= encap_intern (attr
->extra
->vnc_subtlvs
, VNC_SUBTLV_TYPE
);
2806 return BGP_ATTR_PARSE_PROCEED
;
2810 bgp_packet_mpattr_start (struct stream
*s
, afi_t afi
, safi_t safi
, afi_t nh_afi
,
2811 struct bpacket_attr_vec_arr
*vecarr
,
2818 /* Set extended bit always to encode the attribute length as 2 bytes */
2819 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_EXTLEN
);
2820 stream_putc (s
, BGP_ATTR_MP_REACH_NLRI
);
2821 sizep
= stream_get_endp (s
);
2822 stream_putw (s
, 0); /* Marker: Attribute length. */
2825 /* Convert AFI, SAFI to values for packet. */
2826 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
2828 stream_putw (s
, pkt_afi
); /* AFI */
2829 stream_putc (s
, pkt_safi
); /* SAFI */
2830 if (afi
== AFI_L2VPN
)
2832 else if (nh_afi
== AFI_MAX
)
2833 nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->extra
->mp_nexthop_len
);
2842 case SAFI_MULTICAST
:
2843 case SAFI_LABELED_UNICAST
:
2844 bpacket_attr_vec_arr_set_vec (vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
2846 stream_put_ipv4 (s
, attr
->nexthop
.s_addr
);
2849 bpacket_attr_vec_arr_set_vec (vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
2850 stream_putc (s
, 12);
2851 stream_putl (s
, 0); /* RD = 0, per RFC */
2853 stream_put (s
, &attr
->extra
->mp_nexthop_global_in
, 4);
2857 stream_put (s
, &attr
->extra
->mp_nexthop_global_in
, 4);
2867 case SAFI_MULTICAST
:
2868 case SAFI_LABELED_UNICAST
:
2870 struct attr_extra
*attre
= attr
->extra
;
2872 assert (attr
->extra
);
2873 bpacket_attr_vec_arr_set_vec (vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
2875 if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
2876 stream_putc (s
, BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
);
2877 stream_put (s
, &attre
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2878 stream_put (s
, &attre
->mp_nexthop_local
, IPV6_MAX_BYTELEN
);
2880 stream_putc (s
, IPV6_MAX_BYTELEN
);
2881 stream_put (s
, &attre
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2887 struct attr_extra
*attre
= attr
->extra
;
2889 assert (attr
->extra
);
2890 if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
) {
2891 stream_putc (s
, 24);
2892 stream_putl (s
, 0); /* RD = 0, per RFC */
2894 stream_put (s
, &attre
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2895 } else if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
2896 stream_putc (s
, 48);
2897 stream_putl (s
, 0); /* RD = 0, per RFC */
2899 stream_put (s
, &attre
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2900 stream_putl (s
, 0); /* RD = 0, per RFC */
2902 stream_put (s
, &attre
->mp_nexthop_local
, IPV6_MAX_BYTELEN
);
2907 assert (attr
->extra
);
2908 stream_putc (s
, IPV6_MAX_BYTELEN
);
2909 stream_put (s
, &attr
->extra
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2919 if (attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV4
)
2921 stream_putc (s
, 12);
2922 stream_putl (s
, 0); /* RD = 0, per RFC */
2924 stream_put (s
, &attr
->extra
->mp_nexthop_global_in
, 4);
2926 else if (attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
)
2928 stream_putc (s
, 24);
2929 stream_putl (s
, 0); /* RD = 0, per RFC */
2931 stream_put (s
, &attr
->extra
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2933 else if (attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
2935 stream_putc (s
, 48);
2936 stream_putl (s
, 0); /* RD = 0, per RFC */
2938 stream_put (s
, &attr
->extra
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
2939 stream_putl (s
, 0); /* RD = 0, per RFC */
2941 stream_put (s
, &attr
->extra
->mp_nexthop_local
, IPV6_MAX_BYTELEN
);
2958 bgp_packet_mpattr_prefix (struct stream
*s
, afi_t afi
, safi_t safi
,
2959 struct prefix
*p
, struct prefix_rd
*prd
,
2960 u_char
*tag
, int addpath_encode
,
2961 u_int32_t addpath_tx_id
, struct attr
*attr
)
2963 if (safi
== SAFI_MPLS_VPN
)
2966 stream_putl(s
, addpath_tx_id
);
2967 /* Tag, RD, Prefix write. */
2968 stream_putc (s
, p
->prefixlen
+ 88);
2969 stream_put (s
, tag
, 3);
2970 stream_put (s
, prd
->val
, 8);
2971 stream_put (s
, &p
->u
.prefix
, PSIZE (p
->prefixlen
));
2973 else if (safi
== SAFI_EVPN
)
2975 bgp_packet_mpattr_route_type_5(s
, p
, prd
, tag
, attr
);
2977 else if (safi
== SAFI_LABELED_UNICAST
)
2979 /* Prefix write with label. */
2980 stream_put_labeled_prefix(s
, p
, tag
);
2983 stream_put_prefix_addpath (s
, p
, addpath_encode
, addpath_tx_id
);
2987 bgp_packet_mpattr_prefix_size (afi_t afi
, safi_t safi
, struct prefix
*p
)
2989 int size
= PSIZE (p
->prefixlen
);
2990 if (safi
== SAFI_MPLS_VPN
)
2996 * Encodes the tunnel encapsulation attribute,
2997 * and with ENABLE_BGP_VNC the VNC attribute which uses
2998 * almost the same TLV format
3001 bgp_packet_mpattr_tea(
3008 unsigned int attrlenfield
= 0;
3009 unsigned int attrhdrlen
= 0;
3010 struct bgp_attr_encap_subtlv
*subtlvs
;
3011 struct bgp_attr_encap_subtlv
*st
;
3012 const char *attrname
;
3014 if (!attr
|| !attr
->extra
||
3015 (attrtype
== BGP_ATTR_ENCAP
&&
3016 (!attr
->extra
->encap_tunneltype
||
3017 attr
->extra
->encap_tunneltype
== BGP_ENCAP_TYPE_MPLS
)))
3021 case BGP_ATTR_ENCAP
:
3022 attrname
= "Tunnel Encap";
3023 subtlvs
= attr
->extra
->encap_subtlvs
;
3026 * The tunnel encap attr has an "outer" tlv.
3028 * L = total length of subtlvs,
3029 * V = concatenated subtlvs.
3031 attrlenfield
= 2 + 2; /* T + L */
3032 attrhdrlen
= 1 + 1; /* subTLV T + L */
3038 subtlvs
= attr
->extra
->vnc_subtlvs
;
3039 attrlenfield
= 0; /* no outer T + L */
3040 attrhdrlen
= 2 + 2; /* subTLV T + L */
3048 /* compute attr length */
3049 for (st
= subtlvs
; st
; st
= st
->next
) {
3050 attrlenfield
+= (attrhdrlen
+ st
->length
);
3053 if (attrlenfield
> 0xffff) {
3054 zlog_info ("%s attribute is too long (length=%d), can't send it",
3060 if (attrlenfield
> 0xff) {
3061 /* 2-octet length field */
3063 BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_EXTLEN
);
3064 stream_putc (s
, attrtype
);
3065 stream_putw (s
, attrlenfield
& 0xffff);
3067 /* 1-octet length field */
3068 stream_putc (s
, BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_OPTIONAL
);
3069 stream_putc (s
, attrtype
);
3070 stream_putc (s
, attrlenfield
& 0xff);
3073 if (attrtype
== BGP_ATTR_ENCAP
) {
3074 /* write outer T+L */
3075 stream_putw(s
, attr
->extra
->encap_tunneltype
);
3076 stream_putw(s
, attrlenfield
- 4);
3079 /* write each sub-tlv */
3080 for (st
= subtlvs
; st
; st
= st
->next
) {
3081 if (attrtype
== BGP_ATTR_ENCAP
) {
3082 stream_putc (s
, st
->type
);
3083 stream_putc (s
, st
->length
);
3086 stream_putw (s
, st
->type
);
3087 stream_putw (s
, st
->length
);
3090 stream_put (s
, st
->value
, st
->length
);
3095 bgp_packet_mpattr_end (struct stream
*s
, size_t sizep
)
3097 /* Set MP attribute length. Don't count the (2) bytes used to encode
3099 stream_putw_at (s
, sizep
, (stream_get_endp (s
) - sizep
) - 2);
3102 /* Make attribute packet. */
3104 bgp_packet_attribute (struct bgp
*bgp
, struct peer
*peer
,
3105 struct stream
*s
, struct attr
*attr
,
3106 struct bpacket_attr_vec_arr
*vecarr
,
3107 struct prefix
*p
, afi_t afi
, safi_t safi
,
3108 struct peer
*from
, struct prefix_rd
*prd
, u_char
*tag
,
3110 u_int32_t addpath_tx_id
)
3113 size_t aspath_sizep
;
3114 struct aspath
*aspath
;
3115 int send_as4_path
= 0;
3116 int send_as4_aggregator
= 0;
3117 int use32bit
= (CHECK_FLAG (peer
->cap
, PEER_CAP_AS4_RCV
)) ? 1 : 0;
3122 /* Remember current pointer. */
3123 cp
= stream_get_endp (s
);
3125 if (p
&& !((afi
== AFI_IP
&& safi
== SAFI_UNICAST
) &&
3126 !peer_cap_enhe(peer
, afi
, safi
)))
3128 size_t mpattrlen_pos
= 0;
3130 mpattrlen_pos
= bgp_packet_mpattr_start(s
, afi
, safi
,
3131 (peer_cap_enhe(peer
, afi
, safi
) ? AFI_IP6
:
3132 AFI_MAX
), /* get from NH */
3134 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, tag
,
3135 addpath_encode
, addpath_tx_id
, attr
);
3136 bgp_packet_mpattr_end(s
, mpattrlen_pos
);
3139 /* Origin attribute. */
3140 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3141 stream_putc (s
, BGP_ATTR_ORIGIN
);
3143 stream_putc (s
, attr
->origin
);
3145 /* AS path attribute. */
3147 /* If remote-peer is EBGP */
3148 if (peer
->sort
== BGP_PEER_EBGP
3149 && (! CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_AS_PATH_UNCHANGED
)
3150 || attr
->aspath
->segments
== NULL
)
3151 && (! CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_RSERVER_CLIENT
)))
3153 aspath
= aspath_dup (attr
->aspath
);
3155 /* Even though we may not be configured for confederations we may have
3156 * RXed an AS_PATH with AS_CONFED_SEQUENCE or AS_CONFED_SET */
3157 aspath
= aspath_delete_confed_seq (aspath
);
3159 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
))
3161 /* Stuff our path CONFED_ID on the front */
3162 aspath
= aspath_add_seq (aspath
, bgp
->confed_id
);
3166 if (peer
->change_local_as
) {
3167 /* If replace-as is specified, we only use the change_local_as when
3168 advertising routes. */
3169 if( ! CHECK_FLAG (peer
->flags
, PEER_FLAG_LOCAL_AS_REPLACE_AS
) ) {
3170 aspath
= aspath_add_seq (aspath
, peer
->local_as
);
3172 aspath
= aspath_add_seq (aspath
, peer
->change_local_as
);
3174 aspath
= aspath_add_seq (aspath
, peer
->local_as
);
3178 else if (peer
->sort
== BGP_PEER_CONFED
)
3180 /* A confed member, so we need to do the AS_CONFED_SEQUENCE thing */
3181 aspath
= aspath_dup (attr
->aspath
);
3182 aspath
= aspath_add_confed_seq (aspath
, peer
->local_as
);
3185 aspath
= attr
->aspath
;
3187 /* If peer is not AS4 capable, then:
3188 * - send the created AS_PATH out as AS4_PATH (optional, transitive),
3189 * but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path segment
3190 * types are in it (i.e. exclude them if they are there)
3191 * AND do this only if there is at least one asnum > 65535 in the path!
3192 * - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and change
3193 * all ASnums > 65535 to BGP_AS_TRANS
3196 stream_putc (s
, BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3197 stream_putc (s
, BGP_ATTR_AS_PATH
);
3198 aspath_sizep
= stream_get_endp (s
);
3200 stream_putw_at (s
, aspath_sizep
, aspath_put (s
, aspath
, use32bit
));
3202 /* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
3205 if (!use32bit
&& aspath_has_as4 (aspath
))
3206 send_as4_path
= 1; /* we'll do this later, at the correct place */
3208 /* Nexthop attribute. */
3209 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
&& !peer_cap_enhe(peer
, afi
, safi
))
3211 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP
))
3213 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3214 stream_putc (s
, BGP_ATTR_NEXT_HOP
);
3215 bpacket_attr_vec_arr_set_vec (vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
3217 stream_put_ipv4 (s
, attr
->nexthop
.s_addr
);
3219 else if (peer_cap_enhe(from
, afi
, safi
))
3222 * Likely this is the case when an IPv4 prefix was received with
3223 * Extended Next-hop capability and now being advertised to
3225 * Setting the mandatory (ipv4) next-hop attribute here to enable
3226 * implicit next-hop self with correct (ipv4 address family).
3228 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3229 stream_putc (s
, BGP_ATTR_NEXT_HOP
);
3230 bpacket_attr_vec_arr_set_vec (vecarr
, BGP_ATTR_VEC_NH
, s
, NULL
);
3232 stream_put_ipv4 (s
, 0);
3236 /* MED attribute. */
3237 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC
) ||
3240 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
);
3241 stream_putc (s
, BGP_ATTR_MULTI_EXIT_DISC
);
3243 stream_putl (s
, (bgp
->maxmed_active
? bgp
->maxmed_value
: attr
->med
));
3246 /* Local preference. */
3247 if (peer
->sort
== BGP_PEER_IBGP
||
3248 peer
->sort
== BGP_PEER_CONFED
)
3250 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3251 stream_putc (s
, BGP_ATTR_LOCAL_PREF
);
3253 stream_putl (s
, attr
->local_pref
);
3256 /* Atomic aggregate. */
3257 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE
))
3259 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3260 stream_putc (s
, BGP_ATTR_ATOMIC_AGGREGATE
);
3265 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR
))
3267 assert (attr
->extra
);
3269 /* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
3270 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3271 stream_putc (s
, BGP_ATTR_AGGREGATOR
);
3275 /* AS4 capable peer */
3277 stream_putl (s
, attr
->extra
->aggregator_as
);
3281 /* 2-byte AS peer */
3284 /* Is ASN representable in 2-bytes? Or must AS_TRANS be used? */
3285 if ( attr
->extra
->aggregator_as
> 65535 )
3287 stream_putw (s
, BGP_AS_TRANS
);
3289 /* we have to send AS4_AGGREGATOR, too.
3290 * we'll do that later in order to send attributes in ascending
3293 send_as4_aggregator
= 1;
3296 stream_putw (s
, (u_int16_t
) attr
->extra
->aggregator_as
);
3298 stream_put_ipv4 (s
, attr
->extra
->aggregator_addr
.s_addr
);
3301 /* Community attribute. */
3302 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
)
3303 && (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES
)))
3305 if (attr
->community
->size
* 4 > 255)
3307 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3308 stream_putc (s
, BGP_ATTR_COMMUNITIES
);
3309 stream_putw (s
, attr
->community
->size
* 4);
3313 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3314 stream_putc (s
, BGP_ATTR_COMMUNITIES
);
3315 stream_putc (s
, attr
->community
->size
* 4);
3317 stream_put (s
, attr
->community
->val
, attr
->community
->size
* 4);
3321 * Large Community attribute.
3324 CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_LARGE_COMMUNITY
)
3325 && (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES
)))
3327 if (attr
->extra
->lcommunity
->size
* 12 > 255)
3329 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3330 stream_putc (s
, BGP_ATTR_LARGE_COMMUNITIES
);
3331 stream_putw (s
, attr
->extra
->lcommunity
->size
* 12);
3335 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3336 stream_putc (s
, BGP_ATTR_LARGE_COMMUNITIES
);
3337 stream_putc (s
, attr
->extra
->lcommunity
->size
* 12);
3339 stream_put (s
, attr
->extra
->lcommunity
->val
, attr
->extra
->lcommunity
->size
* 12);
3342 /* Route Reflector. */
3343 if (peer
->sort
== BGP_PEER_IBGP
3345 && from
->sort
== BGP_PEER_IBGP
)
3347 /* Originator ID. */
3348 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
);
3349 stream_putc (s
, BGP_ATTR_ORIGINATOR_ID
);
3352 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
3353 stream_put_in_addr (s
, &attr
->extra
->originator_id
);
3355 stream_put_in_addr (s
, &from
->remote_id
);
3358 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
);
3359 stream_putc (s
, BGP_ATTR_CLUSTER_LIST
);
3361 if (attr
->extra
&& attr
->extra
->cluster
)
3363 stream_putc (s
, attr
->extra
->cluster
->length
+ 4);
3364 /* If this peer configuration's parent BGP has cluster_id. */
3365 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
3366 stream_put_in_addr (s
, &bgp
->cluster_id
);
3368 stream_put_in_addr (s
, &bgp
->router_id
);
3369 stream_put (s
, attr
->extra
->cluster
->list
,
3370 attr
->extra
->cluster
->length
);
3375 /* If this peer configuration's parent BGP has cluster_id. */
3376 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
3377 stream_put_in_addr (s
, &bgp
->cluster_id
);
3379 stream_put_in_addr (s
, &bgp
->router_id
);
3383 /* Extended Communities attribute. */
3384 if (CHECK_FLAG (peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
)
3385 && (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES
)))
3387 struct attr_extra
*attre
= attr
->extra
;
3391 if (peer
->sort
== BGP_PEER_IBGP
3392 || peer
->sort
== BGP_PEER_CONFED
)
3394 if (attre
->ecommunity
->size
* 8 > 255)
3396 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3397 stream_putc (s
, BGP_ATTR_EXT_COMMUNITIES
);
3398 stream_putw (s
, attre
->ecommunity
->size
* 8);
3402 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3403 stream_putc (s
, BGP_ATTR_EXT_COMMUNITIES
);
3404 stream_putc (s
, attre
->ecommunity
->size
* 8);
3406 stream_put (s
, attre
->ecommunity
->val
, attre
->ecommunity
->size
* 8);
3412 int ecom_tr_size
= 0;
3415 for (i
= 0; i
< attre
->ecommunity
->size
; i
++)
3417 pnt
= attre
->ecommunity
->val
+ (i
* 8);
3420 if (CHECK_FLAG (tbit
, ECOMMUNITY_FLAG_NON_TRANSITIVE
))
3428 if (ecom_tr_size
* 8 > 255)
3430 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3431 stream_putc (s
, BGP_ATTR_EXT_COMMUNITIES
);
3432 stream_putw (s
, ecom_tr_size
* 8);
3436 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3437 stream_putc (s
, BGP_ATTR_EXT_COMMUNITIES
);
3438 stream_putc (s
, ecom_tr_size
* 8);
3441 for (i
= 0; i
< attre
->ecommunity
->size
; i
++)
3443 pnt
= attre
->ecommunity
->val
+ (i
* 8);
3446 if (CHECK_FLAG (tbit
, ECOMMUNITY_FLAG_NON_TRANSITIVE
))
3449 stream_put (s
, pnt
, 8);
3455 /* Label index attribute. */
3456 if (safi
== SAFI_LABELED_UNICAST
)
3458 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID
))
3460 u_int32_t label_index
;
3462 assert (attr
->extra
);
3463 label_index
= attr
->extra
->label_index
;
3465 if (label_index
!= BGP_INVALID_LABEL_INDEX
)
3467 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3468 stream_putc (s
, BGP_ATTR_PREFIX_SID
);
3469 stream_putc (s
, 10);
3470 stream_putc (s
, BGP_PREFIX_SID_LABEL_INDEX
);
3471 stream_putw (s
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
3472 stream_putc (s
, 0); // reserved
3473 stream_putw (s
, 0); // flags
3474 stream_putl (s
, label_index
);
3479 if ( send_as4_path
)
3481 /* If the peer is NOT As4 capable, AND */
3482 /* there are ASnums > 65535 in path THEN
3483 * give out AS4_PATH */
3485 /* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
3487 * Hm, I wonder... confederation things *should* only be at
3488 * the beginning of an aspath, right? Then we should use
3489 * aspath_delete_confed_seq for this, because it is already
3491 * Folks, talk to me: what is reasonable here!?
3493 aspath
= aspath_delete_confed_seq (aspath
);
3495 stream_putc (s
, BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_EXTLEN
);
3496 stream_putc (s
, BGP_ATTR_AS4_PATH
);
3497 aspath_sizep
= stream_get_endp (s
);
3499 stream_putw_at (s
, aspath_sizep
, aspath_put (s
, aspath
, 1));
3502 if (aspath
!= attr
->aspath
)
3503 aspath_free (aspath
);
3505 if ( send_as4_aggregator
)
3507 assert (attr
->extra
);
3509 /* send AS4_AGGREGATOR, at this place */
3510 /* this section of code moved here in order to ensure the correct
3511 * *ascending* order of attributes
3513 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3514 stream_putc (s
, BGP_ATTR_AS4_AGGREGATOR
);
3516 stream_putl (s
, attr
->extra
->aggregator_as
);
3517 stream_put_ipv4 (s
, attr
->extra
->aggregator_addr
.s_addr
);
3520 if (((afi
== AFI_IP
|| afi
== AFI_IP6
) &&
3521 (safi
== SAFI_ENCAP
|| safi
== SAFI_MPLS_VPN
)) ||
3522 (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
))
3524 /* Tunnel Encap attribute */
3525 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_ENCAP
);
3529 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_VNC
);
3533 /* Unknown transit attribute. */
3534 if (attr
->extra
&& attr
->extra
->transit
)
3535 stream_put (s
, attr
->extra
->transit
->val
, attr
->extra
->transit
->length
);
3537 /* Return total size of attribute. */
3538 return stream_get_endp (s
) - cp
;
3542 bgp_packet_mpunreach_start (struct stream
*s
, afi_t afi
, safi_t safi
)
3544 unsigned long attrlen_pnt
;
3548 /* Set extended bit always to encode the attribute length as 2 bytes */
3549 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_EXTLEN
);
3550 stream_putc (s
, BGP_ATTR_MP_UNREACH_NLRI
);
3552 attrlen_pnt
= stream_get_endp (s
);
3553 stream_putw (s
, 0); /* Length of this attribute. */
3555 /* Convert AFI, SAFI to values for packet. */
3556 bgp_map_afi_safi_int2iana (afi
, safi
, &pkt_afi
, &pkt_safi
);
3558 stream_putw (s
, pkt_afi
);
3559 stream_putc (s
, pkt_safi
);
3565 bgp_packet_mpunreach_prefix (struct stream
*s
, struct prefix
*p
,
3566 afi_t afi
, safi_t safi
, struct prefix_rd
*prd
,
3567 u_char
*tag
, int addpath_encode
,
3568 u_int32_t addpath_tx_id
, struct attr
*attr
)
3570 u_char wlabel
[3] = {0x80, 0x00, 0x00};
3572 if (safi
== SAFI_LABELED_UNICAST
)
3575 return bgp_packet_mpattr_prefix (s
, afi
, safi
, p
, prd
,
3576 tag
, addpath_encode
, addpath_tx_id
, attr
);
3580 bgp_packet_mpunreach_end (struct stream
*s
, size_t attrlen_pnt
)
3582 bgp_packet_mpattr_end (s
, attrlen_pnt
);
3585 /* Initialization of attribute. */
3587 bgp_attr_init (void)
3600 bgp_attr_finish (void)
3604 community_finish ();
3605 ecommunity_finish ();
3606 lcommunity_finish ();
3612 /* Make attribute packet. */
3614 bgp_dump_routes_attr (struct stream
*s
, struct attr
*attr
,
3615 struct prefix
*prefix
)
3620 struct aspath
*aspath
;
3621 int addpath_encode
= 0;
3622 u_int32_t addpath_tx_id
= 0;
3624 /* Remember current pointer. */
3625 cp
= stream_get_endp (s
);
3627 /* Place holder of length. */
3630 /* Origin attribute. */
3631 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3632 stream_putc (s
, BGP_ATTR_ORIGIN
);
3634 stream_putc (s
, attr
->origin
);
3636 aspath
= attr
->aspath
;
3638 stream_putc (s
, BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3639 stream_putc (s
, BGP_ATTR_AS_PATH
);
3640 aspath_lenp
= stream_get_endp (s
);
3643 stream_putw_at (s
, aspath_lenp
, aspath_put (s
, aspath
, 1));
3645 /* Nexthop attribute. */
3646 /* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
3647 if(prefix
!= NULL
&& prefix
->family
!= AF_INET6
)
3649 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3650 stream_putc (s
, BGP_ATTR_NEXT_HOP
);
3652 stream_put_ipv4 (s
, attr
->nexthop
.s_addr
);
3655 /* MED attribute. */
3656 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC
))
3658 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
);
3659 stream_putc (s
, BGP_ATTR_MULTI_EXIT_DISC
);
3661 stream_putl (s
, attr
->med
);
3664 /* Local preference. */
3665 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF
))
3667 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3668 stream_putc (s
, BGP_ATTR_LOCAL_PREF
);
3670 stream_putl (s
, attr
->local_pref
);
3673 /* Atomic aggregate. */
3674 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE
))
3676 stream_putc (s
, BGP_ATTR_FLAG_TRANS
);
3677 stream_putc (s
, BGP_ATTR_ATOMIC_AGGREGATE
);
3682 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR
))
3684 assert (attr
->extra
);
3685 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3686 stream_putc (s
, BGP_ATTR_AGGREGATOR
);
3688 stream_putl (s
, attr
->extra
->aggregator_as
);
3689 stream_put_ipv4 (s
, attr
->extra
->aggregator_addr
.s_addr
);
3692 /* Community attribute. */
3693 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES
))
3695 if (attr
->community
->size
* 4 > 255)
3697 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3698 stream_putc (s
, BGP_ATTR_COMMUNITIES
);
3699 stream_putw (s
, attr
->community
->size
* 4);
3703 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3704 stream_putc (s
, BGP_ATTR_COMMUNITIES
);
3705 stream_putc (s
, attr
->community
->size
* 4);
3707 stream_put (s
, attr
->community
->val
, attr
->community
->size
* 4);
3710 /* Large Community attribute. */
3711 if (attr
->extra
&& attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES
))
3713 if (attr
->extra
->lcommunity
->size
* 12 > 255)
3715 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
|BGP_ATTR_FLAG_EXTLEN
);
3716 stream_putc (s
, BGP_ATTR_LARGE_COMMUNITIES
);
3717 stream_putw (s
, attr
->extra
->lcommunity
->size
* 12);
3721 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3722 stream_putc (s
, BGP_ATTR_LARGE_COMMUNITIES
);
3723 stream_putc (s
, attr
->extra
->lcommunity
->size
* 12);
3726 stream_put (s
, attr
->extra
->lcommunity
->val
, attr
->extra
->lcommunity
->size
* 12);
3729 /* Add a MP_NLRI attribute to dump the IPv6 next hop */
3730 if (prefix
!= NULL
&& prefix
->family
== AF_INET6
&& attr
->extra
&&
3731 (attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
||
3732 attr
->extra
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) )
3735 struct attr_extra
*attre
= attr
->extra
;
3737 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
3738 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
3739 sizep
= stream_get_endp (s
);
3742 stream_putc (s
, 0); /* Marker: Attribute length. */
3743 stream_putw(s
, AFI_IP6
); /* AFI */
3744 stream_putc(s
, SAFI_UNICAST
); /* SAFI */
3747 stream_putc(s
, attre
->mp_nexthop_len
);
3748 stream_put(s
, &attre
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
3749 if (attre
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
3750 stream_put(s
, &attre
->mp_nexthop_local
, IPV6_MAX_BYTELEN
);
3756 stream_put_prefix_addpath (s
, prefix
, addpath_encode
, addpath_tx_id
);
3758 /* Set MP attribute length. */
3759 stream_putc_at (s
, sizep
, (stream_get_endp (s
) - sizep
) - 1);
3763 if (attr
->flag
& ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID
))
3765 assert (attr
->extra
);
3767 if (attr
->extra
->label_index
!= BGP_INVALID_LABEL_INDEX
)
3769 stream_putc (s
, BGP_ATTR_FLAG_OPTIONAL
|BGP_ATTR_FLAG_TRANS
);
3770 stream_putc (s
, BGP_ATTR_PREFIX_SID
);
3771 stream_putc (s
, 10);
3772 stream_putc (s
, BGP_PREFIX_SID_LABEL_INDEX
);
3773 stream_putc (s
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
3774 stream_putc (s
, 0); // reserved
3775 stream_putw (s
, 0); // flags
3776 stream_putl (s
, attr
->extra
->label_index
);
3780 /* Return total size of attribute. */
3781 len
= stream_get_endp (s
) - cp
- 2;
3782 stream_putw_at (s
, cp
, len
);