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 #ifdef __OpenBSD__
  24 #include <netmpls/mpls.h>
  25 #endif
  26
  27 #include "if.h"
  28 #include "prefix.h"
  29 #include "sockunion.h"
  30 #include "log.h"
  31 #include "privs.h"
  32
  33 #include "zebra/debug.h"
  34 #include "zebra/rib.h"
  35 #include "zebra/rt.h"
  36 #include "zebra/kernel_socket.h"
  37 #include "zebra/zebra_mpls.h"
  38
  39 extern struct zebra_privs_t zserv_privs;
  40
  41 /* kernel socket export */
  42 extern int rtm_write (int message, union sockunion *dest,
  43                       union sockunion *mask, union sockunion *gate,
  44                       union sockunion *mpls, unsigned int index,
  45                       int zebra_flags, int metric);
  46
  47 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
  48 /* Adjust netmask socket length. Return value is a adjusted sin_len
  49    value. */
  50 static int
  51 sin_masklen (struct in_addr mask)
  52 {
  53   char *p, *lim;
  54   int len;
  55   struct sockaddr_in sin;
  56
  57   if (mask.s_addr == 0)
  58     return sizeof (long);
  59
  60   sin.sin_addr = mask;
  61   len = sizeof (struct sockaddr_in);
  62
  63   lim = (char *) &sin.sin_addr;
  64   p = lim + sizeof (sin.sin_addr);
  65
  66   while (*--p == 0 && p >= lim)
  67     len--;
  68   return len;
  69 }
  70 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
  71
  72 /* Interface between zebra message and rtm message. */
  73 static int
  74 kernel_rtm_ipv4 (int cmd, struct prefix *p, struct route_entry *re)
  75
  76 {
  77   struct sockaddr_in *mask = NULL;
  78   struct sockaddr_in sin_dest, sin_mask, sin_gate;
  79 #ifdef __OpenBSD__
  80   struct sockaddr_mpls smpls;
  81 #endif
  82   union sockunion *smplsp = NULL;
  83   struct nexthop *nexthop, *tnexthop;
  84   int recursing;
  85   int nexthop_num = 0;
  86   ifindex_t ifindex = 0;
  87   int gate = 0;
  88   int error;
  89   char prefix_buf[PREFIX_STRLEN];
  90
  91   if (IS_ZEBRA_DEBUG_RIB)
  92     prefix2str (p, prefix_buf, sizeof(prefix_buf));
  93   memset (&sin_dest, 0, sizeof (struct sockaddr_in));
  94   sin_dest.sin_family = AF_INET;
  95 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
  96   sin_dest.sin_len = sizeof (struct sockaddr_in);
  97 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
  98   sin_dest.sin_addr = p->u.prefix4;
  99
 100   memset (&sin_mask, 0, sizeof (struct sockaddr_in));
 101
 102   memset (&sin_gate, 0, sizeof (struct sockaddr_in));
 103   sin_gate.sin_family = AF_INET;
 104 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 105   sin_gate.sin_len = sizeof (struct sockaddr_in);
 106 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 107
 108   /* Make gateway. */
 109   for (ALL_NEXTHOPS_RO(re->nexthop, nexthop, tnexthop, recursing))
 110     {
 111       if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 112         continue;
 113
 114       gate = 0;
 115       char gate_buf[INET_ADDRSTRLEN] = "NULL";
 116
 117       /*
 118        * XXX We need to refrain from kernel operations in some cases,
 119        * but this if statement seems overly cautious - what about
 120        * other than ADD and DELETE?
 121        */
 122       if ((cmd == RTM_ADD
 123            && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 124           || (cmd == RTM_DELETE
 125               && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)
 126               ))
 127         {
 128           if (nexthop->type == NEXTHOP_TYPE_IPV4 ||
 129               nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 130             {
 131               sin_gate.sin_addr = nexthop->gate.ipv4;
 132               gate = 1;
 133             }
 134           if (nexthop->type == NEXTHOP_TYPE_IFINDEX
 135               || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 136             ifindex = nexthop->ifindex;
 137           if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE)
 138             {
 139               struct in_addr loopback;
 140               loopback.s_addr = htonl (INADDR_LOOPBACK);
 141               sin_gate.sin_addr = loopback;
 142               gate = 1;
 143             }
 144
 145           if (gate && p->prefixlen == 32)
 146             mask = NULL;
 147           else
 148             {
 149               masklen2ip (p->prefixlen, &sin_mask.sin_addr);
 150               sin_mask.sin_family = AF_INET;
 151 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 152               sin_mask.sin_len = sin_masklen (sin_mask.sin_addr);
 153 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 154               mask = &sin_mask;
 155             }
 156
 157 #ifdef __OpenBSD__
 158           if (nexthop->nh_label)
 159             {
 160               memset (&smpls, 0, sizeof (smpls));
 161               smpls.smpls_len = sizeof (smpls);
 162               smpls.smpls_family = AF_MPLS;
 163               smpls.smpls_label =
 164                 htonl (nexthop->nh_label->label[0] << MPLS_LABEL_OFFSET);
 165               smplsp = (union sockunion *)&smpls;
 166             }
 167 #endif
 168
 169           error = rtm_write (cmd,
 170                              (union sockunion *)&sin_dest,
 171                              (union sockunion *)mask,
 172                              gate ? (union sockunion *)&sin_gate : NULL,
 173                              smplsp,
 174                              ifindex,
 175                              re->flags,
 176                              re->metric);
 177
 178            if (IS_ZEBRA_DEBUG_RIB)
 179            {
 180              if (!gate)
 181              {
 182                zlog_debug ("%s: %s: attention! gate not found for re %p",
 183                  __func__, prefix_buf, re);
 184                route_entry_dump (p, NULL, re);
 185              }
 186              else
 187                inet_ntop (AF_INET, &sin_gate.sin_addr, gate_buf, INET_ADDRSTRLEN);
 188            }
 189
 190            switch (error)
 191            {
 192              /* We only flag nexthops as being in FIB if rtm_write() did its work. */
 193              case ZEBRA_ERR_NOERROR:
 194                nexthop_num++;
 195                if (IS_ZEBRA_DEBUG_RIB)
 196                  zlog_debug ("%s: %s: successfully did NH %s",
 197                    __func__, prefix_buf, gate_buf);
 198                if (cmd == RTM_ADD)
 199                  SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
 200                break;
 201
 202              /* The only valid case for this error is kernel's failure to install
 203               * a multipath route, which is common for FreeBSD. This should be
 204               * ignored silently, but logged as an error otherwise.
 205               */
 206              case ZEBRA_ERR_RTEXIST:
 207                if (cmd != RTM_ADD)
 208                  zlog_err ("%s: rtm_write() returned %d for command %d",
 209                    __func__, error, cmd);
 210                continue;
 211                break;
 212
 213              /* Given that our NEXTHOP_FLAG_FIB matches real kernel FIB, it isn't
 214               * normal to get any other messages in ANY case.
 215               */
 216              case ZEBRA_ERR_RTNOEXIST:
 217              case ZEBRA_ERR_RTUNREACH:
 218              default:
 219                zlog_err ("%s: %s: rtm_write() unexpectedly returned %d for command %s",
 220                  __func__, prefix2str(p, prefix_buf, sizeof(prefix_buf)),
 221                  error, lookup_msg(rtm_type_str, cmd, NULL));
 222                break;
 223            }
 224          } /* if (cmd and flags make sense) */
 225        else
 226          if (IS_ZEBRA_DEBUG_RIB)
 227            zlog_debug ("%s: odd command %s for flags %d",
 228              __func__, lookup_msg(rtm_type_str, cmd, NULL), nexthop->flags);
 229      } /* for (ALL_NEXTHOPS_RO(...))*/
 230
 231    /* If there was no useful nexthop, then complain. */
 232    if (nexthop_num == 0 && IS_ZEBRA_DEBUG_KERNEL)
 233      zlog_debug ("%s: No useful nexthops were found in RIB entry %p", __func__, re);
 234
 235   return 0; /*XXX*/
 236 }
 237
 238 #ifdef SIN6_LEN
 239 /* Calculate sin6_len value for netmask socket value. */
 240 static int
 241 sin6_masklen (struct in6_addr mask)
 242 {
 243   struct sockaddr_in6 sin6;
 244   char *p, *lim;
 245   int len;
 246
 247   if (IN6_IS_ADDR_UNSPECIFIED (&mask))
 248     return sizeof (long);
 249
 250   sin6.sin6_addr = mask;
 251   len = sizeof (struct sockaddr_in6);
 252
 253   lim = (char *) & sin6.sin6_addr;
 254   p = lim + sizeof (sin6.sin6_addr);
 255
 256   while (*--p == 0 && p >= lim)
 257     len--;
 258
 259   return len;
 260 }
 261 #endif /* SIN6_LEN */
 262
 263 /* Interface between zebra message and rtm message. */
 264 static int
 265 kernel_rtm_ipv6 (int cmd, struct prefix *p, struct route_entry *re)
 266 {
 267   struct sockaddr_in6 *mask;
 268   struct sockaddr_in6 sin_dest, sin_mask, sin_gate;
 269   struct nexthop *nexthop, *tnexthop;
 270   int recursing;
 271   int nexthop_num = 0;
 272   ifindex_t ifindex = 0;
 273   int gate = 0;
 274   int error;
 275
 276   memset (&sin_dest, 0, sizeof (struct sockaddr_in6));
 277   sin_dest.sin6_family = AF_INET6;
 278 #ifdef SIN6_LEN
 279   sin_dest.sin6_len = sizeof (struct sockaddr_in6);
 280 #endif /* SIN6_LEN */
 281   sin_dest.sin6_addr = p->u.prefix6;
 282
 283   memset (&sin_mask, 0, sizeof (struct sockaddr_in6));
 284
 285   memset (&sin_gate, 0, sizeof (struct sockaddr_in6));
 286   sin_gate.sin6_family = AF_INET6;
 287 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 288   sin_gate.sin6_len = sizeof (struct sockaddr_in6);
 289 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 290
 291   /* Make gateway. */
 292   for (ALL_NEXTHOPS_RO(re->nexthop, nexthop, tnexthop, recursing))
 293     {
 294       if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 295         continue;
 296
 297       gate = 0;
 298
 299       if ((cmd == RTM_ADD
 300            && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 301           || (cmd == RTM_DELETE
 302 #if 0
 303               && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)
 304 #endif
 305               ))
 306         {
 307           if (nexthop->type == NEXTHOP_TYPE_IPV6
 308               || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
 309             {
 310               sin_gate.sin6_addr = nexthop->gate.ipv6;
 311               gate = 1;
 312             }
 313           if (nexthop->type == NEXTHOP_TYPE_IFINDEX
 314               || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
 315             ifindex = nexthop->ifindex;
 316
 317           if (cmd == RTM_ADD)
 318             SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
 319         }
 320
 321       /* Under kame set interface index to link local address. */
 322 #ifdef KAME
 323
 324 #define SET_IN6_LINKLOCAL_IFINDEX(a, i) \
 325       do { \
 326         (a).s6_addr[2] = ((i) >> 8) & 0xff; \
 327         (a).s6_addr[3] = (i) & 0xff; \
 328       } while (0)
 329
 330       if (gate && IN6_IS_ADDR_LINKLOCAL(&sin_gate.sin6_addr))
 331         SET_IN6_LINKLOCAL_IFINDEX (sin_gate.sin6_addr, ifindex);
 332 #endif /* KAME */
 333
 334       if (gate && p->prefixlen == 128)
 335         mask = NULL;
 336       else
 337         {
 338           masklen2ip6 (p->prefixlen, &sin_mask.sin6_addr);
 339           sin_mask.sin6_family = AF_INET6;
 340 #ifdef SIN6_LEN
 341           sin_mask.sin6_len = sin6_masklen (sin_mask.sin6_addr);
 342 #endif /* SIN6_LEN */
 343           mask = &sin_mask;
 344         }
 345
 346       error = rtm_write (cmd,
 347                         (union sockunion *) &sin_dest,
 348                         (union sockunion *) mask,
 349                         gate ? (union sockunion *)&sin_gate : NULL,
 350                         NULL,
 351                         ifindex,
 352                         re->flags,
 353                         re->metric);
 354
 355 #if 0
 356       if (error)
 357         {
 358           zlog_info ("kernel_rtm_ipv6(): nexthop %d add error=%d.",
 359             nexthop_num, error);
 360         }
 361 #else
 362       (void)error;
 363 #endif
 364
 365       nexthop_num++;
 366     }
 367
 368   /* If there is no useful nexthop then return. */
 369   if (nexthop_num == 0)
 370     {
 371       if (IS_ZEBRA_DEBUG_KERNEL)
 372         zlog_debug ("kernel_rtm_ipv6(): No useful nexthop.");
 373       return 0;
 374     }
 375
 376   return 0; /*XXX*/
 377 }
 378
 379 static int
 380 kernel_rtm (int cmd, struct prefix *p, struct route_entry *re)
 381 {
 382   switch (PREFIX_FAMILY(p))
 383     {
 384     case AF_INET:
 385       return kernel_rtm_ipv4 (cmd, p, re);
 386     case AF_INET6:
 387       return kernel_rtm_ipv6 (cmd, p, re);
 388     }
 389   return 0;
 390 }
 391
 392 int
 393 kernel_route_rib (struct prefix *p, struct prefix *src_p,
 394                   struct route_entry *old, struct route_entry *new)
 395 {
 396   int route = 0;
 397
 398   if (src_p && src_p->prefixlen)
 399     {
 400       zlog_err ("route add: IPv6 sourcedest routes unsupported!");
 401       return 1;
 402     }
 403
 404   if (zserv_privs.change(ZPRIVS_RAISE))
 405     zlog_err("Can't raise privileges");
 406
 407   if (old)
 408     route |= kernel_rtm (RTM_DELETE, p, old);
 409
 410   if (new)
 411     route |= kernel_rtm (RTM_ADD, p, new);
 412
 413   if (zserv_privs.change(ZPRIVS_LOWER))
 414     zlog_err("Can't lower privileges");
 415
 416   return route;
 417 }
 418
 419 int
 420 kernel_neigh_update (int add, int ifindex, uint32_t addr, char *lla, int llalen)
 421 {
 422   /* TODO */
 423   return 0;
 424 }
 425
 426 extern int
 427 kernel_get_ipmr_sg_stats (void *mroute)
 428 {
 429   return 0;
 430 }