zebra/zebra_mpls_openbsd.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 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
  21 #include <zebra.h>
  22
  23 #ifdef OPEN_BSD
  24
  25 #include <netmpls/mpls.h>
  26 #include "zebra/rt.h"
  27 #include "zebra/zebra_mpls.h"
  28 #include "zebra/debug.h"
  29
  30 #include "privs.h"
  31 #include "prefix.h"
  32 #include "interface.h"
  33 #include "log.h"
  34
  35 extern struct zebra_privs_t zserv_privs;
  36
  37 struct {
  38         u_int32_t rtseq;
  39         int fd;
  40         int ioctl_fd;
  41 } kr_state;
  42
  43 static int kernel_send_rtmsg_v4(int action, mpls_label_t in_label,
  44                                 zebra_nhlfe_t *nhlfe)
  45 {
  46         struct iovec iov[5];
  47         struct rt_msghdr hdr;
  48         struct sockaddr_mpls sa_label_in, sa_label_out;
  49         struct sockaddr_in nexthop;
  50         int iovcnt = 0;
  51         int ret;
  52
  53         if (IS_ZEBRA_DEBUG_KERNEL)
  54                 zlog_debug("%s: 0x%x, label=%u", __func__, action, in_label);
  55
  56         /* initialize header */
  57         memset(&hdr, 0, sizeof(hdr));
  58         hdr.rtm_version = RTM_VERSION;
  59
  60         hdr.rtm_type = action;
  61         hdr.rtm_flags = RTF_UP;
  62         hdr.rtm_fmask = RTF_MPLS;
  63         hdr.rtm_seq = kr_state.rtseq++; /* overflow doesn't matter */
  64         hdr.rtm_msglen = sizeof(hdr);
  65         hdr.rtm_hdrlen = sizeof(struct rt_msghdr);
  66         hdr.rtm_priority = 0;
  67         /* adjust iovec */
  68         iov[iovcnt].iov_base = &hdr;
  69         iov[iovcnt++].iov_len = sizeof(hdr);
  70
  71         /* in label */
  72         memset(&sa_label_in, 0, sizeof(sa_label_in));
  73         sa_label_in.smpls_len = sizeof(sa_label_in);
  74         sa_label_in.smpls_family = AF_MPLS;
  75         sa_label_in.smpls_label = htonl(in_label << MPLS_LABEL_OFFSET);
  76         /* adjust header */
  77         hdr.rtm_flags |= RTF_MPLS | RTF_MPATH;
  78         hdr.rtm_addrs |= RTA_DST;
  79         hdr.rtm_msglen += sizeof(sa_label_in);
  80         /* adjust iovec */
  81         iov[iovcnt].iov_base = &sa_label_in;
  82         iov[iovcnt++].iov_len = sizeof(sa_label_in);
  83
  84         /* nexthop */
  85         memset(&nexthop, 0, sizeof(nexthop));
  86         nexthop.sin_len = sizeof(nexthop);
  87         nexthop.sin_family = AF_INET;
  88         nexthop.sin_addr = nhlfe->nexthop->gate.ipv4;
  89         /* adjust header */
  90         hdr.rtm_flags |= RTF_GATEWAY;
  91         hdr.rtm_addrs |= RTA_GATEWAY;
  92         hdr.rtm_msglen += sizeof(nexthop);
  93         /* adjust iovec */
  94         iov[iovcnt].iov_base = &nexthop;
  95         iov[iovcnt++].iov_len = sizeof(nexthop);
  96
  97         /* If action is RTM_DELETE we have to get rid of MPLS infos */
  98         if (action != RTM_DELETE) {
  99                 memset(&sa_label_out, 0, sizeof(sa_label_out));
 100                 sa_label_out.smpls_len = sizeof(sa_label_out);
 101                 sa_label_out.smpls_family = AF_MPLS;
 102                 sa_label_out.smpls_label =
 103                         htonl(nhlfe->nexthop->nh_label->label[0]
 104                               << MPLS_LABEL_OFFSET);
 105                 /* adjust header */
 106                 hdr.rtm_addrs |= RTA_SRC;
 107                 hdr.rtm_flags |= RTF_MPLS;
 108                 hdr.rtm_msglen += sizeof(sa_label_out);
 109                 /* adjust iovec */
 110                 iov[iovcnt].iov_base = &sa_label_out;
 111                 iov[iovcnt++].iov_len = sizeof(sa_label_out);
 112
 113                 if (nhlfe->nexthop->nh_label->label[0] == MPLS_LABEL_IMPLNULL)
 114                         hdr.rtm_mpls = MPLS_OP_POP;
 115                 else
 116                         hdr.rtm_mpls = MPLS_OP_SWAP;
 117         }
 118
 119         if (zserv_privs.change(ZPRIVS_RAISE))
 120                 zlog_err("Can't raise privileges");
 121         ret = writev(kr_state.fd, iov, iovcnt);
 122         if (zserv_privs.change(ZPRIVS_LOWER))
 123                 zlog_err("Can't lower privileges");
 124
 125         if (ret == -1)
 126                 zlog_err("%s: %s", __func__, safe_strerror(errno));
 127
 128         return ret;
 129 }
 130
 131 #if !defined(ROUNDUP)
 132 #define ROUNDUP(a)                                                             \
 133         (((a) & (sizeof(long) - 1)) ? (1 + ((a) | (sizeof(long) - 1))) : (a))
 134 #endif
 135
 136 static int kernel_send_rtmsg_v6(int action, mpls_label_t in_label,
 137                                 zebra_nhlfe_t *nhlfe)
 138 {
 139         struct iovec iov[5];
 140         struct rt_msghdr hdr;
 141         struct sockaddr_mpls sa_label_in, sa_label_out;
 142         struct pad {
 143                 struct sockaddr_in6 addr;
 144                 char pad[sizeof(long)]; /* thank you IPv6 */
 145         } nexthop;
 146         int iovcnt = 0;
 147         int ret;
 148
 149         if (IS_ZEBRA_DEBUG_KERNEL)
 150                 zlog_debug("%s: 0x%x, label=%u", __func__, action, in_label);
 151
 152         /* initialize header */
 153         memset(&hdr, 0, sizeof(hdr));
 154         hdr.rtm_version = RTM_VERSION;
 155
 156         hdr.rtm_type = action;
 157         hdr.rtm_flags = RTF_UP;
 158         hdr.rtm_fmask = RTF_MPLS;
 159         hdr.rtm_seq = kr_state.rtseq++; /* overflow doesn't matter */
 160         hdr.rtm_msglen = sizeof(hdr);
 161         hdr.rtm_hdrlen = sizeof(struct rt_msghdr);
 162         hdr.rtm_priority = 0;
 163         /* adjust iovec */
 164         iov[iovcnt].iov_base = &hdr;
 165         iov[iovcnt++].iov_len = sizeof(hdr);
 166
 167         /* in label */
 168         memset(&sa_label_in, 0, sizeof(sa_label_in));
 169         sa_label_in.smpls_len = sizeof(sa_label_in);
 170         sa_label_in.smpls_family = AF_MPLS;
 171         sa_label_in.smpls_label = htonl(in_label << MPLS_LABEL_OFFSET);
 172         /* adjust header */
 173         hdr.rtm_flags |= RTF_MPLS | RTF_MPATH;
 174         hdr.rtm_addrs |= RTA_DST;
 175         hdr.rtm_msglen += sizeof(sa_label_in);
 176         /* adjust iovec */
 177         iov[iovcnt].iov_base = &sa_label_in;
 178         iov[iovcnt++].iov_len = sizeof(sa_label_in);
 179
 180         /* nexthop */
 181         memset(&nexthop, 0, sizeof(nexthop));
 182         nexthop.addr.sin6_len = sizeof(struct sockaddr_in6);
 183         nexthop.addr.sin6_family = AF_INET6;
 184         nexthop.addr.sin6_addr = nhlfe->nexthop->gate.ipv6;
 185         if (IN6_IS_ADDR_LINKLOCAL(&nexthop.addr.sin6_addr)) {
 186                 uint16_t tmp16;
 187                 struct sockaddr_in6 *sin6 = &nexthop.addr;
 188
 189                 nexthop.addr.sin6_scope_id = nhlfe->nexthop->ifindex;
 190
 191                 memcpy(&tmp16, &sin6->sin6_addr.s6_addr[2], sizeof(tmp16));
 192                 tmp16 = htons(sin6->sin6_scope_id);
 193                 memcpy(&sin6->sin6_addr.s6_addr[2], &tmp16, sizeof(tmp16));
 194                 sin6->sin6_scope_id = 0;
 195         }
 196
 197         /* adjust header */
 198         hdr.rtm_flags |= RTF_GATEWAY;
 199         hdr.rtm_addrs |= RTA_GATEWAY;
 200         hdr.rtm_msglen += ROUNDUP(sizeof(struct sockaddr_in6));
 201         /* adjust iovec */
 202         iov[iovcnt].iov_base = &nexthop;
 203         iov[iovcnt++].iov_len = ROUNDUP(sizeof(struct sockaddr_in6));
 204
 205         /* If action is RTM_DELETE we have to get rid of MPLS infos */
 206         if (action != RTM_DELETE) {
 207                 memset(&sa_label_out, 0, sizeof(sa_label_out));
 208                 sa_label_out.smpls_len = sizeof(sa_label_out);
 209                 sa_label_out.smpls_family = AF_MPLS;
 210                 sa_label_out.smpls_label =
 211                         htonl(nhlfe->nexthop->nh_label->label[0]
 212                               << MPLS_LABEL_OFFSET);
 213                 /* adjust header */
 214                 hdr.rtm_addrs |= RTA_SRC;
 215                 hdr.rtm_flags |= RTF_MPLS;
 216                 hdr.rtm_msglen += sizeof(sa_label_out);
 217                 /* adjust iovec */
 218                 iov[iovcnt].iov_base = &sa_label_out;
 219                 iov[iovcnt++].iov_len = sizeof(sa_label_out);
 220
 221                 if (nhlfe->nexthop->nh_label->label[0] == MPLS_LABEL_IMPLNULL)
 222                         hdr.rtm_mpls = MPLS_OP_POP;
 223                 else
 224                         hdr.rtm_mpls = MPLS_OP_SWAP;
 225         }
 226
 227         if (zserv_privs.change(ZPRIVS_RAISE))
 228                 zlog_err("Can't raise privileges");
 229         ret = writev(kr_state.fd, iov, iovcnt);
 230         if (zserv_privs.change(ZPRIVS_LOWER))
 231                 zlog_err("Can't lower privileges");
 232
 233         if (ret == -1)
 234                 zlog_err("%s: %s", __func__, safe_strerror(errno));
 235
 236         return ret;
 237 }
 238
 239 static int kernel_lsp_cmd(int action, zebra_lsp_t *lsp)
 240 {
 241         zebra_nhlfe_t *nhlfe;
 242         struct nexthop *nexthop = NULL;
 243         unsigned int nexthop_num = 0;
 244
 245         for (nhlfe = lsp->nhlfe_list; nhlfe; nhlfe = nhlfe->next) {
 246                 nexthop = nhlfe->nexthop;
 247                 if (!nexthop)
 248                         continue;
 249
 250                 if (nexthop_num >= multipath_num)
 251                         break;
 252
 253                 if (((action == RTM_ADD || action == RTM_CHANGE)
 254                      && (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)
 255                          && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)))
 256                     || (action == RTM_DELETE
 257                         && (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED)
 258                             && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)))) {
 259                         if (nhlfe->nexthop->nh_label->num_labels > 1) {
 260                                 zlog_warn(
 261                                         "%s: can't push %u labels at once "
 262                                         "(maximum is 1)",
 263                                         __func__,
 264                                         nhlfe->nexthop->nh_label->num_labels);
 265                                 continue;
 266                         }
 267
 268                         nexthop_num++;
 269
 270                         switch (NHLFE_FAMILY(nhlfe)) {
 271                         case AF_INET:
 272                                 kernel_send_rtmsg_v4(action, lsp->ile.in_label,
 273                                                      nhlfe);
 274                                 break;
 275                         case AF_INET6:
 276                                 kernel_send_rtmsg_v6(action, lsp->ile.in_label,
 277                                                      nhlfe);
 278                                 break;
 279                         default:
 280                                 break;
 281                         }
 282                         if (action == RTM_ADD || action == RTM_CHANGE) {
 283                                 SET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
 284                                 SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
 285                         } else {
 286                                 UNSET_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED);
 287                                 UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
 288                         }
 289                 }
 290         }
 291
 292         return (0);
 293 }
 294
 295 int kernel_add_lsp(zebra_lsp_t *lsp)
 296 {
 297         int ret;
 298
 299         if (!lsp || !lsp->best_nhlfe) // unexpected
 300                 return -1;
 301
 302         UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
 303         ret = kernel_lsp_cmd(RTM_ADD, lsp);
 304         if (!ret)
 305                 SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 306
 307         return ret;
 308 }
 309
 310 int kernel_upd_lsp(zebra_lsp_t *lsp)
 311 {
 312         int ret;
 313
 314         if (!lsp || !lsp->best_nhlfe) // unexpected
 315                 return -1;
 316
 317         UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
 318         UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 319         ret = kernel_lsp_cmd(RTM_CHANGE, lsp);
 320         if (!ret)
 321                 SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 322
 323         return ret;
 324 }
 325
 326 int kernel_del_lsp(zebra_lsp_t *lsp)
 327 {
 328         int ret;
 329
 330         if (!lsp) // unexpected
 331                 return -1;
 332
 333         if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED))
 334                 return -1;
 335
 336         ret = kernel_lsp_cmd(RTM_DELETE, lsp);
 337         if (!ret)
 338                 UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 339
 340         return ret;
 341 }
 342
 343 static int kmpw_install(struct zebra_pw *pw)
 344 {
 345         struct ifreq ifr;
 346         struct ifmpwreq imr;
 347         struct sockaddr_storage ss;
 348         struct sockaddr_in *sa_in = (struct sockaddr_in *)&ss;
 349         struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)&ss;
 350
 351         memset(&imr, 0, sizeof(imr));
 352         switch (pw->type) {
 353         case PW_TYPE_ETHERNET:
 354                 imr.imr_type = IMR_TYPE_ETHERNET;
 355                 break;
 356         case PW_TYPE_ETHERNET_TAGGED:
 357                 imr.imr_type = IMR_TYPE_ETHERNET_TAGGED;
 358                 break;
 359         default:
 360                 zlog_err("%s: unhandled pseudowire type (%#X)", __func__,
 361                          pw->type);
 362                 return -1;
 363         }
 364
 365         if (pw->flags & F_PSEUDOWIRE_CWORD)
 366                 imr.imr_flags |= IMR_FLAG_CONTROLWORD;
 367
 368         /* pseudowire nexthop */
 369         memset(&ss, 0, sizeof(ss));
 370         switch (pw->af) {
 371         case AF_INET:
 372                 sa_in->sin_family = AF_INET;
 373                 sa_in->sin_len = sizeof(struct sockaddr_in);
 374                 sa_in->sin_addr = pw->nexthop.ipv4;
 375                 break;
 376         case AF_INET6:
 377                 sa_in6->sin6_family = AF_INET6;
 378                 sa_in6->sin6_len = sizeof(struct sockaddr_in6);
 379                 sa_in6->sin6_addr = pw->nexthop.ipv6;
 380                 break;
 381         default:
 382                 zlog_err("%s: unhandled pseudowire address-family (%u)",
 383                          __func__, pw->af);
 384                 return -1;
 385         }
 386         memcpy(&imr.imr_nexthop, (struct sockaddr *)&ss,
 387                sizeof(imr.imr_nexthop));
 388
 389         /* pseudowire local/remote labels */
 390         imr.imr_lshim.shim_label = pw->local_label;
 391         imr.imr_rshim.shim_label = pw->remote_label;
 392
 393         /* ioctl */
 394         memset(&ifr, 0, sizeof(ifr));
 395         strlcpy(ifr.ifr_name, pw->ifname, sizeof(ifr.ifr_name));
 396         ifr.ifr_data = (caddr_t)&imr;
 397         if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
 398                 zlog_err("ioctl SIOCSETMPWCFG: %s", safe_strerror(errno));
 399                 return -1;
 400         }
 401
 402         return 0;
 403 }
 404
 405 static int kmpw_uninstall(struct zebra_pw *pw)
 406 {
 407         struct ifreq ifr;
 408         struct ifmpwreq imr;
 409
 410         memset(&ifr, 0, sizeof(ifr));
 411         memset(&imr, 0, sizeof(imr));
 412         strlcpy(ifr.ifr_name, pw->ifname, sizeof(ifr.ifr_name));
 413         ifr.ifr_data = (caddr_t)&imr;
 414         if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
 415                 zlog_err("ioctl SIOCSETMPWCFG: %s", safe_strerror(errno));
 416                 return -1;
 417         }
 418
 419         return 0;
 420 }
 421
 422 #define MAX_RTSOCK_BUF  128 * 1024
 423 int mpls_kernel_init(void)
 424 {
 425         int rcvbuf, default_rcvbuf;
 426         socklen_t optlen;
 427
 428         if ((kr_state.fd = socket(AF_ROUTE, SOCK_RAW, 0)) == -1) {
 429                 zlog_warn("%s: socket", __func__);
 430                 return -1;
 431         }
 432
 433         if ((kr_state.ioctl_fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, 0))
 434             == -1) {
 435                 zlog_warn("%s: ioctl socket", __func__);
 436                 return -1;
 437         }
 438
 439         /* grow receive buffer, don't wanna miss messages */
 440         optlen = sizeof(default_rcvbuf);
 441         if (getsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, &default_rcvbuf,
 442                        &optlen)
 443             == -1)
 444                 zlog_warn("kr_init getsockopt SOL_SOCKET SO_RCVBUF");
 445         else
 446                 for (rcvbuf = MAX_RTSOCK_BUF;
 447                      rcvbuf > default_rcvbuf
 448                      && setsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
 449                                    sizeof(rcvbuf))
 450                                 == -1
 451                      && errno == ENOBUFS;
 452                      rcvbuf /= 2)
 453                         ; /* nothing */
 454
 455         kr_state.rtseq = 1;
 456
 457         /* register hook to install/uninstall pseudowires */
 458         hook_register(pw_install, kmpw_install);
 459         hook_register(pw_uninstall, kmpw_uninstall);
 460
 461         return 0;
 462 }
 463
 464 #endif /* OPEN_BSD */