3 * Copyright (C) 2018 Cumulus Networks, Inc.
6 * FRR 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 * FRR 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
35 #include "nexthop_group.h"
39 #include "pbr_memory.h"
40 #include "pbr_zebra.h"
41 #include "pbr_debug.h"
44 DEFINE_MTYPE_STATIC(PBRD
, PBR_INTERFACE
, "PBR Interface");
46 /* Zebra structure to hold current status. */
47 struct zclient
*zclient
;
49 struct pbr_interface
*pbr_if_new(struct interface
*ifp
)
51 struct pbr_interface
*pbr_ifp
;
56 pbr_ifp
= XCALLOC(MTYPE_PBR_INTERFACE
, sizeof(*pbr_ifp
));
62 void pbr_if_del(struct interface
*ifp
)
64 XFREE(MTYPE_PBR_INTERFACE
, ifp
->info
);
67 /* Inteface addition message from zebra. */
68 int pbr_ifp_create(struct interface
*ifp
)
70 DEBUGD(&pbr_dbg_zebra
, "%s: %s", __func__
, ifp
->name
);
75 pbr_nht_interface_update(ifp
);
76 /* Update nexthops tracked from a `set nexthop` command */
77 pbr_nht_nexthop_interface_update(ifp
);
79 pbr_map_policy_interface_update(ifp
, true);
84 int pbr_ifp_destroy(struct interface
*ifp
)
86 DEBUGD(&pbr_dbg_zebra
, "%s: %s", __func__
, ifp
->name
);
88 pbr_map_policy_interface_update(ifp
, false);
93 static int interface_address_add(ZAPI_CALLBACK_ARGS
)
96 char buf
[PREFIX_STRLEN
];
98 c
= zebra_interface_address_read(cmd
, zclient
->ibuf
, vrf_id
);
100 DEBUGD(&pbr_dbg_zebra
, "%s: %s added %s", __func__
,
101 c
? c
->ifp
->name
: "Unknown",
102 c
? prefix2str(c
->address
, buf
, sizeof(buf
)) : "Unknown");
107 static int interface_address_delete(ZAPI_CALLBACK_ARGS
)
111 c
= zebra_interface_address_read(cmd
, zclient
->ibuf
, vrf_id
);
116 DEBUGD(&pbr_dbg_zebra
, "%s: %s deleted %pFX", __func__
, c
->ifp
->name
,
123 int pbr_ifp_up(struct interface
*ifp
)
125 DEBUGD(&pbr_dbg_zebra
, "%s: %s is up", __func__
, ifp
->name
);
127 pbr_nht_nexthop_interface_update(ifp
);
132 int pbr_ifp_down(struct interface
*ifp
)
134 DEBUGD(&pbr_dbg_zebra
, "%s: %s is down", __func__
, ifp
->name
);
136 pbr_nht_nexthop_interface_update(ifp
);
141 static int interface_vrf_update(ZAPI_CALLBACK_ARGS
)
143 struct interface
*ifp
;
146 ifp
= zebra_interface_vrf_update_read(zclient
->ibuf
, vrf_id
,
150 DEBUGD(&pbr_dbg_zebra
, "%s: VRF change interface not found",
156 DEBUGD(&pbr_dbg_zebra
, "%s: %s VRF change %u -> %u", __func__
,
157 ifp
->name
, vrf_id
, new_vrf_id
);
159 if_update_to_new_vrf(ifp
, new_vrf_id
);
164 static int route_notify_owner(ZAPI_CALLBACK_ARGS
)
167 enum zapi_route_notify_owner note
;
170 if (!zapi_route_notify_decode(zclient
->ibuf
, &p
, &table_id
, ¬e
,
175 case ZAPI_ROUTE_FAIL_INSTALL
:
176 DEBUGD(&pbr_dbg_zebra
,
177 "%s: [%pFX] Route install failure for table: %u",
178 __func__
, &p
, table_id
);
180 case ZAPI_ROUTE_BETTER_ADMIN_WON
:
181 DEBUGD(&pbr_dbg_zebra
,
182 "%s: [%pFX] Route better admin distance won for table: %u",
183 __func__
, &p
, table_id
);
185 case ZAPI_ROUTE_INSTALLED
:
186 DEBUGD(&pbr_dbg_zebra
,
187 "%s: [%pFX] Route installed succeeded for table: %u",
188 __func__
, &p
, table_id
);
189 pbr_nht_route_installed_for_table(table_id
);
191 case ZAPI_ROUTE_REMOVED
:
192 DEBUGD(&pbr_dbg_zebra
,
193 "%s: [%pFX] Route Removed succeeded for table: %u",
194 __func__
, &p
, table_id
);
195 pbr_nht_route_removed_for_table(table_id
);
197 case ZAPI_ROUTE_REMOVE_FAIL
:
198 DEBUGD(&pbr_dbg_zebra
,
199 "%s: [%pFX] Route remove fail for table: %u", __func__
,
207 static int rule_notify_owner(ZAPI_CALLBACK_ARGS
)
209 uint32_t seqno
, priority
, unique
;
210 enum zapi_rule_notify_owner note
;
211 struct pbr_map_sequence
*pbrms
;
212 struct pbr_map_interface
*pmi
;
213 char ifname
[INTERFACE_NAMSIZ
+ 1];
216 if (!zapi_rule_notify_decode(zclient
->ibuf
, &seqno
, &priority
, &unique
,
221 pbrms
= pbrms_lookup_unique(unique
, ifname
, &pmi
);
223 DEBUGD(&pbr_dbg_zebra
,
224 "%s: Failure to lookup pbrms based upon %u", __func__
,
229 installed
= 1 << pmi
->install_bit
;
232 case ZAPI_RULE_FAIL_INSTALL
:
233 pbrms
->installed
&= ~installed
;
235 case ZAPI_RULE_INSTALLED
:
236 pbrms
->installed
|= installed
;
238 case ZAPI_RULE_FAIL_REMOVE
:
239 /* Don't change state on rule removal failure */
241 case ZAPI_RULE_REMOVED
:
242 pbrms
->installed
&= ~installed
;
246 DEBUGD(&pbr_dbg_zebra
, "%s: Received %s: %" PRIu64
, __func__
,
247 zapi_rule_notify_owner2str(note
), pbrms
->installed
);
249 pbr_map_final_interface_deletion(pbrms
->parent
, pmi
);
254 static void zebra_connected(struct zclient
*zclient
)
256 DEBUGD(&pbr_dbg_zebra
, "%s: Registering for fun and profit", __func__
);
257 zclient_send_reg_requests(zclient
, VRF_DEFAULT
);
260 static void route_add_helper(struct zapi_route
*api
, struct nexthop_group nhg
,
263 struct zapi_nexthop
*api_nh
;
264 struct nexthop
*nhop
;
267 api
->prefix
.family
= install_afi
;
269 DEBUGD(&pbr_dbg_zebra
, " Encoding %pFX", &api
->prefix
);
272 for (ALL_NEXTHOPS(nhg
, nhop
)) {
273 api_nh
= &api
->nexthops
[i
];
274 api_nh
->vrf_id
= nhop
->vrf_id
;
275 api_nh
->type
= nhop
->type
;
276 api_nh
->weight
= nhop
->weight
;
277 switch (nhop
->type
) {
278 case NEXTHOP_TYPE_IPV4
:
279 api_nh
->gate
.ipv4
= nhop
->gate
.ipv4
;
281 case NEXTHOP_TYPE_IPV4_IFINDEX
:
282 api_nh
->gate
.ipv4
= nhop
->gate
.ipv4
;
283 api_nh
->ifindex
= nhop
->ifindex
;
285 case NEXTHOP_TYPE_IFINDEX
:
286 api_nh
->ifindex
= nhop
->ifindex
;
288 case NEXTHOP_TYPE_IPV6
:
289 memcpy(&api_nh
->gate
.ipv6
, &nhop
->gate
.ipv6
, 16);
291 case NEXTHOP_TYPE_IPV6_IFINDEX
:
292 api_nh
->ifindex
= nhop
->ifindex
;
293 memcpy(&api_nh
->gate
.ipv6
, &nhop
->gate
.ipv6
, 16);
295 case NEXTHOP_TYPE_BLACKHOLE
:
296 api_nh
->bh_type
= nhop
->bh_type
;
301 api
->nexthop_num
= i
;
303 zclient_route_send(ZEBRA_ROUTE_ADD
, zclient
, api
);
307 * This function assumes a default route is being
308 * installed into the appropriate tableid
310 void route_add(struct pbr_nexthop_group_cache
*pnhgc
, struct nexthop_group nhg
,
313 struct zapi_route api
;
315 DEBUGD(&pbr_dbg_zebra
, "%s for Table: %d", __func__
, pnhgc
->table_id
);
317 memset(&api
, 0, sizeof(api
));
319 api
.vrf_id
= VRF_DEFAULT
;
320 api
.type
= ZEBRA_ROUTE_PBR
;
321 api
.safi
= SAFI_UNICAST
;
323 * Sending a default route
325 api
.tableid
= pnhgc
->table_id
;
326 SET_FLAG(api
.flags
, ZEBRA_FLAG_ALLOW_RECURSION
);
327 SET_FLAG(api
.message
, ZAPI_MESSAGE_TABLEID
);
328 SET_FLAG(api
.message
, ZAPI_MESSAGE_NEXTHOP
);
329 switch (install_afi
) {
331 route_add_helper(&api
, nhg
, AF_INET
);
332 route_add_helper(&api
, nhg
, AF_INET6
);
335 route_add_helper(&api
, nhg
, AF_INET
);
338 route_add_helper(&api
, nhg
, AF_INET6
);
341 DEBUGD(&pbr_dbg_zebra
,
342 "%s: Asked to install unsupported route type: L2VPN",
346 DEBUGD(&pbr_dbg_zebra
,
347 "%s: Asked to install unspecified route type", __func__
);
353 * This function assumes a default route is being
354 * removed from the appropriate tableid
356 void route_delete(struct pbr_nexthop_group_cache
*pnhgc
, afi_t afi
)
358 struct zapi_route api
;
360 DEBUGD(&pbr_dbg_zebra
, "%s for Table: %d", __func__
, pnhgc
->table_id
);
362 memset(&api
, 0, sizeof(api
));
363 api
.vrf_id
= VRF_DEFAULT
;
364 api
.type
= ZEBRA_ROUTE_PBR
;
365 api
.safi
= SAFI_UNICAST
;
367 api
.tableid
= pnhgc
->table_id
;
368 SET_FLAG(api
.message
, ZAPI_MESSAGE_TABLEID
);
372 api
.prefix
.family
= AF_INET
;
373 zclient_route_send(ZEBRA_ROUTE_DELETE
, zclient
, &api
);
376 api
.prefix
.family
= AF_INET6
;
377 zclient_route_send(ZEBRA_ROUTE_DELETE
, zclient
, &api
);
380 api
.prefix
.family
= AF_INET
;
381 zclient_route_send(ZEBRA_ROUTE_DELETE
, zclient
, &api
);
382 api
.prefix
.family
= AF_INET6
;
383 zclient_route_send(ZEBRA_ROUTE_DELETE
, zclient
, &api
);
386 DEBUGD(&pbr_dbg_zebra
,
387 "%s: Asked to delete unsupported route type: L2VPN",
391 DEBUGD(&pbr_dbg_zebra
,
392 "%s: Asked to delete unspecified route type", __func__
);
397 static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS
)
399 struct zapi_route nhr
;
402 if (!zapi_nexthop_update_decode(zclient
->ibuf
, &nhr
)) {
403 zlog_err("Failure to decode Nexthop update message");
407 if (DEBUG_MODE_CHECK(&pbr_dbg_zebra
, DEBUG_MODE_ALL
)) {
409 DEBUGD(&pbr_dbg_zebra
, "%s: Received Nexthop update: %pFX",
410 __func__
, &nhr
.prefix
);
412 DEBUGD(&pbr_dbg_zebra
, "%s: (Nexthops(%u)", __func__
,
415 for (i
= 0; i
< nhr
.nexthop_num
; i
++) {
416 DEBUGD(&pbr_dbg_zebra
,
417 "%s: Type: %d: vrf: %d, ifindex: %d gate: %pI4",
418 __func__
, nhr
.nexthops
[i
].type
,
419 nhr
.nexthops
[i
].vrf_id
, nhr
.nexthops
[i
].ifindex
,
420 &nhr
.nexthops
[i
].gate
.ipv4
);
424 pbr_nht_nexthop_update(&nhr
);
428 extern struct zebra_privs_t pbr_privs
;
430 void pbr_zebra_init(void)
432 struct zclient_options opt
= { .receive_notify
= true };
434 zclient
= zclient_new(master
, &opt
);
436 zclient_init(zclient
, ZEBRA_ROUTE_PBR
, 0, &pbr_privs
);
437 zclient
->zebra_connected
= zebra_connected
;
438 zclient
->interface_address_add
= interface_address_add
;
439 zclient
->interface_address_delete
= interface_address_delete
;
440 zclient
->interface_vrf_update
= interface_vrf_update
;
441 zclient
->route_notify_owner
= route_notify_owner
;
442 zclient
->rule_notify_owner
= rule_notify_owner
;
443 zclient
->nexthop_update
= pbr_zebra_nexthop_update
;
446 void pbr_send_rnh(struct nexthop
*nhop
, bool reg
)
452 ZEBRA_NEXTHOP_REGISTER
: ZEBRA_NEXTHOP_UNREGISTER
;
454 memset(&p
, 0, sizeof(p
));
455 switch (nhop
->type
) {
456 case NEXTHOP_TYPE_IFINDEX
:
457 case NEXTHOP_TYPE_BLACKHOLE
:
459 case NEXTHOP_TYPE_IPV4
:
460 case NEXTHOP_TYPE_IPV4_IFINDEX
:
462 p
.u
.prefix4
.s_addr
= nhop
->gate
.ipv4
.s_addr
;
465 case NEXTHOP_TYPE_IPV6
:
466 case NEXTHOP_TYPE_IPV6_IFINDEX
:
468 memcpy(&p
.u
.prefix6
, &nhop
->gate
.ipv6
, 16);
470 if (IN6_IS_ADDR_LINKLOCAL(&nhop
->gate
.ipv6
))
472 * Don't bother tracking link locals, just track their
479 if (zclient_send_rnh(zclient
, command
, &p
, false, nhop
->vrf_id
)
480 == ZCLIENT_SEND_FAILURE
) {
481 zlog_warn("%s: Failure to send nexthop to zebra", __func__
);
485 static void pbr_encode_pbr_map_sequence_prefix(struct stream
*s
,
487 unsigned char family
)
492 memset(&any
, 0, sizeof(any
));
497 stream_putc(s
, p
->family
);
498 stream_putc(s
, p
->prefixlen
);
499 stream_put(s
, &p
->u
.prefix
, prefix_blen(p
));
503 pbr_encode_pbr_map_sequence_vrf(struct stream
*s
,
504 const struct pbr_map_sequence
*pbrms
,
505 const struct interface
*ifp
)
507 struct pbr_vrf
*pbr_vrf
;
509 if (pbrms
->vrf_unchanged
)
510 pbr_vrf
= pbr_vrf_lookup_by_id(ifp
->vrf_id
);
512 pbr_vrf
= pbr_vrf_lookup_by_name(pbrms
->vrf_name
);
515 DEBUGD(&pbr_dbg_zebra
, "%s: VRF not found", __func__
);
519 stream_putl(s
, pbr_vrf
->vrf
->data
.l
.table_id
);
522 static void pbr_encode_pbr_map_sequence(struct stream
*s
,
523 struct pbr_map_sequence
*pbrms
,
524 struct interface
*ifp
)
526 unsigned char family
;
530 family
= pbrms
->family
;
532 stream_putl(s
, pbrms
->seqno
);
533 stream_putl(s
, pbrms
->ruleno
);
534 stream_putl(s
, pbrms
->unique
);
535 pbr_encode_pbr_map_sequence_prefix(s
, pbrms
->src
, family
);
536 stream_putw(s
, 0); /* src port */
537 pbr_encode_pbr_map_sequence_prefix(s
, pbrms
->dst
, family
);
538 stream_putw(s
, 0); /* dst port */
539 stream_putc(s
, pbrms
->dsfield
);
540 stream_putl(s
, pbrms
->mark
);
542 if (pbrms
->vrf_unchanged
|| pbrms
->vrf_lookup
)
543 pbr_encode_pbr_map_sequence_vrf(s
, pbrms
, ifp
);
544 else if (pbrms
->nhgrp_name
)
545 stream_putl(s
, pbr_nht_get_table(pbrms
->nhgrp_name
));
547 stream_putl(s
, pbr_nht_get_table(pbrms
->internal_nhg_name
));
548 stream_put(s
, ifp
->name
, INTERFACE_NAMSIZ
);
551 bool pbr_send_pbr_map(struct pbr_map_sequence
*pbrms
,
552 struct pbr_map_interface
*pmi
, bool install
, bool changed
)
554 struct pbr_map
*pbrm
= pbrms
->parent
;
556 uint64_t is_installed
= (uint64_t)1 << pmi
->install_bit
;
558 is_installed
&= pbrms
->installed
;
560 DEBUGD(&pbr_dbg_zebra
, "%s: for %s %d(%" PRIu64
")", __func__
,
561 pbrm
->name
, install
, is_installed
);
564 * If we are installed and asked to do so again and the config
565 * has not changed, just return.
567 * If we are not installed and asked
568 * to delete just return.
570 if (install
&& is_installed
&& !changed
)
573 if (!install
&& !is_installed
)
579 zclient_create_header(s
,
580 install
? ZEBRA_RULE_ADD
: ZEBRA_RULE_DELETE
,
584 * We are sending one item at a time at the moment
588 DEBUGD(&pbr_dbg_zebra
, "%s: %s %s seq %u %d %s %u", __func__
,
589 install
? "Installing" : "Deleting", pbrm
->name
, pbrms
->seqno
,
590 install
, pmi
->ifp
->name
, pmi
->delete);
592 pbr_encode_pbr_map_sequence(s
, pbrms
, pmi
->ifp
);
594 stream_putw_at(s
, 0, stream_get_endp(s
));
596 zclient_send_message(zclient
);