zebra/rt_socket.c

   1 /*
   2  * Kernel routing table updates by routing socket.
   3  * Copyright (C) 1997, 98 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23
  24 #ifndef HAVE_NETLINK
  25
  26 #ifdef __OpenBSD__
  27 #include <netmpls/mpls.h>
  28 #endif
  29
  30 #include "if.h"
  31 #include "prefix.h"
  32 #include "sockunion.h"
  33 #include "log.h"
  34 #include "privs.h"
  35 #include "vxlan.h"
  36 #include "lib_errors.h"
  37
  38 #include "zebra/debug.h"
  39 #include "zebra/rib.h"
  40 #include "zebra/rt.h"
  41 #include "zebra/kernel_socket.h"
  42 #include "zebra/zebra_mpls.h"
  43
  44 extern struct zebra_privs_t zserv_privs;
  45
  46 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
  47 /* Adjust netmask socket length. Return value is a adjusted sin_len
  48    value. */
  49 static int sin_masklen(struct in_addr mask)
  50 {
  51         char *p, *lim;
  52         int len;
  53         struct sockaddr_in sin;
  54
  55         if (mask.s_addr == 0)
  56                 return sizeof(long);
  57
  58         sin.sin_addr = mask;
  59         len = sizeof(struct sockaddr_in);
  60
  61         lim = (char *)&sin.sin_addr;
  62         p = lim + sizeof(sin.sin_addr);
  63
  64         while (*--p == 0 && p >= lim)
  65                 len--;
  66         return len;
  67 }
  68 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
  69
  70 #ifdef __OpenBSD__
  71 static int kernel_rtm_add_labels(struct mpls_label_stack *nh_label,
  72                                  struct sockaddr_mpls *smpls)
  73 {
  74         if (nh_label->num_labels > 1) {
  75                 zlog_warn(
  76                         "%s: can't push %u labels at "
  77                         "once (maximum is 1)",
  78                         __func__, nh_label->num_labels);
  79                 return -1;
  80         }
  81
  82         memset(smpls, 0, sizeof(*smpls));
  83         smpls->smpls_len = sizeof(*smpls);
  84         smpls->smpls_family = AF_MPLS;
  85         smpls->smpls_label = htonl(nh_label->label[0] << MPLS_LABEL_OFFSET);
  86
  87         return 0;
  88 }
  89 #endif
  90
  91 /* Interface between zebra message and rtm message. */
  92 static int kernel_rtm_ipv4(int cmd, const struct prefix *p,
  93                            struct route_entry *re)
  94
  95 {
  96         struct sockaddr_in *mask = NULL;
  97         struct sockaddr_in sin_dest, sin_mask, sin_gate;
  98 #ifdef __OpenBSD__
  99         struct sockaddr_mpls smpls;
 100 #endif
 101         union sockunion *smplsp = NULL;
 102         struct nexthop *nexthop;
 103         int nexthop_num = 0;
 104         ifindex_t ifindex = 0;
 105         int gate = 0;
 106         int error;
 107         char prefix_buf[PREFIX_STRLEN];
 108         enum blackhole_type bh_type = BLACKHOLE_UNSPEC;
 109
 110         if (IS_ZEBRA_DEBUG_RIB)
 111                 prefix2str(p, prefix_buf, sizeof(prefix_buf));
 112         memset(&sin_dest, 0, sizeof(struct sockaddr_in));
 113         sin_dest.sin_family = AF_INET;
 114 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 115         sin_dest.sin_len = sizeof(struct sockaddr_in);
 116 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 117         sin_dest.sin_addr = p->u.prefix4;
 118
 119         memset(&sin_mask, 0, sizeof(struct sockaddr_in));
 120
 121         memset(&sin_gate, 0, sizeof(struct sockaddr_in));
 122         sin_gate.sin_family = AF_INET;
 123 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 124         sin_gate.sin_len = sizeof(struct sockaddr_in);
 125 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 126
 127         /* Make gateway. */
 128         for (ALL_NEXTHOPS(re->ng, nexthop)) {
 129                 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 130                         continue;
 131
 132                 gate = 0;
 133                 char gate_buf[INET_ADDRSTRLEN] = "NULL";
 134
 135                 /*
 136                  * XXX We need to refrain from kernel operations in some cases,
 137                  * but this if statement seems overly cautious - what about
 138                  * other than ADD and DELETE?
 139                  */
 140                 if ((cmd == RTM_ADD && NEXTHOP_IS_ACTIVE(nexthop->flags))
 141                     || (cmd == RTM_DELETE
 142                         && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB))) {
 143                         if (nexthop->type == NEXTHOP_TYPE_IPV4
 144                             || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX) {
 145                                 sin_gate.sin_addr = nexthop->gate.ipv4;
 146                                 gate = 1;
 147                         }
 148                         if (nexthop->type == NEXTHOP_TYPE_IFINDEX
 149                             || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 150                                 ifindex = nexthop->ifindex;
 151                         if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE) {
 152                                 struct in_addr loopback;
 153                                 loopback.s_addr = htonl(INADDR_LOOPBACK);
 154                                 sin_gate.sin_addr = loopback;
 155                                 bh_type = nexthop->bh_type;
 156                                 gate = 1;
 157                         }
 158
 159                         if (gate && p->prefixlen == 32)
 160                                 mask = NULL;
 161                         else {
 162                                 masklen2ip(p->prefixlen, &sin_mask.sin_addr);
 163                                 sin_mask.sin_family = AF_INET;
 164 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 165                                 sin_mask.sin_len =
 166                                         sin_masklen(sin_mask.sin_addr);
 167 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 168                                 mask = &sin_mask;
 169                         }
 170
 171 #ifdef __OpenBSD__
 172                         if (nexthop->nh_label
 173                             && !kernel_rtm_add_labels(nexthop->nh_label,
 174                                                       &smpls))
 175                                 continue;
 176                         smplsp = (union sockunion *)&smpls;
 177 #endif
 178
 179                         error = rtm_write(cmd, (union sockunion *)&sin_dest,
 180                                           (union sockunion *)mask,
 181                                           gate ? (union sockunion *)&sin_gate
 182                                                : NULL,
 183                                           smplsp, ifindex, bh_type, re->metric);
 184
 185                         if (IS_ZEBRA_DEBUG_RIB) {
 186                                 if (!gate) {
 187                                         zlog_debug(
 188                                                 "%s: %s: attention! gate not found for re %p",
 189                                                 __func__, prefix_buf, re);
 190                                         route_entry_dump(p, NULL, re);
 191                                 } else
 192                                         inet_ntop(AF_INET, &sin_gate.sin_addr,
 193                                                   gate_buf, INET_ADDRSTRLEN);
 194                         }
 195
 196                         switch (error) {
 197                         /* We only flag nexthops as being in FIB if rtm_write()
 198                          * did its work. */
 199                         case ZEBRA_ERR_NOERROR:
 200                                 nexthop_num++;
 201                                 if (IS_ZEBRA_DEBUG_RIB)
 202                                         zlog_debug(
 203                                                 "%s: %s: successfully did NH %s",
 204                                                 __func__, prefix_buf, gate_buf);
 205                                 break;
 206
 207                         /* The only valid case for this error is kernel's
 208                          * failure to install
 209                          * a multipath route, which is common for FreeBSD. This
 210                          * should be
 211                          * ignored silently, but logged as an error otherwise.
 212                          */
 213                         case ZEBRA_ERR_RTEXIST:
 214                                 if (cmd != RTM_ADD)
 215                                         flog_err(
 216                                                 LIB_ERR_SYSTEM_CALL,
 217                                                 "%s: rtm_write() returned %d for command %d",
 218                                                 __func__, error, cmd);
 219                                 continue;
 220                                 break;
 221
 222                         /* Given that our NEXTHOP_FLAG_FIB matches real kernel
 223                          * FIB, it isn't
 224                          * normal to get any other messages in ANY case.
 225                          */
 226                         case ZEBRA_ERR_RTNOEXIST:
 227                         case ZEBRA_ERR_RTUNREACH:
 228                         default:
 229                                 flog_err(
 230                                         LIB_ERR_SYSTEM_CALL,
 231                                         "%s: %s: rtm_write() unexpectedly returned %d for command %s",
 232                                         __func__,
 233                                         prefix2str(p, prefix_buf,
 234                                                    sizeof(prefix_buf)),
 235                                         error,
 236                                         lookup_msg(rtm_type_str, cmd, NULL));
 237                                 break;
 238                         }
 239                 } /* if (cmd and flags make sense) */
 240                 else if (IS_ZEBRA_DEBUG_RIB)
 241                         zlog_debug("%s: odd command %s for flags %d", __func__,
 242                                    lookup_msg(rtm_type_str, cmd, NULL),
 243                                    nexthop->flags);
 244         } /* for (ALL_NEXTHOPS(...))*/
 245
 246         /* If there was no useful nexthop, then complain. */
 247         if (nexthop_num == 0 && IS_ZEBRA_DEBUG_KERNEL)
 248                 zlog_debug("%s: No useful nexthops were found in RIB entry %p",
 249                            __func__, re);
 250
 251         return 0; /*XXX*/
 252 }
 253
 254 #ifdef SIN6_LEN
 255 /* Calculate sin6_len value for netmask socket value. */
 256 static int sin6_masklen(struct in6_addr mask)
 257 {
 258         struct sockaddr_in6 sin6;
 259         char *p, *lim;
 260         int len;
 261
 262         if (IN6_IS_ADDR_UNSPECIFIED(&mask))
 263                 return sizeof(long);
 264
 265         sin6.sin6_addr = mask;
 266         len = sizeof(struct sockaddr_in6);
 267
 268         lim = (char *)&sin6.sin6_addr;
 269         p = lim + sizeof(sin6.sin6_addr);
 270
 271         while (*--p == 0 && p >= lim)
 272                 len--;
 273
 274         return len;
 275 }
 276 #endif /* SIN6_LEN */
 277
 278 /* Interface between zebra message and rtm message. */
 279 static int kernel_rtm_ipv6(int cmd, const struct prefix *p,
 280                            struct route_entry *re)
 281 {
 282         struct sockaddr_in6 *mask;
 283         struct sockaddr_in6 sin_dest, sin_mask, sin_gate;
 284 #ifdef __OpenBSD__
 285         struct sockaddr_mpls smpls;
 286 #endif
 287         union sockunion *smplsp = NULL;
 288         struct nexthop *nexthop;
 289         int nexthop_num = 0;
 290         ifindex_t ifindex = 0;
 291         int gate = 0;
 292         int error;
 293         enum blackhole_type bh_type = BLACKHOLE_UNSPEC;
 294
 295         memset(&sin_dest, 0, sizeof(struct sockaddr_in6));
 296         sin_dest.sin6_family = AF_INET6;
 297 #ifdef SIN6_LEN
 298         sin_dest.sin6_len = sizeof(struct sockaddr_in6);
 299 #endif /* SIN6_LEN */
 300         sin_dest.sin6_addr = p->u.prefix6;
 301
 302         memset(&sin_mask, 0, sizeof(struct sockaddr_in6));
 303
 304         memset(&sin_gate, 0, sizeof(struct sockaddr_in6));
 305         sin_gate.sin6_family = AF_INET6;
 306 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 307         sin_gate.sin6_len = sizeof(struct sockaddr_in6);
 308 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 309
 310         /* Make gateway. */
 311         for (ALL_NEXTHOPS(re->ng, nexthop)) {
 312                 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 313                         continue;
 314
 315                 gate = 0;
 316
 317                 if ((cmd == RTM_ADD && NEXTHOP_IS_ACTIVE(nexthop->flags))
 318                     || (cmd == RTM_DELETE)) {
 319                         if (nexthop->type == NEXTHOP_TYPE_IPV6
 320                             || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
 321                                 sin_gate.sin6_addr = nexthop->gate.ipv6;
 322                                 gate = 1;
 323                         }
 324                         if (nexthop->type == NEXTHOP_TYPE_IFINDEX
 325                             || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
 326                                 ifindex = nexthop->ifindex;
 327
 328                         if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE)
 329                                 bh_type = nexthop->bh_type;
 330                 }
 331
 332 /* Under kame set interface index to link local address. */
 333 #ifdef KAME
 334
 335 #define SET_IN6_LINKLOCAL_IFINDEX(a, i)                                        \
 336         do {                                                                   \
 337                 (a).s6_addr[2] = ((i) >> 8) & 0xff;                            \
 338                 (a).s6_addr[3] = (i)&0xff;                                     \
 339         } while (0)
 340
 341                 if (gate && IN6_IS_ADDR_LINKLOCAL(&sin_gate.sin6_addr))
 342                         SET_IN6_LINKLOCAL_IFINDEX(sin_gate.sin6_addr, ifindex);
 343 #endif /* KAME */
 344
 345                 if (gate && p->prefixlen == 128)
 346                         mask = NULL;
 347                 else {
 348                         masklen2ip6(p->prefixlen, &sin_mask.sin6_addr);
 349                         sin_mask.sin6_family = AF_INET6;
 350 #ifdef SIN6_LEN
 351                         sin_mask.sin6_len = sin6_masklen(sin_mask.sin6_addr);
 352 #endif /* SIN6_LEN */
 353                         mask = &sin_mask;
 354                 }
 355
 356 #ifdef __OpenBSD__
 357                 if (nexthop->nh_label
 358                     && !kernel_rtm_add_labels(nexthop->nh_label, &smpls))
 359                         continue;
 360                 smplsp = (union sockunion *)&smpls;
 361 #endif
 362
 363                 error = rtm_write(cmd, (union sockunion *)&sin_dest,
 364                                   (union sockunion *)mask,
 365                                   gate ? (union sockunion *)&sin_gate : NULL,
 366                                   smplsp, ifindex, bh_type, re->metric);
 367                 (void)error;
 368
 369                 nexthop_num++;
 370         }
 371
 372         /* If there is no useful nexthop then return. */
 373         if (nexthop_num == 0) {
 374                 if (IS_ZEBRA_DEBUG_KERNEL)
 375                         zlog_debug("kernel_rtm_ipv6(): No useful nexthop.");
 376                 return 0;
 377         }
 378
 379         return 0; /*XXX*/
 380 }
 381
 382 static int kernel_rtm(int cmd, const struct prefix *p, struct route_entry *re)
 383 {
 384         switch (PREFIX_FAMILY(p)) {
 385         case AF_INET:
 386                 return kernel_rtm_ipv4(cmd, p, re);
 387         case AF_INET6:
 388                 return kernel_rtm_ipv6(cmd, p, re);
 389         }
 390         return 0;
 391 }
 392
 393 enum dp_req_result kernel_route_rib(struct route_node *rn,
 394                                     const struct prefix *p,
 395                                     const struct prefix *src_p,
 396                                     struct route_entry *old,
 397                                     struct route_entry *new)
 398 {
 399         int route = 0;
 400
 401         if (src_p && src_p->prefixlen) {
 402                 zlog_warn("%s: IPv6 sourcedest routes unsupported!", __func__);
 403                 return DP_REQUEST_FAILURE;
 404         }
 405
 406         frr_elevate_privs(&zserv_privs) {
 407
 408                 if (old)
 409                         route |= kernel_rtm(RTM_DELETE, p, old);
 410
 411                 if (new)
 412                         route |= kernel_rtm(RTM_ADD, p, new);
 413
 414         }
 415
 416         if (new) {
 417                 kernel_route_rib_pass_fail(
 418                         rn, p, new,
 419                         (!route) ? DP_INSTALL_SUCCESS
 420                                  : DP_INSTALL_FAILURE);
 421         } else {
 422                 kernel_route_rib_pass_fail(rn, p, old,
 423                                            (!route)
 424                                                    ? DP_DELETE_SUCCESS
 425                                                    : DP_DELETE_FAILURE);
 426         }
 427
 428         return DP_REQUEST_SUCCESS;
 429 }
 430
 431 int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
 432                         int llalen, ns_id_t ns_id)
 433 {
 434         /* TODO */
 435         return 0;
 436 }
 437
 438 extern int kernel_get_ipmr_sg_stats(struct zebra_vrf *zvrf, void *mroute)
 439 {
 440         return 0;
 441 }
 442
 443 int kernel_add_vtep(vni_t vni, struct interface *ifp, struct in_addr *vtep_ip)
 444 {
 445         return 0;
 446 }
 447
 448 int kernel_del_vtep(vni_t vni, struct interface *ifp, struct in_addr *vtep_ip)
 449 {
 450         return 0;
 451 }
 452
 453 int kernel_add_mac(struct interface *ifp, vlanid_t vid, struct ethaddr *mac,
 454                    struct in_addr vtep_ip, uint8_t sticky)
 455 {
 456         return 0;
 457 }
 458
 459 int kernel_del_mac(struct interface *ifp, vlanid_t vid, struct ethaddr *mac,
 460                    struct in_addr vtep_ip, int local)
 461 {
 462         return 0;
 463 }
 464
 465 int kernel_add_neigh(struct interface *ifp, struct ipaddr *ip,
 466                      struct ethaddr *mac, uint8_t flags)
 467 {
 468         return 0;
 469 }
 470
 471 int kernel_del_neigh(struct interface *ifp, struct ipaddr *ip)
 472 {
 473         return 0;
 474 }
 475
 476 extern int kernel_interface_set_master(struct interface *master,
 477                                        struct interface *slave)
 478 {
 479         return 0;
 480 }
 481
 482 uint32_t kernel_get_speed(struct interface *ifp)
 483 {
 484         return ifp->speed;
 485 }
 486
 487 #endif /* !HAVE_NETLINK */