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
  43 DEFINE_MTYPE_STATIC(PBRD, PBR_INTERFACE, "PBR Interface")
  44
  45 /* Zebra structure to hold current status. */
  46 struct zclient *zclient;
  47
  48 struct pbr_interface *pbr_if_new(struct interface *ifp)
  49 {
  50         struct pbr_interface *pbr_ifp;
  51
  52         zassert(ifp);
  53         zassert(!ifp->info);
  54
  55         pbr_ifp = XCALLOC(MTYPE_PBR_INTERFACE, sizeof(*pbr_ifp));
  56
  57         ifp->info = pbr_ifp;
  58         return pbr_ifp;
  59 }
  60
  61 /* Inteface addition message from zebra. */
  62 static int interface_add(ZAPI_CALLBACK_ARGS)
  63 {
  64         struct interface *ifp;
  65
  66         ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
  67
  68         if (!ifp)
  69                 return 0;
  70
  71         DEBUGD(&pbr_dbg_zebra,
  72                "%s: %s", __PRETTY_FUNCTION__, ifp->name);
  73
  74         if (!ifp->info)
  75                 pbr_if_new(ifp);
  76
  77         pbr_nht_nexthop_interface_update(ifp);
  78
  79         return 0;
  80 }
  81
  82 static int interface_delete(ZAPI_CALLBACK_ARGS)
  83 {
  84         struct interface *ifp;
  85         struct stream *s;
  86
  87         s = zclient->ibuf;
  88         /* zebra_interface_state_read () updates interface structure in iflist
  89          */
  90         ifp = zebra_interface_state_read(s, vrf_id);
  91
  92         if (ifp == NULL)
  93                 return 0;
  94
  95         DEBUGD(&pbr_dbg_zebra,
  96                "%s: %s", __PRETTY_FUNCTION__, ifp->name);
  97
  98         if_set_index(ifp, IFINDEX_INTERNAL);
  99
 100         return 0;
 101 }
 102
 103 static int interface_address_add(ZAPI_CALLBACK_ARGS)
 104 {
 105         struct connected *c;
 106         char buf[PREFIX_STRLEN];
 107
 108         c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 109
 110         DEBUGD(&pbr_dbg_zebra,
 111                "%s: %s added %s", __PRETTY_FUNCTION__,
 112                c ? c->ifp->name : "Unknown",
 113                c ? prefix2str(c->address, buf, sizeof(buf)) : "Unknown");
 114
 115         return 0;
 116 }
 117
 118 static int interface_address_delete(ZAPI_CALLBACK_ARGS)
 119 {
 120         struct connected *c;
 121         char buf[PREFIX_STRLEN];
 122
 123         c = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 124
 125         if (!c)
 126                 return 0;
 127
 128         DEBUGD(&pbr_dbg_zebra,
 129                "%s: %s deleted %s", __PRETTY_FUNCTION__, c->ifp->name,
 130                prefix2str(c->address, buf, sizeof(buf)));
 131
 132         connected_free(c);
 133         return 0;
 134 }
 135
 136 static int interface_state_up(ZAPI_CALLBACK_ARGS)
 137 {
 138         struct interface *ifp;
 139
 140         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 141
 142         DEBUGD(&pbr_dbg_zebra,
 143                "%s: %s is up", __PRETTY_FUNCTION__, ifp->name);
 144
 145         pbr_nht_nexthop_interface_update(ifp);
 146
 147         return 0;
 148 }
 149
 150 static int interface_state_down(ZAPI_CALLBACK_ARGS)
 151 {
 152         struct interface *ifp;
 153
 154         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 155
 156         DEBUGD(&pbr_dbg_zebra,
 157                "%s: %s is down", __PRETTY_FUNCTION__, ifp->name);
 158
 159         pbr_nht_nexthop_interface_update(ifp);
 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         char buf[PREFIX_STRLEN];
 170
 171         if (!zapi_route_notify_decode(zclient->ibuf, &p, &table_id, &note))
 172                 return -1;
 173
 174         prefix2str(&p, buf, sizeof(buf));
 175
 176         switch (note) {
 177         case ZAPI_ROUTE_FAIL_INSTALL:
 178                 DEBUGD(&pbr_dbg_zebra,
 179                        "%s: [%s] Route install failure for table: %u",
 180                        __PRETTY_FUNCTION__, buf, table_id);
 181                 break;
 182         case ZAPI_ROUTE_BETTER_ADMIN_WON:
 183                 DEBUGD(&pbr_dbg_zebra,
 184                        "%s: [%s] Route better admin distance won for table: %u",
 185                        __PRETTY_FUNCTION__, buf, table_id);
 186                 break;
 187         case ZAPI_ROUTE_INSTALLED:
 188                 DEBUGD(&pbr_dbg_zebra,
 189                        "%s: [%s] Route installed succeeded for table: %u",
 190                        __PRETTY_FUNCTION__, buf, table_id);
 191                 pbr_nht_route_installed_for_table(table_id);
 192                 break;
 193         case ZAPI_ROUTE_REMOVED:
 194                 DEBUGD(&pbr_dbg_zebra,
 195                        "%s: [%s] Route Removed succeeded for table: %u",
 196                        __PRETTY_FUNCTION__, buf, table_id);
 197                 pbr_nht_route_removed_for_table(table_id);
 198                 break;
 199         case ZAPI_ROUTE_REMOVE_FAIL:
 200                 DEBUGD(&pbr_dbg_zebra,
 201                        "%s: [%s] Route remove fail for table: %u",
 202                        __PRETTY_FUNCTION__, buf, table_id);
 203                 break;
 204         }
 205
 206         return 0;
 207 }
 208
 209 static int rule_notify_owner(ZAPI_CALLBACK_ARGS)
 210 {
 211         uint32_t seqno, priority, unique;
 212         enum zapi_rule_notify_owner note;
 213         struct pbr_map_sequence *pbrms;
 214         struct pbr_map_interface *pmi;
 215         ifindex_t ifi;
 216         uint64_t installed;
 217
 218         if (!zapi_rule_notify_decode(zclient->ibuf, &seqno, &priority, &unique,
 219                                      &ifi, &note))
 220                 return -1;
 221
 222         pmi = NULL;
 223         pbrms = pbrms_lookup_unique(unique, ifi, &pmi);
 224         if (!pbrms) {
 225                 DEBUGD(&pbr_dbg_zebra,
 226                        "%s: Failure to lookup pbrms based upon %u",
 227                        __PRETTY_FUNCTION__, unique);
 228                 return 0;
 229         }
 230
 231         installed = 1 << pmi->install_bit;
 232
 233         switch (note) {
 234         case ZAPI_RULE_FAIL_INSTALL:
 235                 pbrms->installed &= ~installed;
 236                 DEBUGD(&pbr_dbg_zebra,
 237                        "%s: Received RULE_FAIL_INSTALL: %" PRIu64,
 238                        __PRETTY_FUNCTION__, pbrms->installed);
 239                 break;
 240         case ZAPI_RULE_INSTALLED:
 241                 pbrms->installed |= installed;
 242                 DEBUGD(&pbr_dbg_zebra, "%s: Received RULE_INSTALLED: %" PRIu64,
 243                        __PRETTY_FUNCTION__, pbrms->installed);
 244                 break;
 245         case ZAPI_RULE_FAIL_REMOVE:
 246         case ZAPI_RULE_REMOVED:
 247                 pbrms->installed &= ~installed;
 248                 DEBUGD(&pbr_dbg_zebra, "%s: Received RULE REMOVED: %" PRIu64,
 249                        __PRETTY_FUNCTION__, pbrms->installed);
 250                 break;
 251         }
 252
 253         pbr_map_final_interface_deletion(pbrms->parent, pmi);
 254
 255         return 0;
 256 }
 257
 258 static void zebra_connected(struct zclient *zclient)
 259 {
 260         DEBUGD(&pbr_dbg_zebra, "%s: Registering for fun and profit",
 261                __PRETTY_FUNCTION__);
 262         zclient_send_reg_requests(zclient, VRF_DEFAULT);
 263 }
 264
 265 static void route_add_helper(struct zapi_route *api, struct nexthop_group nhg,
 266                              uint8_t install_afi)
 267 {
 268         struct zapi_nexthop *api_nh;
 269         char buf[PREFIX_STRLEN];
 270         struct nexthop *nhop;
 271         int i;
 272
 273         api->prefix.family = install_afi;
 274
 275         DEBUGD(&pbr_dbg_zebra, "\tEncoding %s",
 276                prefix2str(&api->prefix, buf, sizeof(buf)));
 277
 278         i = 0;
 279         for (ALL_NEXTHOPS(nhg, nhop)) {
 280                 api_nh = &api->nexthops[i];
 281                 api_nh->vrf_id = nhop->vrf_id;
 282                 api_nh->type = nhop->type;
 283                 switch (nhop->type) {
 284                 case NEXTHOP_TYPE_IPV4:
 285                         api_nh->gate.ipv4 = nhop->gate.ipv4;
 286                         break;
 287                 case NEXTHOP_TYPE_IPV4_IFINDEX:
 288                         api_nh->gate.ipv4 = nhop->gate.ipv4;
 289                         api_nh->ifindex = nhop->ifindex;
 290                         break;
 291                 case NEXTHOP_TYPE_IFINDEX:
 292                         api_nh->ifindex = nhop->ifindex;
 293                         break;
 294                 case NEXTHOP_TYPE_IPV6:
 295                         memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6, 16);
 296                         break;
 297                 case NEXTHOP_TYPE_IPV6_IFINDEX:
 298                         api_nh->ifindex = nhop->ifindex;
 299                         memcpy(&api_nh->gate.ipv6, &nhop->gate.ipv6, 16);
 300                         break;
 301                 case NEXTHOP_TYPE_BLACKHOLE:
 302                         api_nh->bh_type = nhop->bh_type;
 303                         break;
 304                 }
 305                 i++;
 306         }
 307         api->nexthop_num = i;
 308
 309         zclient_route_send(ZEBRA_ROUTE_ADD, zclient, api);
 310 }
 311
 312 /*
 313  * This function assumes a default route is being
 314  * installed into the appropriate tableid
 315  */
 316 void route_add(struct pbr_nexthop_group_cache *pnhgc, struct nexthop_group nhg,
 317                afi_t install_afi)
 318 {
 319         struct zapi_route api;
 320
 321         DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __PRETTY_FUNCTION__,
 322                pnhgc->table_id);
 323
 324         memset(&api, 0, sizeof(api));
 325
 326         api.vrf_id = VRF_DEFAULT;
 327         api.type = ZEBRA_ROUTE_PBR;
 328         api.safi = SAFI_UNICAST;
 329         /*
 330          * Sending a default route
 331          */
 332         api.tableid = pnhgc->table_id;
 333         SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
 334         SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
 335         SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
 336         switch (install_afi) {
 337         case AFI_MAX:
 338                 route_add_helper(&api, nhg, AF_INET);
 339                 route_add_helper(&api, nhg, AF_INET6);
 340                 break;
 341         case AFI_IP:
 342                 route_add_helper(&api, nhg, AF_INET);
 343                 break;
 344         case AFI_IP6:
 345                 route_add_helper(&api, nhg, AF_INET6);
 346                 break;
 347         case AFI_L2VPN:
 348                 DEBUGD(&pbr_dbg_zebra,
 349                        "%s: Asked to install unsupported route type: L2VPN",
 350                        __PRETTY_FUNCTION__);
 351                 break;
 352         }
 353 }
 354
 355 /*
 356  * This function assumes a default route is being
 357  * removed from the appropriate tableid
 358  */
 359 void route_delete(struct pbr_nexthop_group_cache *pnhgc, afi_t afi)
 360 {
 361         struct zapi_route api;
 362
 363         DEBUGD(&pbr_dbg_zebra, "%s for Table: %d", __PRETTY_FUNCTION__,
 364                pnhgc->table_id);
 365
 366         memset(&api, 0, sizeof(api));
 367         api.vrf_id = VRF_DEFAULT;
 368         api.type = ZEBRA_ROUTE_PBR;
 369         api.safi = SAFI_UNICAST;
 370
 371         api.tableid = pnhgc->table_id;
 372         SET_FLAG(api.message, ZAPI_MESSAGE_TABLEID);
 373
 374         switch (afi) {
 375         case AFI_IP:
 376                 api.prefix.family = AF_INET;
 377                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 378                 break;
 379         case AFI_IP6:
 380                 api.prefix.family = AF_INET6;
 381                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 382                 break;
 383         case AFI_MAX:
 384                 api.prefix.family = AF_INET;
 385                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 386                 api.prefix.family = AF_INET6;
 387                 zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 388                 break;
 389         case AFI_L2VPN:
 390                 DEBUGD(&pbr_dbg_zebra,
 391                        "%s: Asked to delete unsupported route type: L2VPN",
 392                        __PRETTY_FUNCTION__);
 393                 break;
 394         }
 395 }
 396
 397 static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
 398 {
 399         struct zapi_route nhr;
 400         char buf[PREFIX2STR_BUFFER];
 401         uint32_t i;
 402
 403         if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
 404                 zlog_warn("Failure to decode Nexthop update message");
 405                 return 0;
 406         }
 407
 408         if (DEBUG_MODE_CHECK(&pbr_dbg_zebra, DEBUG_MODE_ALL)) {
 409
 410                 DEBUGD(&pbr_dbg_zebra, "%s: Received Nexthop update: %s",
 411                        __PRETTY_FUNCTION__,
 412                        prefix2str(&nhr.prefix, buf, sizeof(buf)));
 413
 414                 DEBUGD(&pbr_dbg_zebra, "%s: (\tNexthops(%u)",
 415                        __PRETTY_FUNCTION__, nhr.nexthop_num);
 416
 417                 for (i = 0; i < nhr.nexthop_num; i++) {
 418                         DEBUGD(&pbr_dbg_zebra,
 419                                "%s: \tType: %d: vrf: %d, ifindex: %d gate: %s",
 420                                __PRETTY_FUNCTION__, nhr.nexthops[i].type,
 421                                nhr.nexthops[i].vrf_id, nhr.nexthops[i].ifindex,
 422                                inet_ntoa(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 void pbr_zebra_init(void)
 433 {
 434         struct zclient_options opt = { .receive_notify = true };
 435
 436         zclient = zclient_new(master, &opt);
 437
 438         zclient_init(zclient, ZEBRA_ROUTE_PBR, 0, &pbr_privs);
 439         zclient->zebra_connected = zebra_connected;
 440         zclient->interface_add = interface_add;
 441         zclient->interface_delete = interface_delete;
 442         zclient->interface_up = interface_state_up;
 443         zclient->interface_down = interface_state_down;
 444         zclient->interface_address_add = interface_address_add;
 445         zclient->interface_address_delete = interface_address_delete;
 446         zclient->route_notify_owner = route_notify_owner;
 447         zclient->rule_notify_owner = rule_notify_owner;
 448         zclient->nexthop_update = pbr_zebra_nexthop_update;
 449 }
 450
 451 void pbr_send_rnh(struct nexthop *nhop, bool reg)
 452 {
 453         uint32_t command;
 454         struct prefix p;
 455
 456         command = (reg) ?
 457                 ZEBRA_NEXTHOP_REGISTER : ZEBRA_NEXTHOP_UNREGISTER;
 458
 459         memset(&p, 0, sizeof(p));
 460         switch (nhop->type) {
 461         case NEXTHOP_TYPE_IFINDEX:
 462         case NEXTHOP_TYPE_BLACKHOLE:
 463                 return;
 464         case NEXTHOP_TYPE_IPV4:
 465         case NEXTHOP_TYPE_IPV4_IFINDEX:
 466                 p.family = AF_INET;
 467                 p.u.prefix4.s_addr = nhop->gate.ipv4.s_addr;
 468                 p.prefixlen = 32;
 469                 break;
 470         case NEXTHOP_TYPE_IPV6:
 471         case NEXTHOP_TYPE_IPV6_IFINDEX:
 472                 p.family = AF_INET6;
 473                 memcpy(&p.u.prefix6, &nhop->gate.ipv6, 16);
 474                 p.prefixlen = 128;
 475                 break;
 476         }
 477
 478         if (zclient_send_rnh(zclient, command, &p,
 479                              false, nhop->vrf_id) < 0) {
 480                 zlog_warn("%s: Failure to send nexthop to zebra",
 481                           __PRETTY_FUNCTION__);
 482         }
 483 }
 484
 485 static void pbr_encode_pbr_map_sequence_prefix(struct stream *s,
 486                                                struct prefix *p,
 487                                                unsigned char  family)
 488 {
 489         struct prefix any;
 490
 491         if (!p) {
 492                 memset(&any, 0, sizeof(any));
 493                 any.family = family;
 494                 p = &any;
 495         }
 496
 497         stream_putc(s, p->family);
 498         stream_putc(s, p->prefixlen);
 499         stream_put(s, &p->u.prefix, prefix_blen(p));
 500 }
 501
 502 static void pbr_encode_pbr_map_sequence(struct stream *s,
 503                                         struct pbr_map_sequence *pbrms,
 504                                         struct interface *ifp)
 505 {
 506         unsigned char family;
 507
 508         family = AF_INET;
 509         if (pbrms->family)
 510                 family = pbrms->family;
 511
 512         stream_putl(s, pbrms->seqno);
 513         stream_putl(s, pbrms->ruleno);
 514         stream_putl(s, pbrms->unique);
 515         pbr_encode_pbr_map_sequence_prefix(s, pbrms->src, family);
 516         stream_putw(s, 0);  /* src port */
 517         pbr_encode_pbr_map_sequence_prefix(s, pbrms->dst, family);
 518         stream_putw(s, 0);  /* dst port */
 519         stream_putl(s, 0);  /* fwmark */
 520         if (pbrms->nhgrp_name)
 521                 stream_putl(s, pbr_nht_get_table(pbrms->nhgrp_name));
 522         else if (pbrms->nhg)
 523                 stream_putl(s, pbr_nht_get_table(pbrms->internal_nhg_name));
 524         stream_putl(s, ifp->ifindex);
 525 }
 526
 527 void pbr_send_pbr_map(struct pbr_map_sequence *pbrms,
 528                       struct pbr_map_interface *pmi, bool install)
 529 {
 530         struct pbr_map *pbrm = pbrms->parent;
 531         struct stream *s;
 532         uint64_t is_installed = (uint64_t)1 << pmi->install_bit;
 533
 534         is_installed &= pbrms->installed;
 535
 536         DEBUGD(&pbr_dbg_zebra, "%s: for %s %d(%" PRIu64 ")",
 537                __PRETTY_FUNCTION__, pbrm->name, install, is_installed);
 538
 539         /*
 540          * If we are installed and asked to do so again
 541          * just return.  If we are not installed and asked
 542          * and asked to delete just return;
 543          */
 544         if (install && is_installed)
 545                 return;
 546
 547         if (!install && !is_installed)
 548                 return;
 549
 550         s = zclient->obuf;
 551         stream_reset(s);
 552
 553         zclient_create_header(s,
 554                               install ? ZEBRA_RULE_ADD : ZEBRA_RULE_DELETE,
 555                               VRF_DEFAULT);
 556
 557         /*
 558          * We are sending one item at a time at the moment
 559          */
 560         stream_putl(s, 1);
 561
 562         DEBUGD(&pbr_dbg_zebra, "%s: \t%s %s %d %s %u",
 563                __PRETTY_FUNCTION__, install ? "Installing" : "Deleting",
 564                pbrm->name, install, pmi->ifp->name, pmi->delete);
 565
 566         pbr_encode_pbr_map_sequence(s, pbrms, pmi->ifp);
 567
 568         stream_putw_at(s, 0, stream_get_endp(s));
 569
 570         zclient_send_message(zclient);
 571 }