pbrd/pbr_zebra.c

   1 /*
   2  * Zebra connect code.
   3  * Copyright (C) 2018 Cumulus Networks, Inc.
   4  *               Donald Sharp
   5  *
   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
   9  * later version.
  10  *
  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.
  15  *
  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
  19  */
  20 #include <zebra.h>
  21
  22 #include "thread.h"
  23 #include "command.h"
  24 #include "network.h"
  25 #include "prefix.h"
  26 #include "routemap.h"
  27 #include "table.h"
  28 #include "stream.h"
  29 #include "memory.h"
  30 #include "zclient.h"
  31 #include "filter.h"
  32 #include "plist.h"
  33 #include "log.h"
  34 #include "nexthop.h"
  35 #include "nexthop_group.h"
  36
  37 #include "pbr_nht.h"
  38 #include "pbr_map.h"
  39 #include "pbr_memory.h"
  40 #include "pbr_zebra.h"
  41 #include "pbr_debug.h"
  42 #include "pbr_vrf.h"
  43
  44 DEFINE_MTYPE_STATIC(PBRD, PBR_INTERFACE, "PBR Interface");
  45
  46 /* Zebra structure to hold current status. */
  47 struct zclient *zclient;
  48
  49 struct pbr_interface *pbr_if_new(struct interface *ifp)
  50 {
  51         struct pbr_interface *pbr_ifp;
  52
  53         assert(ifp);
  54         assert(!ifp->info);
  55
  56         pbr_ifp = XCALLOC(MTYPE_PBR_INTERFACE, sizeof(*pbr_ifp));
  57
  58         ifp->info = pbr_ifp;
  59         return pbr_ifp;
  60 }
  61
  62 void pbr_if_del(struct interface *ifp)
  63 {
  64         XFREE(MTYPE_PBR_INTERFACE, ifp->info);
  65 }
  66
  67 /* Inteface addition message from zebra. */
  68 int pbr_ifp_create(struct interface *ifp)
  69 {
  70         DEBUGD(&pbr_dbg_zebra, "%s: %s", __func__, ifp->name);
  71
  72         if (!ifp->info)
  73                 pbr_if_new(ifp);
  74
  75         pbr_nht_interface_update(ifp);
  76         /* Update nexthops tracked from a `set nexthop` command */
  77         pbr_nht_nexthop_interface_update(ifp);
  78
  79         pbr_map_policy_interface_update(ifp, true);
  80
  81         return 0;
  82 }
  83
  84 int pbr_ifp_destroy(struct interface *ifp)
  85 {
  86         DEBUGD(&pbr_dbg_zebra, "%s: %s", __func__, ifp->name);
  87
  88         pbr_map_policy_interface_update(ifp, false);
  89
  90         return 0;
  91 }
  92
  93 static int interface_address_add(ZAPI_CALLBACK_ARGS)
  94 {
  95         struct connected *c;
  96         char buf[PREFIX_STRLEN];
  97
  98         c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
  99
 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");
 103
 104         return 0;
 105 }
 106
 107 static int interface_address_delete(ZAPI_CALLBACK_ARGS)
 108 {
 109         struct connected *c;
 110
 111         c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 112
 113         if (!c)
 114                 return 0;
 115
 116         DEBUGD(&pbr_dbg_zebra, "%s: %s deleted %pFX", __func__, c->ifp->name,
 117                c->address);
 118
 119         connected_free(&c);
 120         return 0;
 121 }
 122
 123 int pbr_ifp_up(struct interface *ifp)
 124 {
 125         DEBUGD(&pbr_dbg_zebra, "%s: %s is up", __func__, ifp->name);
 126
 127         pbr_nht_nexthop_interface_update(ifp);
 128
 129         return 0;
 130 }
 131
 132 int pbr_ifp_down(struct interface *ifp)
 133 {
 134         DEBUGD(&pbr_dbg_zebra, "%s: %s is down", __func__, ifp->name);
 135
 136         pbr_nht_nexthop_interface_update(ifp);
 137
 138         return 0;
 139 }
 140
 141 static int interface_vrf_update(ZAPI_CALLBACK_ARGS)
 142 {
 143         struct interface *ifp;
 144         vrf_id_t new_vrf_id;
 145
 146         ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
 147                                               &new_vrf_id);
 148
 149         if (!ifp) {
 150                 DEBUGD(&pbr_dbg_zebra, "%s: VRF change interface not found",
 151                        __func__);
 152
 153                 return 0;
 154         }
 155
 156         DEBUGD(&pbr_dbg_zebra, "%s: %s VRF change %u -> %u", __func__,
 157                ifp->name, vrf_id, new_vrf_id);
 158
 159         if_update_to_new_vrf(ifp, new_vrf_id);
 160
 161         return 0;
 162 }
 163
 164 static int route_notify_owner(ZAPI_CALLBACK_ARGS)
 165 {
 166         struct prefix p;
 167         enum zapi_route_notify_owner note;
 168         uint32_t table_id;
 169
 170         if (!zapi_route_notify_decode(zclient->ibuf, &p, &table_id, &note,
 171                                       NULL, NULL))
 172                 return -1;
 173
 174         switch (note) {
 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);
 179                 break;
 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);
 184                 break;
 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);
 190                 break;
 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);
 196                 break;
 197         case ZAPI_ROUTE_REMOVE_FAIL:
 198                 DEBUGD(&pbr_dbg_zebra,
 199                        "%s: [%pFX] Route remove fail for table: %u", __func__,
 200                        &p, table_id);
 201                 break;
 202         }
 203
 204         return 0;
 205 }
 206
 207 static int rule_notify_owner(ZAPI_CALLBACK_ARGS)
 208 {
 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];
 214         uint64_t installed;
 215
 216         if (!zapi_rule_notify_decode(zclient->ibuf, &seqno, &priority, &unique,
 217                                      ifname, &note))
 218                 return -1;
 219
 220         pmi = NULL;
 221         pbrms = pbrms_lookup_unique(unique, ifname, &pmi);
 222         if (!pbrms) {
 223                 DEBUGD(&pbr_dbg_zebra,
 224                        "%s: Failure to lookup pbrms based upon %u", __func__,
 225                        unique);
 226                 return 0;
 227         }
 228
 229         installed = 1 << pmi->install_bit;
 230
 231         switch (note) {
 232         case ZAPI_RULE_FAIL_INSTALL:
 233                 pbrms->installed &= ~installed;
 234                 break;
 235         case ZAPI_RULE_INSTALLED:
 236                 pbrms->installed |= installed;
 237                 break;
 238         case ZAPI_RULE_FAIL_REMOVE:
 239                 /* Don't change state on rule removal failure */
 240                 break;
 241         case ZAPI_RULE_REMOVED:
 242                 pbrms->installed &= ~installed;
 243                 break;
 244         }
 245
 246         DEBUGD(&pbr_dbg_zebra, "%s: Received %s: %" PRIu64, __func__,
 247                zapi_rule_notify_owner2str(note), pbrms->installed);
 248
 249         pbr_map_final_interface_deletion(pbrms->parent, pmi);
 250
 251         return 0;
 252 }
 253
 254 static void zebra_connected(struct zclient *zclient)
 255 {
 256         DEBUGD(&pbr_dbg_zebra, "%s: Registering for fun and profit", __func__);
 257         zclient_send_reg_requests(zclient, VRF_DEFAULT);
 258 }
 259
 260 static void route_add_helper(struct zapi_route *api, struct nexthop_group nhg,
 261                              uint8_t install_afi)
 262 {
 263         struct zapi_nexthop *api_nh;
 264         struct nexthop *nhop;
 265         int i;
 266
 267         api->prefix.family = install_afi;
 268
 269         DEBUGD(&pbr_dbg_zebra, "    Encoding %pFX", &api->prefix);
 270
 271         i = 0;
 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;
 280                         break;
 281                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 282                         api_nh->gate.ipv4 = nhop->gate.ipv4;
 283                         api_nh->ifindex = nhop->ifindex;
 284                         break;
 285                 case NEXTHOP_TYPE_IFINDEX:
 286                         api_nh->ifindex = nhop->ifindex;
 287                         break;
 288                 case NEXTHOP_TYPE_IPV6:
 289                         memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6,
 290                                IPV6_MAX_BYTELEN);
 291                         break;
 292                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 293                         api_nh->ifindex = nhop->ifindex;
 294                         memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6,
 295                                IPV6_MAX_BYTELEN);
 296                         break;
 297                 case NEXTHOP_TYPE_BLACKHOLE:
 298                         api_nh->bh_type = nhop->bh_type;
 299                         break;
 300                 }
 301                 i++;
 302         }
 303         api->nexthop_num = i;
 304
 305         zclient_route_send(ZEBRA_ROUTE_ADD, zclient, api);
 306 }
 307
 308 /*
 309  * This function assumes a default route is being
 310  * installed into the appropriate tableid
 311  */
 312 void route_add(struct pbr_nexthop_group_cache *pnhgc, struct nexthop_group nhg,
 313                afi_t install_afi)
 314 {
 315         struct zapi_route api;
 316
 317         DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __func__, pnhgc->table_id);
 318
 319         memset(&api, 0, sizeof(api));
 320
 321         api.vrf_id = VRF_DEFAULT;
 322         api.type = ZEBRA_ROUTE_PBR;
 323         api.safi = SAFI_UNICAST;
 324         /*
 325          * Sending a default route
 326          */
 327         api.tableid = pnhgc->table_id;
 328         SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
 329         SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
 330         SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
 331         switch (install_afi) {
 332         case AFI_MAX:
 333                 route_add_helper(&api, nhg, AF_INET);
 334                 route_add_helper(&api, nhg, AF_INET6);
 335                 break;
 336         case AFI_IP:
 337                 route_add_helper(&api, nhg, AF_INET);
 338                 break;
 339         case AFI_IP6:
 340                 route_add_helper(&api, nhg, AF_INET6);
 341                 break;
 342         case AFI_L2VPN:
 343                 DEBUGD(&pbr_dbg_zebra,
 344                        "%s: Asked to install unsupported route type: L2VPN",
 345                        __func__);
 346                 break;
 347         case AFI_UNSPEC:
 348                 DEBUGD(&pbr_dbg_zebra,
 349                        "%s: Asked to install unspecified route type", __func__);
 350                 break;
 351         }
 352 }
 353
 354 /*
 355  * This function assumes a default route is being
 356  * removed from the appropriate tableid
 357  */
 358 void route_delete(struct pbr_nexthop_group_cache *pnhgc, afi_t afi)
 359 {
 360         struct zapi_route api;
 361
 362         DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __func__, pnhgc->table_id);
 363
 364         memset(&api, 0, sizeof(api));
 365         api.vrf_id = VRF_DEFAULT;
 366         api.type = ZEBRA_ROUTE_PBR;
 367         api.safi = SAFI_UNICAST;
 368
 369         api.tableid = pnhgc->table_id;
 370         SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
 371
 372         switch (afi) {
 373         case AFI_IP:
 374                 api.prefix.family = AF_INET;
 375                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 376                 break;
 377         case AFI_IP6:
 378                 api.prefix.family = AF_INET6;
 379                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 380                 break;
 381         case AFI_MAX:
 382                 api.prefix.family = AF_INET;
 383                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 384                 api.prefix.family = AF_INET6;
 385                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 386                 break;
 387         case AFI_L2VPN:
 388                 DEBUGD(&pbr_dbg_zebra,
 389                        "%s: Asked to delete unsupported route type: L2VPN",
 390                        __func__);
 391                 break;
 392         case AFI_UNSPEC:
 393                 DEBUGD(&pbr_dbg_zebra,
 394                        "%s: Asked to delete unspecified route type", __func__);
 395                 break;
 396         }
 397 }
 398
 399 static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
 400 {
 401         struct zapi_route nhr;
 402         uint32_t i;
 403
 404         if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
 405                 zlog_err("Failure to decode Nexthop update message");
 406                 return 0;
 407         }
 408
 409         if (DEBUG_MODE_CHECK(&pbr_dbg_zebra, DEBUG_MODE_ALL)) {
 410
 411                 DEBUGD(&pbr_dbg_zebra, "%s: Received Nexthop update: %pFX",
 412                        __func__, &nhr.prefix);
 413
 414                 DEBUGD(&pbr_dbg_zebra, "%s:   (Nexthops(%u)", __func__,
 415                        nhr.nexthop_num);
 416
 417                 for (i = 0; i < nhr.nexthop_num; i++) {
 418                         DEBUGD(&pbr_dbg_zebra,
 419                                "%s:     Type: %d: vrf: %d, ifindex: %d gate: %pI4",
 420                                __func__, nhr.nexthops[i].type,
 421                                nhr.nexthops[i].vrf_id, nhr.nexthops[i].ifindex,
 422                                &nhr.nexthops[i].gate.ipv4);
 423                 }
 424         }
 425
 426         pbr_nht_nexthop_update(&nhr);
 427         return 1;
 428 }
 429
 430 extern struct zebra_privs_t pbr_privs;
 431
 432 static zclient_handler *const pbr_handlers[] = {
 433         [ZEBRA_INTERFACE_ADDRESS_ADD] = interface_address_add,
 434         [ZEBRA_INTERFACE_ADDRESS_DELETE] = interface_address_delete,
 435         [ZEBRA_INTERFACE_VRF_UPDATE] = interface_vrf_update,
 436         [ZEBRA_ROUTE_NOTIFY_OWNER] = route_notify_owner,
 437         [ZEBRA_RULE_NOTIFY_OWNER] = rule_notify_owner,
 438         [ZEBRA_NEXTHOP_UPDATE] = pbr_zebra_nexthop_update,
 439 };
 440
 441 void pbr_zebra_init(void)
 442 {
 443         struct zclient_options opt = { .receive_notify = true };
 444
 445         zclient = zclient_new(master, &opt, pbr_handlers,
 446                               array_size(pbr_handlers));
 447
 448         zclient_init(zclient, ZEBRA_ROUTE_PBR, 0, &pbr_privs);
 449         zclient->zebra_connected = zebra_connected;
 450 }
 451
 452 void pbr_send_rnh(struct nexthop *nhop, bool reg)
 453 {
 454         uint32_t command;
 455         struct prefix p;
 456
 457         command = (reg) ?
 458                 ZEBRA_NEXTHOP_REGISTER : ZEBRA_NEXTHOP_UNREGISTER;
 459
 460         memset(&p, 0, sizeof(p));
 461         switch (nhop->type) {
 462         case NEXTHOP_TYPE_IFINDEX:
 463         case NEXTHOP_TYPE_BLACKHOLE:
 464                 return;
 465         case NEXTHOP_TYPE_IPV4:
 466         case NEXTHOP_TYPE_IPV4_IFINDEX:
 467                 p.family = AF_INET;
 468                 p.u.prefix4.s_addr = nhop->gate.ipv4.s_addr;
 469                 p.prefixlen = IPV4_MAX_BITLEN;
 470                 break;
 471         case NEXTHOP_TYPE_IPV6:
 472         case NEXTHOP_TYPE_IPV6_IFINDEX:
 473                 p.family = AF_INET6;
 474                 memcpy(&p.u.prefix6, &nhop->gate.ipv6, IPV6_MAX_BYTELEN);
 475                 p.prefixlen = IPV6_MAX_BITLEN;
 476                 if (IN6_IS_ADDR_LINKLOCAL(&nhop->gate.ipv6))
 477                         /*
 478                          * Don't bother tracking link locals, just track their
 479                          * interface state.
 480                          */
 481                         return;
 482                 break;
 483         }
 484
 485         if (zclient_send_rnh(zclient, command, &p, false, false, nhop->vrf_id)
 486             == ZCLIENT_SEND_FAILURE) {
 487                 zlog_warn("%s: Failure to send nexthop to zebra", __func__);
 488         }
 489 }
 490
 491 static void pbr_encode_pbr_map_sequence_prefix(struct stream *s,
 492                                                struct prefix *p,
 493                                                unsigned char  family)
 494 {
 495         struct prefix any;
 496
 497         if (!p) {
 498                 memset(&any, 0, sizeof(any));
 499                 any.family = family;
 500                 p = &any;
 501         }
 502
 503         stream_putc(s, p->family);
 504         stream_putc(s, p->prefixlen);
 505         stream_put(s, &p->u.prefix, prefix_blen(p));
 506 }
 507
 508 static void
 509 pbr_encode_pbr_map_sequence_vrf(struct stream *s,
 510                                 const struct pbr_map_sequence *pbrms,
 511                                 const struct interface *ifp)
 512 {
 513         struct pbr_vrf *pbr_vrf;
 514
 515         if (pbrms->vrf_unchanged)
 516                 pbr_vrf = ifp->vrf->info;
 517         else
 518                 pbr_vrf = pbr_vrf_lookup_by_name(pbrms->vrf_name);
 519
 520         if (!pbr_vrf) {
 521                 DEBUGD(&pbr_dbg_zebra, "%s: VRF not found", __func__);
 522                 return;
 523         }
 524
 525         stream_putl(s, pbr_vrf->vrf->data.l.table_id);
 526 }
 527
 528 static void pbr_encode_pbr_map_sequence(struct stream *s,
 529                                         struct pbr_map_sequence *pbrms,
 530                                         struct interface *ifp)
 531 {
 532         unsigned char family;
 533
 534         family = AF_INET;
 535         if (pbrms->family)
 536                 family = pbrms->family;
 537
 538         stream_putl(s, pbrms->seqno);
 539         stream_putl(s, pbrms->ruleno);
 540         stream_putl(s, pbrms->unique);
 541         stream_putc(s, pbrms->ip_proto); /* The ip_proto */
 542         pbr_encode_pbr_map_sequence_prefix(s, pbrms->src, family);
 543         stream_putw(s, pbrms->src_prt);
 544         pbr_encode_pbr_map_sequence_prefix(s, pbrms->dst, family);
 545         stream_putw(s, pbrms->dst_prt);
 546         stream_putc(s, pbrms->dsfield);
 547         stream_putl(s, pbrms->mark);
 548
 549         stream_putl(s, pbrms->action_queue_id);
 550
 551         stream_putw(s, pbrms->action_vlan_id);
 552         stream_putw(s, pbrms->action_vlan_flags);
 553         stream_putw(s, pbrms->action_pcp);
 554
 555         if (pbrms->vrf_unchanged || pbrms->vrf_lookup)
 556                 pbr_encode_pbr_map_sequence_vrf(s, pbrms, ifp);
 557         else if (pbrms->nhgrp_name)
 558                 stream_putl(s, pbr_nht_get_table(pbrms->nhgrp_name));
 559         else if (pbrms->nhg)
 560                 stream_putl(s, pbr_nht_get_table(pbrms->internal_nhg_name));
 561         stream_put(s, ifp->name, INTERFACE_NAMSIZ);
 562 }
 563
 564 bool pbr_send_pbr_map(struct pbr_map_sequence *pbrms,
 565                       struct pbr_map_interface *pmi, bool install, bool changed)
 566 {
 567         struct pbr_map *pbrm = pbrms->parent;
 568         struct stream *s;
 569         uint64_t is_installed = (uint64_t)1 << pmi->install_bit;
 570
 571         is_installed &= pbrms->installed;
 572
 573         DEBUGD(&pbr_dbg_zebra, "%s: for %s %d(%" PRIu64 ")", __func__,
 574                pbrm->name, install, is_installed);
 575
 576         /*
 577          * If we are installed and asked to do so again and the config
 578          * has not changed, just return.
 579          *
 580          * If we are not installed and asked
 581          * to delete just return.
 582          */
 583         if (install && is_installed && !changed)
 584                 return false;
 585
 586         if (!install && !is_installed)
 587                 return false;
 588
 589         s = zclient->obuf;
 590         stream_reset(s);
 591
 592         zclient_create_header(s,
 593                               install ? ZEBRA_RULE_ADD : ZEBRA_RULE_DELETE,
 594                               VRF_DEFAULT);
 595
 596         /*
 597          * We are sending one item at a time at the moment
 598          */
 599         stream_putl(s, 1);
 600
 601         DEBUGD(&pbr_dbg_zebra, "%s:    %s %s seq %u %d %s %u", __func__,
 602                install ? "Installing" : "Deleting", pbrm->name, pbrms->seqno,
 603                install, pmi->ifp->name, pmi->delete);
 604
 605         pbr_encode_pbr_map_sequence(s, pbrms, pmi->ifp);
 606
 607         stream_putw_at(s, 0, stream_get_endp(s));
 608
 609         zclient_send_message(zclient);
 610
 611         return true;
 612 }