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