release/src/router/zebra/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
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20  * 02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "if.h"
  26 #include "prefix.h"
  27 #include "sockunion.h"
  28 #include "log.h"
  29 #include "str.h"
  30
  31 #include "zebra/debug.h"
  32 #include "zebra/rib.h"
  33
  34 int
  35 rtm_write (int message,
  36            union sockunion *dest,
  37            union sockunion *mask,
  38            union sockunion *gate,
  39            unsigned int index,
  40            int zebra_flags,
  41            int metric);
  42
  43 /* Adjust netmask socket length. Return value is a adjusted sin_len
  44    value. */
  45 int
  46 sin_masklen (struct in_addr mask)
  47 {
  48   char *p, *lim;
  49   int len;
  50   struct sockaddr_in sin;
  51
  52   if (mask.s_addr == 0)
  53     return sizeof (long);
  54
  55   sin.sin_addr = mask;
  56   len = sizeof (struct sockaddr_in);
  57
  58   lim = (char *) &sin.sin_addr;
  59   p = lim + sizeof (sin.sin_addr);
  60
  61   while (*--p == 0 && p >= lim)
  62     len--;
  63   return len;
  64 }
  65
  66 /* Interface between zebra message and rtm message. */
  67 int
  68 kernel_rtm_ipv4 (int cmd, struct prefix *p, struct rib *rib, int family)
  69 {
  70   struct sockaddr_in *mask = NULL;
  71   struct sockaddr_in sin_dest, sin_mask, sin_gate;
  72   struct nexthop *nexthop;
  73   int nexthop_num = 0;
  74   unsigned int ifindex = 0;
  75   int gate = 0;
  76   int error;
  77
  78   memset (&sin_dest, 0, sizeof (struct sockaddr_in));
  79   sin_dest.sin_family = AF_INET;
  80 #ifdef HAVE_SIN_LEN
  81   sin_dest.sin_len = sizeof (struct sockaddr_in);
  82 #endif /* HAVE_SIN_LEN */
  83   sin_dest.sin_addr = p->u.prefix4;
  84
  85   memset (&sin_mask, 0, sizeof (struct sockaddr_in));
  86
  87   memset (&sin_gate, 0, sizeof (struct sockaddr_in));
  88   sin_gate.sin_family = AF_INET;
  89 #ifdef HAVE_SIN_LEN
  90   sin_gate.sin_len = sizeof (struct sockaddr_in);
  91 #endif /* HAVE_SIN_LEN */
  92
  93   /* Make gateway. */
  94   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
  95     {
  96       gate = 0;
  97
  98       if ((cmd == RTM_ADD
  99            && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 100           || (cmd == RTM_DELETE
 101 #if 0
 102               && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)
 103 #endif
 104               ))
 105         {
 106           if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 107             {
 108               if (nexthop->rtype == NEXTHOP_TYPE_IPV4 ||
 109                   nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX)
 110                 {
 111                   sin_gate.sin_addr = nexthop->rgate.ipv4;
 112                   gate = 1;
 113                 }
 114               if (nexthop->rtype == NEXTHOP_TYPE_IFINDEX
 115                   || nexthop->rtype == NEXTHOP_TYPE_IFNAME
 116                   || nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX)
 117                 ifindex = nexthop->rifindex;
 118             }
 119           else
 120             {
 121               if (nexthop->type == NEXTHOP_TYPE_IPV4 ||
 122                   nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 123                 {
 124                   sin_gate.sin_addr = nexthop->gate.ipv4;
 125                   gate = 1;
 126                 }
 127               if (nexthop->type == NEXTHOP_TYPE_IFINDEX
 128                   || nexthop->type == NEXTHOP_TYPE_IFNAME
 129                   || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 130                 ifindex = nexthop->ifindex;
 131               if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE)
 132                 {
 133                   struct in_addr loopback;
 134
 135                   loopback.s_addr = htonl (INADDR_LOOPBACK);
 136                   sin_gate.sin_addr = loopback;
 137                   gate = 1;
 138                 }
 139             }
 140
 141           if (cmd == RTM_ADD)
 142             SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
 143
 144           if (gate && p->prefixlen == 32)
 145             mask = NULL;
 146           else
 147             {
 148               masklen2ip (p->prefixlen, &sin_mask.sin_addr);
 149               sin_mask.sin_family = AF_UNSPEC;
 150 #ifdef HAVE_SIN_LEN
 151               sin_mask.sin_len = sin_masklen (sin_mask.sin_addr);
 152 #endif /* HAVE_SIN_LEN */
 153               mask = &sin_mask;
 154             }
 155         }
 156
 157       error = rtm_write (cmd,
 158                         (union sockunion *)&sin_dest,
 159                         (union sockunion *)mask,
 160                         gate ? (union sockunion *)&sin_gate : NULL,
 161                         ifindex,
 162                         rib->flags,
 163                         rib->metric);
 164
 165 #if 0
 166       if (error)
 167         {
 168           zlog_info ("kernel_rtm_ipv4(): nexthop %d add error=%d.",
 169             nexthop_num, error);
 170         }
 171 #endif
 172
 173       nexthop_num++;
 174     }
 175
 176   /* If there is no useful nexthop then return. */
 177   if (nexthop_num == 0)
 178     {
 179       if (IS_ZEBRA_DEBUG_KERNEL)
 180         zlog_info ("kernel_rtm_ipv4(): No useful nexthop.");
 181       return 0;
 182     }
 183
 184   return 0; /*XXX*/
 185 }
 186
 187 int
 188 kernel_add_ipv4 (struct prefix *p, struct rib *rib)
 189 {
 190   return kernel_rtm_ipv4 (RTM_ADD, p, rib, AF_INET);
 191 }
 192
 193 int
 194 kernel_delete_ipv4 (struct prefix *p, struct rib *rib)
 195 {
 196   return kernel_rtm_ipv4 (RTM_DELETE, p, rib, AF_INET);
 197 }
 198
 199 #ifdef HAVE_IPV6
 200
 201 /* Calculate sin6_len value for netmask socket value. */
 202 int
 203 sin6_masklen (struct in6_addr mask)
 204 {
 205   struct sockaddr_in6 sin6;
 206   char *p, *lim;
 207   int len;
 208
 209 #if defined (INRIA)
 210   if (IN_ANYADDR6 (mask))
 211     return sizeof (long);
 212 #else /* ! INRIA */
 213   if (IN6_IS_ADDR_UNSPECIFIED (&mask))
 214     return sizeof (long);
 215 #endif /* ! INRIA */
 216
 217   sin6.sin6_addr = mask;
 218   len = sizeof (struct sockaddr_in6);
 219
 220   lim = (char *) & sin6.sin6_addr;
 221   p = lim + sizeof (sin6.sin6_addr);
 222
 223   while (*--p == 0 && p >= lim)
 224     len--;
 225
 226   return len;
 227 }
 228
 229 /* Interface between zebra message and rtm message. */
 230 int
 231 kernel_rtm_ipv6 (int message, struct prefix_ipv6 *dest,
 232                  struct in6_addr *gate, int index, int flags)
 233 {
 234   struct sockaddr_in6 *mask;
 235   struct sockaddr_in6 sin_dest, sin_mask, sin_gate;
 236
 237   memset (&sin_dest, 0, sizeof (struct sockaddr_in6));
 238   sin_dest.sin6_family = AF_INET6;
 239 #ifdef SIN6_LEN
 240   sin_dest.sin6_len = sizeof (struct sockaddr_in6);
 241 #endif /* SIN6_LEN */
 242
 243   memset (&sin_mask, 0, sizeof (struct sockaddr_in6));
 244
 245   memset (&sin_gate, 0, sizeof (struct sockaddr_in6));
 246   sin_gate.sin6_family = AF_INET6;
 247 #ifdef SIN6_LEN
 248   sin_gate.sin6_len = sizeof (struct sockaddr_in6);
 249 #endif /* SIN6_LEN */
 250
 251   sin_dest.sin6_addr = dest->prefix;
 252
 253   if (gate)
 254     memcpy (&sin_gate.sin6_addr, gate, sizeof (struct in6_addr));
 255
 256   /* Under kame set interface index to link local address. */
 257 #ifdef KAME
 258
 259 #define SET_IN6_LINKLOCAL_IFINDEX(a, i) \
 260   do { \
 261     (a).s6_addr[2] = ((i) >> 8) & 0xff; \
 262     (a).s6_addr[3] = (i) & 0xff; \
 263   } while (0)
 264
 265   if (gate && IN6_IS_ADDR_LINKLOCAL(gate))
 266     SET_IN6_LINKLOCAL_IFINDEX (sin_gate.sin6_addr, index);
 267 #endif /* KAME */
 268
 269   if (gate && dest->prefixlen == 128)
 270     mask = NULL;
 271   else
 272     {
 273       masklen2ip6 (dest->prefixlen, &sin_mask.sin6_addr);
 274       sin_mask.sin6_family = AF_UNSPEC;
 275 #ifdef SIN6_LEN
 276       sin_mask.sin6_len = sin6_masklen (sin_mask.sin6_addr);
 277 #endif /* SIN6_LEN */
 278       mask = &sin_mask;
 279     }
 280
 281   return rtm_write (message,
 282                     (union sockunion *) &sin_dest,
 283                     (union sockunion *) mask,
 284                     gate ? (union sockunion *)&sin_gate : NULL,
 285                     index,
 286                     flags,
 287                     0);
 288 }
 289
 290 /* Interface between zebra message and rtm message. */
 291 int
 292 kernel_rtm_ipv6_multipath (int cmd, struct prefix *p, struct rib *rib,
 293                            int family)
 294 {
 295   struct sockaddr_in6 *mask;
 296   struct sockaddr_in6 sin_dest, sin_mask, sin_gate;
 297   struct nexthop *nexthop;
 298   int nexthop_num = 0;
 299   unsigned int ifindex = 0;
 300   int gate = 0;
 301   int error;
 302
 303   memset (&sin_dest, 0, sizeof (struct sockaddr_in6));
 304   sin_dest.sin6_family = AF_INET6;
 305 #ifdef SIN6_LEN
 306   sin_dest.sin6_len = sizeof (struct sockaddr_in6);
 307 #endif /* SIN6_LEN */
 308   sin_dest.sin6_addr = p->u.prefix6;
 309
 310   memset (&sin_mask, 0, sizeof (struct sockaddr_in6));
 311
 312   memset (&sin_gate, 0, sizeof (struct sockaddr_in6));
 313   sin_gate.sin6_family = AF_INET6;
 314 #ifdef HAVE_SIN_LEN
 315   sin_gate.sin6_len = sizeof (struct sockaddr_in6);
 316 #endif /* HAVE_SIN_LEN */
 317
 318   /* Make gateway. */
 319   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 320     {
 321       gate = 0;
 322
 323       if ((cmd == RTM_ADD
 324            && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 325           || (cmd == RTM_DELETE
 326 #if 0
 327               && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)
 328 #endif
 329               ))
 330         {
 331           if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 332             {
 333               if (nexthop->rtype == NEXTHOP_TYPE_IPV6
 334                   || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME
 335                   || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX)
 336                 {
 337                   sin_gate.sin6_addr = nexthop->rgate.ipv6;
 338                   gate = 1;
 339                 }
 340               if (nexthop->rtype == NEXTHOP_TYPE_IFINDEX
 341                   || nexthop->rtype == NEXTHOP_TYPE_IFNAME
 342                   || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME
 343                   || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX)
 344                 ifindex = nexthop->rifindex;
 345             }
 346           else
 347             {
 348               if (nexthop->type == NEXTHOP_TYPE_IPV6
 349                   || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
 350                   || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
 351                 {
 352                   sin_gate.sin6_addr = nexthop->gate.ipv6;
 353                   gate = 1;
 354                 }
 355               if (nexthop->type == NEXTHOP_TYPE_IFINDEX
 356                   || nexthop->type == NEXTHOP_TYPE_IFNAME
 357                   || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
 358                   || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
 359                 ifindex = nexthop->ifindex;
 360               if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE)
 361                 {
 362 #ifdef HAVE_IN6ADDR_GLOBAL
 363                   sin_gate.sin6_addr = in6addr_loopback;
 364 #else /*HAVE_IN6ADDR_GLOBAL*/
 365                   inet_pton (AF_INET6, "::1", &sin_gate.sin6_addr);
 366 #endif /*HAVE_IN6ADDR_GLOBAL*/
 367                   gate = 1;
 368                 }
 369             }
 370
 371           if (cmd == RTM_ADD)
 372             SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
 373         }
 374
 375       /* Under kame set interface index to link local address. */
 376 #ifdef KAME
 377
 378 #define SET_IN6_LINKLOCAL_IFINDEX(a, i) \
 379       do { \
 380         (a).s6_addr[2] = ((i) >> 8) & 0xff; \
 381         (a).s6_addr[3] = (i) & 0xff; \
 382       } while (0)
 383
 384       if (gate && IN6_IS_ADDR_LINKLOCAL(&sin_gate.sin6_addr))
 385         SET_IN6_LINKLOCAL_IFINDEX (sin_gate.sin6_addr, ifindex);
 386 #endif /* KAME */
 387
 388       if (gate && p->prefixlen == 128)
 389         mask = NULL;
 390       else
 391         {
 392           masklen2ip6 (p->prefixlen, &sin_mask.sin6_addr);
 393           sin_mask.sin6_family = AF_UNSPEC;
 394 #ifdef SIN6_LEN
 395           sin_mask.sin6_len = sin6_masklen (sin_mask.sin6_addr);
 396 #endif /* SIN6_LEN */
 397           mask = &sin_mask;
 398         }
 399
 400       error = rtm_write (cmd,
 401                         (union sockunion *) &sin_dest,
 402                         (union sockunion *) mask,
 403                         gate ? (union sockunion *)&sin_gate : NULL,
 404                         ifindex,
 405                         rib->flags,
 406                         rib->metric);
 407
 408 #if 0
 409       if (error)
 410         {
 411           zlog_info ("kernel_rtm_ipv6_multipath(): nexthop %d add error=%d.",
 412             nexthop_num, error);
 413         }
 414 #endif
 415
 416       nexthop_num++;
 417     }
 418
 419   /* If there is no useful nexthop then return. */
 420   if (nexthop_num == 0)
 421     {
 422       if (IS_ZEBRA_DEBUG_KERNEL)
 423         zlog_info ("kernel_rtm_ipv6_multipath(): No useful nexthop.");
 424       return 0;
 425     }
 426
 427   return 0; /*XXX*/
 428 }
 429
 430 int
 431 kernel_add_ipv6 (struct prefix *p, struct rib *rib)
 432 {
 433   return kernel_rtm_ipv6_multipath (RTM_ADD, p, rib, AF_INET6);
 434 }
 435
 436 int
 437 kernel_delete_ipv6 (struct prefix *p, struct rib *rib)
 438 {
 439   return kernel_rtm_ipv6_multipath (RTM_DELETE, p, rib, AF_INET6);
 440 }
 441
 442 /* Delete IPv6 route from the kernel. */
 443 int
 444 kernel_delete_ipv6_old (struct prefix_ipv6 *dest, struct in6_addr *gate,
 445                     int index, int flags, int table)
 446 {
 447   return kernel_rtm_ipv6 (RTM_DELETE, dest, gate, index, flags);
 448 }
 449 #endif /* HAVE_IPV6 */