ldpd/ldp_zebra.c

   1 /*
   2  * Copyright (C) 2016 by Open Source Routing.
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   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
   9  * later version.
  10  *
  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.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "prefix.h"
  25 #include "stream.h"
  26 #include "memory.h"
  27 #include "zclient.h"
  28 #include "command.h"
  29 #include "network.h"
  30 #include "linklist.h"
  31 #include "mpls.h"
  32
  33 #include "ldpd.h"
  34 #include "ldpe.h"
  35 #include "lde.h"
  36 #include "log.h"
  37 #include "ldp_debug.h"
  38
  39 static void      ifp2kif(struct interface *, struct kif *);
  40 static void      ifc2kaddr(struct interface *, struct connected *,
  41                     struct kaddr *);
  42 static int       zebra_send_mpls_labels(int, struct kroute *);
  43 static int       ldp_router_id_update(int, struct zclient *, zebra_size_t,
  44                     vrf_id_t);
  45 static int       ldp_interface_add(int, struct zclient *, zebra_size_t,
  46                     vrf_id_t);
  47 static int       ldp_interface_delete(int, struct zclient *, zebra_size_t,
  48                     vrf_id_t);
  49 static int       ldp_interface_status_change(int command, struct zclient *,
  50                     zebra_size_t, vrf_id_t);
  51 static int       ldp_interface_address_add(int, struct zclient *, zebra_size_t,
  52                     vrf_id_t);
  53 static int       ldp_interface_address_delete(int, struct zclient *,
  54                     zebra_size_t, vrf_id_t);
  55 static int       ldp_zebra_read_route(int, struct zclient *, zebra_size_t,
  56                     vrf_id_t);
  57 static int       ldp_zebra_read_pw_status_update(int, struct zclient *,
  58                     zebra_size_t, vrf_id_t);
  59 static void      ldp_zebra_connected(struct zclient *);
  60
  61 static struct zclient   *zclient;
  62
  63 static void
  64 ifp2kif(struct interface *ifp, struct kif *kif)
  65 {
  66         memset(kif, 0, sizeof(*kif));
  67         strlcpy(kif->ifname, ifp->name, sizeof(kif->ifname));
  68         kif->ifindex = ifp->ifindex;
  69         kif->operative = if_is_operative(ifp);
  70         if (ifp->ll_type == ZEBRA_LLT_ETHER)
  71                 memcpy(kif->mac, ifp->hw_addr, ETHER_ADDR_LEN);
  72 }
  73
  74 static void
  75 ifc2kaddr(struct interface *ifp, struct connected *ifc, struct kaddr *ka)
  76 {
  77         memset(ka, 0, sizeof(*ka));
  78         strlcpy(ka->ifname, ifp->name, sizeof(ka->ifname));
  79         ka->ifindex = ifp->ifindex;
  80         ka->af = ifc->address->family;
  81         ka->prefixlen = ifc->address->prefixlen;
  82
  83         switch (ka->af) {
  84         case AF_INET:
  85                 ka->addr.v4 = ifc->address->u.prefix4;
  86                 if (ifc->destination)
  87                         ka->dstbrd.v4 = ifc->destination->u.prefix4;
  88                 break;
  89         case AF_INET6:
  90                 ka->addr.v6 = ifc->address->u.prefix6;
  91                 if (ifc->destination)
  92                         ka->dstbrd.v6 = ifc->destination->u.prefix6;
  93                 break;
  94         default:
  95                 break;
  96         }
  97 }
  98
  99 void
 100 pw2zpw(struct l2vpn_pw *pw, struct zapi_pw *zpw)
 101 {
 102         memset(zpw, 0, sizeof(*zpw));
 103         strlcpy(zpw->ifname, pw->ifname, sizeof(zpw->ifname));
 104         zpw->ifindex = pw->ifindex;
 105         zpw->type = pw->l2vpn->pw_type;
 106         zpw->af = pw->af;
 107         zpw->nexthop.ipv6 = pw->addr.v6;
 108         zpw->local_label = NO_LABEL;
 109         zpw->remote_label = NO_LABEL;
 110         if (pw->flags & F_PW_CWORD)
 111                 zpw->flags = F_PSEUDOWIRE_CWORD;
 112         zpw->data.ldp.lsr_id = pw->lsr_id;
 113         zpw->data.ldp.pwid = pw->pwid;
 114         strlcpy(zpw->data.ldp.vpn_name, pw->l2vpn->name,
 115             sizeof(zpw->data.ldp.vpn_name));
 116 }
 117
 118 static int
 119 zebra_send_mpls_labels(int cmd, struct kroute *kr)
 120 {
 121         struct stream           *s;
 122
 123         if (kr->local_label < MPLS_LABEL_RESERVED_MAX ||
 124             kr->remote_label == NO_LABEL)
 125                 return (0);
 126
 127         debug_zebra_out("prefix %s/%u nexthop %s ifindex %u labels %s/%s (%s)",
 128             log_addr(kr->af, &kr->prefix), kr->prefixlen,
 129             log_addr(kr->af, &kr->nexthop), kr->ifindex,
 130             log_label(kr->local_label), log_label(kr->remote_label),
 131             (cmd == ZEBRA_MPLS_LABELS_ADD) ? "add" : "delete");
 132
 133         /* Reset stream. */
 134         s = zclient->obuf;
 135         stream_reset(s);
 136
 137         zclient_create_header(s, cmd, VRF_DEFAULT);
 138         stream_putc(s, ZEBRA_LSP_LDP);
 139         stream_putl(s, kr->af);
 140         switch (kr->af) {
 141         case AF_INET:
 142                 stream_put_in_addr(s, &kr->prefix.v4);
 143                 stream_putc(s, kr->prefixlen);
 144                 stream_put_in_addr(s, &kr->nexthop.v4);
 145                 break;
 146         case AF_INET6:
 147                 stream_write(s, (u_char *)&kr->prefix.v6, 16);
 148                 stream_putc(s, kr->prefixlen);
 149                 stream_write(s, (u_char *)&kr->nexthop.v6, 16);
 150                 break;
 151         default:
 152                 fatalx("kr_change: unknown af");
 153         }
 154         stream_putl(s, kr->ifindex);
 155         stream_putc(s, kr->priority);
 156         stream_putl(s, kr->local_label);
 157         stream_putl(s, kr->remote_label);
 158
 159         /* Put length at the first point of the stream. */
 160         stream_putw_at(s, 0, stream_get_endp(s));
 161
 162         return (zclient_send_message(zclient));
 163 }
 164
 165 int
 166 kr_change(struct kroute *kr)
 167 {
 168         return (zebra_send_mpls_labels(ZEBRA_MPLS_LABELS_ADD, kr));
 169 }
 170
 171 int
 172 kr_delete(struct kroute *kr)
 173 {
 174         return (zebra_send_mpls_labels(ZEBRA_MPLS_LABELS_DELETE, kr));
 175 }
 176
 177 int
 178 kmpw_add(struct zapi_pw *zpw)
 179 {
 180         debug_zebra_out("pseudowire %s nexthop %s (add)",
 181             zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop));
 182
 183         return (zebra_send_pw(zclient, ZEBRA_PW_ADD, zpw));
 184 }
 185
 186 int
 187 kmpw_del(struct zapi_pw *zpw)
 188 {
 189         debug_zebra_out("pseudowire %s nexthop %s (del)",
 190             zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop));
 191
 192         return (zebra_send_pw(zclient, ZEBRA_PW_DELETE, zpw));
 193 }
 194
 195 int
 196 kmpw_set(struct zapi_pw *zpw)
 197 {
 198         debug_zebra_out("pseudowire %s nexthop %s labels %u/%u (set)",
 199             zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop),
 200             zpw->local_label, zpw->remote_label);
 201
 202         return (zebra_send_pw(zclient, ZEBRA_PW_SET, zpw));
 203 }
 204
 205 int
 206 kmpw_unset(struct zapi_pw *zpw)
 207 {
 208         debug_zebra_out("pseudowire %s nexthop %s (unset)",
 209             zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop));
 210
 211         return (zebra_send_pw(zclient, ZEBRA_PW_UNSET, zpw));
 212 }
 213
 214 void
 215 kif_redistribute(const char *ifname)
 216 {
 217         struct listnode         *node, *cnode;
 218         struct interface        *ifp;
 219         struct connected        *ifc;
 220         struct kif               kif;
 221         struct kaddr             ka;
 222
 223         for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT), node, ifp)) {
 224                 if (ifname && strcmp(ifname, ifp->name) != 0)
 225                         continue;
 226
 227                 ifp2kif(ifp, &kif);
 228                 main_imsg_compose_both(IMSG_IFSTATUS, &kif, sizeof(kif));
 229
 230                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, ifc)) {
 231                         ifc2kaddr(ifp, ifc, &ka);
 232                         main_imsg_compose_ldpe(IMSG_NEWADDR, 0, &ka,
 233                             sizeof(ka));
 234                 }
 235         }
 236 }
 237
 238 static int
 239 ldp_router_id_update(int command, struct zclient *zclient, zebra_size_t length,
 240     vrf_id_t vrf_id)
 241 {
 242         struct prefix    router_id;
 243
 244         zebra_router_id_update_read(zclient->ibuf, &router_id);
 245
 246         if (bad_addr_v4(router_id.u.prefix4))
 247                 return (0);
 248
 249         debug_zebra_in("router-id update %s", inet_ntoa(router_id.u.prefix4));
 250
 251         global.rtr_id.s_addr = router_id.u.prefix4.s_addr;
 252         main_imsg_compose_ldpe(IMSG_RTRID_UPDATE, 0, &global.rtr_id,
 253             sizeof(global.rtr_id));
 254
 255         return (0);
 256 }
 257
 258 static int
 259 ldp_interface_add(int command, struct zclient *zclient, zebra_size_t length,
 260     vrf_id_t vrf_id)
 261 {
 262         struct interface        *ifp;
 263         struct kif               kif;
 264
 265         ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
 266         debug_zebra_in("interface add %s index %d mtu %d", ifp->name,
 267             ifp->ifindex, ifp->mtu);
 268
 269         ifp2kif(ifp, &kif);
 270         main_imsg_compose_both(IMSG_IFSTATUS, &kif, sizeof(kif));
 271
 272         return (0);
 273 }
 274
 275 static int
 276 ldp_interface_delete(int command, struct zclient *zclient, zebra_size_t length,
 277     vrf_id_t vrf_id)
 278 {
 279         struct interface        *ifp;
 280         struct kif               kif;
 281
 282         /* zebra_interface_state_read() updates interface structure in iflist */
 283         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 284         if (ifp == NULL)
 285                 return (0);
 286
 287         debug_zebra_in("interface delete %s index %d mtu %d", ifp->name,
 288             ifp->ifindex, ifp->mtu);
 289
 290         /* To support pseudo interface do not free interface structure.  */
 291         /* if_delete(ifp); */
 292         ifp->ifindex = IFINDEX_DELETED;
 293
 294         ifp2kif(ifp, &kif);
 295         main_imsg_compose_both(IMSG_IFSTATUS, &kif, sizeof(kif));
 296
 297         return (0);
 298 }
 299
 300 static int
 301 ldp_interface_status_change(int command, struct zclient *zclient,
 302     zebra_size_t length, vrf_id_t vrf_id)
 303 {
 304         struct interface        *ifp;
 305         struct listnode         *node;
 306         struct connected        *ifc;
 307         struct kif               kif;
 308         struct kaddr             ka;
 309
 310         /*
 311          * zebra_interface_state_read() updates interface structure in
 312          * iflist.
 313          */
 314         ifp = zebra_interface_state_read(zclient->ibuf, vrf_id);
 315         if (ifp == NULL)
 316                 return (0);
 317
 318         debug_zebra_in("interface %s state update", ifp->name);
 319
 320         ifp2kif(ifp, &kif);
 321         main_imsg_compose_both(IMSG_IFSTATUS, &kif, sizeof(kif));
 322
 323         if (if_is_operative(ifp)) {
 324                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 325                         ifc2kaddr(ifp, ifc, &ka);
 326                         main_imsg_compose_ldpe(IMSG_NEWADDR, 0, &ka,
 327                             sizeof(ka));
 328                 }
 329         } else {
 330                 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
 331                         ifc2kaddr(ifp, ifc, &ka);
 332                         main_imsg_compose_ldpe(IMSG_DELADDR, 0, &ka,
 333                             sizeof(ka));
 334                 }
 335         }
 336
 337         return (0);
 338 }
 339
 340 static int
 341 ldp_interface_address_add(int command, struct zclient *zclient,
 342     zebra_size_t length, vrf_id_t vrf_id)
 343 {
 344         struct connected        *ifc;
 345         struct interface        *ifp;
 346         struct kaddr             ka;
 347
 348         ifc = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
 349         if (ifc == NULL)
 350                 return (0);
 351
 352         ifp = ifc->ifp;
 353         ifc2kaddr(ifp, ifc, &ka);
 354
 355         /* Filter invalid addresses.  */
 356         if (bad_addr(ka.af, &ka.addr))
 357                 return (0);
 358
 359         debug_zebra_in("address add %s/%u interface %s",
 360             log_addr(ka.af, &ka.addr), ka.prefixlen, ifp->name);
 361
 362         /* notify ldpe about new address */
 363         main_imsg_compose_ldpe(IMSG_NEWADDR, 0, &ka, sizeof(ka));
 364
 365         return (0);
 366 }
 367
 368 static int
 369 ldp_interface_address_delete(int command, struct zclient *zclient,
 370     zebra_size_t length, vrf_id_t vrf_id)
 371 {
 372         struct connected        *ifc;
 373         struct interface        *ifp;
 374         struct kaddr             ka;
 375
 376         ifc = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
 377         if (ifc == NULL)
 378                 return (0);
 379
 380         ifp = ifc->ifp;
 381         ifc2kaddr(ifp, ifc, &ka);
 382         connected_free(ifc);
 383
 384         /* Filter invalid addresses.  */
 385         if (bad_addr(ka.af, &ka.addr))
 386                 return (0);
 387
 388         debug_zebra_in("address delete %s/%u interface %s",
 389             log_addr(ka.af, &ka.addr), ka.prefixlen, ifp->name);
 390
 391         /* notify ldpe about removed address */
 392         main_imsg_compose_ldpe(IMSG_DELADDR, 0, &ka, sizeof(ka));
 393
 394         return (0);
 395 }
 396
 397 static int
 398 ldp_zebra_read_route(int command, struct zclient *zclient, zebra_size_t length,
 399     vrf_id_t vrf_id)
 400 {
 401         struct stream           *s;
 402         u_char                   type;
 403         u_char                   message_flags;
 404         struct kroute            kr;
 405         int                      nhnum = 0, nhlen;
 406         size_t                   nhmark;
 407         int                      add = 0;
 408
 409         memset(&kr, 0, sizeof(kr));
 410         s = zclient->ibuf;
 411
 412         type = stream_getc(s);
 413         switch (type) {
 414         case ZEBRA_ROUTE_CONNECT:
 415                 kr.flags |= F_CONNECTED;
 416                 break;
 417         case ZEBRA_ROUTE_BGP:
 418                 /* LDP should follow the IGP and ignore BGP routes */
 419                 return (0);
 420         default:
 421                 break;
 422         }
 423
 424         stream_getl(s); /* flags, unused */
 425         stream_getw(s); /* instance, unused */
 426         message_flags = stream_getc(s);
 427
 428         switch (command) {
 429         case ZEBRA_REDISTRIBUTE_IPV4_ADD:
 430         case ZEBRA_REDISTRIBUTE_IPV4_DEL:
 431                 kr.af = AF_INET;
 432                 nhlen = sizeof(struct in_addr);
 433                 break;
 434         case ZEBRA_REDISTRIBUTE_IPV6_ADD:
 435         case ZEBRA_REDISTRIBUTE_IPV6_DEL:
 436                 kr.af = AF_INET6;
 437                 nhlen = sizeof(struct in6_addr);
 438                 break;
 439         default:
 440                 fatalx("ldp_zebra_read_route: unknown command");
 441         }
 442         kr.prefixlen = stream_getc(s);
 443         stream_get(&kr.prefix, s, PSIZE(kr.prefixlen));
 444
 445         if (bad_addr(kr.af, &kr.prefix) ||
 446             (kr.af == AF_INET6 && IN6_IS_SCOPE_EMBED(&kr.prefix.v6)))
 447                 return (0);
 448
 449         if (kr.af == AF_INET6 &&
 450             CHECK_FLAG(message_flags, ZAPI_MESSAGE_SRCPFX)) {
 451                 uint8_t src_prefixlen;
 452
 453                 src_prefixlen = stream_getc(s);
 454
 455                 /* we completely ignore srcdest routes for now. */
 456                 if (src_prefixlen)
 457                         return (0);
 458         }
 459
 460         if (CHECK_FLAG(message_flags, ZAPI_MESSAGE_NEXTHOP)) {
 461                 nhnum = stream_getc(s);
 462                 nhmark = stream_get_getp(s);
 463                 stream_set_getp(s, nhmark + nhnum * (nhlen + 5));
 464         }
 465
 466         if (CHECK_FLAG(message_flags, ZAPI_MESSAGE_DISTANCE))
 467                 kr.priority = stream_getc(s);
 468         if (CHECK_FLAG(message_flags, ZAPI_MESSAGE_METRIC))
 469                 stream_getl(s); /* metric, not used */
 470
 471         if (CHECK_FLAG(message_flags, ZAPI_MESSAGE_NEXTHOP))
 472                 stream_set_getp(s, nhmark);
 473
 474         if (command == ZEBRA_REDISTRIBUTE_IPV4_ADD ||
 475             command == ZEBRA_REDISTRIBUTE_IPV6_ADD)
 476                 add = 1;
 477
 478         if (nhnum == 0)
 479                 debug_zebra_in("route %s %s/%d (%s)", (add) ? "add" : "delete",
 480                     log_addr(kr.af, &kr.prefix), kr.prefixlen,
 481                     zebra_route_string(type));
 482
 483         /* loop through all the nexthops */
 484         for (; nhnum > 0; nhnum--) {
 485                 switch (kr.af) {
 486                 case AF_INET:
 487                         kr.nexthop.v4.s_addr = stream_get_ipv4(s);
 488                         break;
 489                 case AF_INET6:
 490                         stream_get(&kr.nexthop.v6, s, sizeof(kr.nexthop.v6));
 491                         break;
 492                 default:
 493                         break;
 494                 }
 495                 stream_getc(s); /* ifindex_num, unused. */
 496                 kr.ifindex = stream_getl(s);
 497
 498                 debug_zebra_in("route %s %s/%d nexthop %s ifindex %u (%s)",
 499                     (add) ? "add" : "delete", log_addr(kr.af, &kr.prefix),
 500                     kr.prefixlen, log_addr(kr.af, &kr.nexthop), kr.ifindex,
 501                     zebra_route_string(type));
 502
 503                 if (add)
 504                         main_imsg_compose_lde(IMSG_NETWORK_ADD, 0, &kr,
 505                             sizeof(kr));
 506         }
 507
 508         main_imsg_compose_lde(IMSG_NETWORK_UPDATE, 0, &kr, sizeof(kr));
 509
 510         return (0);
 511 }
 512
 513 /*
 514  * Receive PW status update from Zebra and send it to LDE process.
 515  */
 516 static int
 517 ldp_zebra_read_pw_status_update(int command, struct zclient *zclient,
 518     zebra_size_t length, vrf_id_t vrf_id)
 519 {
 520         struct zapi_pw_status    zpw;
 521
 522         zebra_read_pw_status_update(command, zclient, length, vrf_id, &zpw);
 523
 524         debug_zebra_in("pseudowire %s status %s", zpw.ifname,
 525             (zpw.status == PW_STATUS_UP) ? "up" : "down");
 526
 527         main_imsg_compose_lde(IMSG_PW_UPDATE, 0, &zpw, sizeof(zpw));
 528
 529         return (0);
 530 }
 531
 532 static void
 533 ldp_zebra_connected(struct zclient *zclient)
 534 {
 535         zclient_send_reg_requests(zclient, VRF_DEFAULT);
 536         zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP,
 537             ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
 538         zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP6,
 539             ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
 540 }
 541
 542 void
 543 ldp_zebra_init(struct thread_master *master)
 544 {
 545         /* Set default values. */
 546         zclient = zclient_new(master);
 547         zclient_init(zclient, ZEBRA_ROUTE_LDP, 0);
 548
 549         /* set callbacks */
 550         zclient->zebra_connected = ldp_zebra_connected;
 551         zclient->router_id_update = ldp_router_id_update;
 552         zclient->interface_add = ldp_interface_add;
 553         zclient->interface_delete = ldp_interface_delete;
 554         zclient->interface_up = ldp_interface_status_change;
 555         zclient->interface_down = ldp_interface_status_change;
 556         zclient->interface_address_add = ldp_interface_address_add;
 557         zclient->interface_address_delete = ldp_interface_address_delete;
 558         zclient->redistribute_route_ipv4_add = ldp_zebra_read_route;
 559         zclient->redistribute_route_ipv4_del = ldp_zebra_read_route;
 560         zclient->redistribute_route_ipv6_add = ldp_zebra_read_route;
 561         zclient->redistribute_route_ipv6_del = ldp_zebra_read_route;
 562         zclient->pw_status_update = ldp_zebra_read_pw_status_update;
 563 }
 564
 565 void
 566 ldp_zebra_destroy(void)
 567 {
 568         zclient_stop(zclient);
 569         zclient_free(zclient);
 570         zclient = NULL;
 571 }