1 /* BGP carrying label information
2 * Copyright (C) 2013 Cumulus Networks, Inc.
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
34 #include "bgpd/bgpd.h"
35 #include "bgpd/bgp_table.h"
36 #include "bgpd/bgp_route.h"
37 #include "bgpd/bgp_attr.h"
38 #include "bgpd/bgp_label.h"
39 #include "bgpd/bgp_packet.h"
40 #include "bgpd/bgp_debug.h"
41 #include "bgpd/bgp_errors.h"
43 extern struct zclient
*zclient
;
45 int bgp_parse_fec_update(void)
48 struct bgp_dest
*dest
;
50 struct bgp_table
*table
;
58 memset(&p
, 0, sizeof(struct prefix
));
59 p
.family
= stream_getw(s
);
60 p
.prefixlen
= stream_getc(s
);
61 stream_get(p
.u
.val
, s
, PSIZE(p
.prefixlen
));
62 label
= stream_getl(s
);
64 /* hack for the bgp instance & SAFI = have to send/receive it */
65 afi
= family2afi(p
.family
);
67 bgp
= bgp_get_default();
69 zlog_debug("no default bgp instance");
73 table
= bgp
->rib
[afi
][safi
];
75 zlog_debug("no %u unicast table", p
.family
);
78 dest
= bgp_node_lookup(table
, &p
);
80 zlog_debug("no node for the prefix");
84 /* treat it as implicit withdraw - the label is invalid */
85 if (label
== MPLS_INVALID_LABEL
)
86 bgp_unset_valid_label(&dest
->local_label
);
88 label_ntop(label
, 1, &dest
->local_label
);
89 bgp_set_valid_label(&dest
->local_label
);
91 SET_FLAG(dest
->flags
, BGP_NODE_LABEL_CHANGED
);
92 bgp_dest_unlock_node(dest
);
93 bgp_process(bgp
, dest
, afi
, safi
);
97 mpls_label_t
bgp_adv_label(struct bgp_dest
*dest
, struct bgp_path_info
*pi
,
98 struct peer
*to
, afi_t afi
, safi_t safi
)
101 mpls_label_t remote_label
;
104 if (!dest
|| !pi
|| !to
)
105 return MPLS_INVALID_LABEL
;
107 remote_label
= pi
->extra
? pi
->extra
->label
[0] : MPLS_INVALID_LABEL
;
110 ((from
->sort
== BGP_PEER_IBGP
) && (to
->sort
== BGP_PEER_IBGP
));
113 && !CHECK_FLAG(to
->af_flags
[afi
][safi
],
114 PEER_FLAG_FORCE_NEXTHOP_SELF
))
117 if (CHECK_FLAG(to
->af_flags
[afi
][safi
], PEER_FLAG_NEXTHOP_UNCHANGED
))
120 return dest
->local_label
;
124 * This is passed as the callback function to bgp_labelpool.c:bgp_lp_get()
125 * by bgp_reg_dereg_for_label() when a label needs to be obtained from
127 * Note that it will reject the allocated label if a label index is found,
128 * because the label index supposes predictable labels
130 int bgp_reg_for_label_callback(mpls_label_t new_label
, void *labelid
,
133 struct bgp_path_info
*pi
;
134 struct bgp_dest
*dest
;
137 /* Is this path still valid? */
138 if (!bgp_path_info_unlock(pi
)) {
139 if (BGP_DEBUG(labelpool
, LABELPOOL
))
141 "%s: bgp_path_info is no longer valid, ignoring",
148 if (BGP_DEBUG(labelpool
, LABELPOOL
))
149 zlog_debug("%s: FEC %pRN label=%u, allocated=%d", __func__
,
150 bgp_dest_to_rnode(dest
), new_label
, allocated
);
154 * previously-allocated label is now invalid
156 if (pi
->attr
->label_index
== MPLS_INVALID_LABEL_INDEX
157 && pi
->attr
->label
!= MPLS_LABEL_NONE
158 && CHECK_FLAG(dest
->flags
, BGP_NODE_REGISTERED_FOR_LABEL
)) {
159 bgp_unregister_for_label(dest
);
160 label_ntop(MPLS_LABEL_IMPLICIT_NULL
, 1,
162 bgp_set_valid_label(&dest
->local_label
);
168 * label index is assigned, this should be handled by SR-related code,
169 * so retry FEC registration and then reject label allocation for
170 * it to be released to label pool
172 if (pi
->attr
->label_index
!= MPLS_INVALID_LABEL_INDEX
) {
175 "%s: FEC %pRN Rejecting allocated label %u as Label Index is %u",
176 __func__
, bgp_dest_to_rnode(dest
), new_label
,
177 pi
->attr
->label_index
);
179 bgp_register_for_label(pi
->net
, pi
);
184 if (pi
->attr
->label
!= MPLS_INVALID_LABEL
) {
185 if (new_label
== pi
->attr
->label
) {
186 /* already have same label, accept but do nothing */
189 /* Shouldn't happen: different label allocation */
190 flog_err(EC_BGP_LABEL
,
191 "%s: %pRN had label %u but got new assignment %u",
192 __func__
, bgp_dest_to_rnode(dest
), pi
->attr
->label
,
194 /* continue means use new one */
197 label_ntop(new_label
, 1, &dest
->local_label
);
198 bgp_set_valid_label(&dest
->local_label
);
201 * Get back to registering the FEC
203 bgp_register_for_label(pi
->net
, pi
);
208 void bgp_reg_dereg_for_label(struct bgp_dest
*dest
, struct bgp_path_info
*pi
,
211 bool with_label_index
= false;
213 const struct prefix
*p
;
214 mpls_label_t
*local_label
;
217 size_t flags_pos
= 0;
218 char addr
[PREFIX_STRLEN
];
220 p
= bgp_dest_get_prefix(dest
);
221 local_label
= &(dest
->local_label
);
222 /* this prevents the loop when we're called by
223 * bgp_reg_for_label_callback()
225 bool have_label_to_reg
= bgp_is_valid_label(local_label
)
226 && label_pton(local_label
) != MPLS_LABEL_IMPLICIT_NULL
;
231 * Determine if we will let zebra should derive label from
232 * label index instead of bgpd requesting from label pool
234 if (CHECK_FLAG(pi
->attr
->flag
,
235 ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
))
236 && pi
->attr
->label_index
!= BGP_INVALID_LABEL_INDEX
) {
237 with_label_index
= true;
240 * If no label index was provided -- assume any label
241 * from label pool will do. This means that label index
242 * always takes precedence over auto-assigned labels.
244 if (!have_label_to_reg
) {
245 if (BGP_DEBUG(labelpool
, LABELPOOL
)) {
246 prefix2str(p
, addr
, PREFIX_STRLEN
);
247 zlog_debug("%s: Requesting label from LP for %s",
250 /* bgp_reg_for_label_callback() will call back
251 * __func__ when it gets a label from the pool.
252 * This means we'll never register FECs without
255 bgp_lp_get(LP_TYPE_BGP_LU
, pi
,
256 bgp_reg_for_label_callback
);
263 if (!zclient
|| zclient
->sock
< 0)
266 /* If the route node has a local_label assigned or the
267 * path node has an MPLS SR label index allowing zebra to
268 * derive the label, proceed with registration. */
271 command
= (reg
) ? ZEBRA_FEC_REGISTER
: ZEBRA_FEC_UNREGISTER
;
272 zclient_create_header(s
, command
, VRF_DEFAULT
);
273 flags_pos
= stream_get_endp(s
); /* save position of 'flags' */
274 stream_putw(s
, flags
); /* initial flags */
275 stream_putw(s
, PREFIX_FAMILY(p
));
276 stream_put_prefix(s
, p
);
278 if (have_label_to_reg
) {
279 flags
|= ZEBRA_FEC_REGISTER_LABEL
;
280 stream_putl(s
, label_pton(local_label
));
281 } else if (with_label_index
) {
282 flags
|= ZEBRA_FEC_REGISTER_LABEL_INDEX
;
283 stream_putl(s
, pi
->attr
->label_index
);
285 SET_FLAG(dest
->flags
, BGP_NODE_REGISTERED_FOR_LABEL
);
287 UNSET_FLAG(dest
->flags
, BGP_NODE_REGISTERED_FOR_LABEL
);
289 /* Set length and flags */
290 stream_putw_at(s
, 0, stream_get_endp(s
));
293 * We only need to write new flags if this is a register
296 stream_putw_at(s
, flags_pos
, flags
);
298 zclient_send_message(zclient
);
301 static int bgp_nlri_get_labels(struct peer
*peer
, uint8_t *pnt
, uint8_t plen
,
305 uint8_t *lim
= pnt
+ plen
;
307 uint8_t label_depth
= 0;
309 for (; data
< lim
; data
+= BGP_LABEL_BYTES
) {
310 memcpy(label
, data
, BGP_LABEL_BYTES
);
311 llen
+= BGP_LABEL_BYTES
;
313 bgp_set_valid_label(label
);
316 if (bgp_is_withdraw_label(label
) || label_bos(label
))
320 /* If we RX multiple labels we will end up keeping only the last
321 * one. We do not yet support a label stack greater than 1. */
323 zlog_info("%s rcvd UPDATE with label stack %d deep", peer
->host
,
326 if (!(bgp_is_withdraw_label(label
) || label_bos(label
)))
328 EC_BGP_INVALID_LABEL_STACK
,
329 "%s rcvd UPDATE with invalid label stack - no bottom of stack",
335 int bgp_nlri_parse_label(struct peer
*peer
, struct attr
*attr
,
336 struct bgp_nlri
*packet
)
347 mpls_label_t label
= MPLS_INVALID_LABEL
;
351 lim
= pnt
+ packet
->length
;
357 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
358 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
359 PEER_CAP_ADDPATH_AF_TX_RCV
));
361 for (; pnt
< lim
; pnt
+= psize
) {
362 /* Clear prefix structure. */
363 memset(&p
, 0, sizeof(struct prefix
));
365 if (addpath_encoded
) {
367 /* When packet overflow occurs return immediately. */
368 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
369 return BGP_NLRI_PARSE_ERROR_PACKET_OVERFLOW
;
371 memcpy(&addpath_id
, pnt
, BGP_ADDPATH_ID_LEN
);
372 addpath_id
= ntohl(addpath_id
);
373 pnt
+= BGP_ADDPATH_ID_LEN
;
376 /* Fetch prefix length. */
378 p
.family
= afi2family(packet
->afi
);
379 psize
= PSIZE(prefixlen
);
381 /* sanity check against packet data */
382 if ((pnt
+ psize
) > lim
) {
385 "%s [Error] Update packet error / L-U (prefix length %d exceeds packet size %u)",
386 peer
->host
, prefixlen
, (uint
)(lim
- pnt
));
387 return BGP_NLRI_PARSE_ERROR_PACKET_OVERFLOW
;
390 /* Fill in the labels */
391 llen
= bgp_nlri_get_labels(peer
, pnt
, psize
, &label
);
392 p
.prefixlen
= prefixlen
- BSIZE(llen
);
394 /* There needs to be at least one label */
395 if (prefixlen
< 24) {
396 flog_err(EC_BGP_UPDATE_RCV
,
397 "%s [Error] Update packet error (wrong label length %d)",
398 peer
->host
, prefixlen
);
399 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
400 BGP_NOTIFY_UPDATE_INVAL_NETWORK
);
401 return BGP_NLRI_PARSE_ERROR_LABEL_LENGTH
;
404 if ((afi
== AFI_IP
&& p
.prefixlen
> 32)
405 || (afi
== AFI_IP6
&& p
.prefixlen
> 128))
406 return BGP_NLRI_PARSE_ERROR_PREFIX_LENGTH
;
408 /* Fetch prefix from NLRI packet */
409 memcpy(&p
.u
.prefix
, pnt
+ llen
, psize
- llen
);
412 if (afi
== AFI_IP
&& safi
== SAFI_LABELED_UNICAST
) {
413 if (IN_CLASSD(ntohl(p
.u
.prefix4
.s_addr
))) {
414 /* From RFC4271 Section 6.3:
416 * If a prefix in the NLRI field is semantically
418 * (e.g., an unexpected multicast IP address),
420 * be logged locally, and the prefix SHOULD be
425 "%s: IPv4 labeled-unicast NLRI is multicast address %s, ignoring",
426 peer
->host
, inet_ntoa(p
.u
.prefix4
));
432 if (afi
== AFI_IP6
&& safi
== SAFI_LABELED_UNICAST
) {
433 if (IN6_IS_ADDR_LINKLOCAL(&p
.u
.prefix6
)) {
438 "%s: IPv6 labeled-unicast NLRI is link-local address %s, ignoring",
440 inet_ntop(AF_INET6
, &p
.u
.prefix6
, buf
,
446 if (IN6_IS_ADDR_MULTICAST(&p
.u
.prefix6
)) {
451 "%s: IPv6 unicast NLRI is multicast address %s, ignoring",
453 inet_ntop(AF_INET6
, &p
.u
.prefix6
, buf
,
461 bgp_update(peer
, &p
, addpath_id
, attr
, packet
->afi
,
462 SAFI_UNICAST
, ZEBRA_ROUTE_BGP
,
463 BGP_ROUTE_NORMAL
, NULL
, &label
, 1, 0, NULL
);
465 bgp_withdraw(peer
, &p
, addpath_id
, attr
, packet
->afi
,
466 SAFI_UNICAST
, ZEBRA_ROUTE_BGP
,
467 BGP_ROUTE_NORMAL
, NULL
, &label
, 1, NULL
);
471 /* Packet length consistency check. */
475 "%s [Error] Update packet error / L-U (%td data remaining after parsing)",
476 peer
->host
, lim
- pnt
);
477 return BGP_NLRI_PARSE_ERROR_PACKET_LENGTH
;
480 return BGP_NLRI_PARSE_OK
;