zebra/kernel_socket.c

   1 /* Kernel communication using routing socket.
   2  * Copyright (C) 1999 Kunihiro Ishiguro
   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
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "if.h"
  25 #include "prefix.h"
  26 #include "sockunion.h"
  27 #include "connected.h"
  28 #include "memory.h"
  29 #include "ioctl.h"
  30 #include "log.h"
  31 #include "str.h"
  32 #include "table.h"
  33 #include "rib.h"
  34 #include "privs.h"
  35
  36 #include "zebra/interface.h"
  37 #include "zebra/zserv.h"
  38 #include "zebra/debug.h"
  39
  40 extern struct zebra_privs_t zserv_privs;
  41 extern struct zebra_t zebrad;
  42
  43 /*
  44  * Given a sockaddr length, round it up to include pad bytes following
  45  * it.  Assumes the kernel pads to sizeof(long).
  46  *
  47  * XXX: why is ROUNDUP(0) sizeof(long)?  0 is an illegal sockaddr
  48  * length anyway (< sizeof (struct sockaddr)), so this shouldn't
  49  * matter.
  50  */
  51 #define ROUNDUP(a) \
  52   ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
  53
  54 /*
  55  * Given a pointer (sockaddr or void *), return the number of bytes
  56  * taken up by the sockaddr and any padding needed for alignment.
  57  */
  58 #if defined(HAVE_SA_LEN)
  59 #define SAROUNDUP(X)   ROUNDUP(((struct sockaddr *)(X))->sa_len)
  60 #elif defined(HAVE_IPV6)
  61 /*
  62  * One would hope all fixed-size structure definitions are aligned,
  63  * but round them up nonetheless.
  64  */
  65 #define SAROUNDUP(X) \
  66     (((struct sockaddr *)(X))->sa_family == AF_INET ?   \
  67       ROUNDUP(sizeof(struct sockaddr_in)):\
  68       (((struct sockaddr *)(X))->sa_family == AF_INET6 ? \
  69        ROUNDUP(sizeof(struct sockaddr_in6)) :  \
  70        (((struct sockaddr *)(X))->sa_family == AF_LINK ? \
  71          ROUNDUP(sizeof(struct sockaddr_dl)) : sizeof(struct sockaddr))))
  72 #else /* HAVE_IPV6 */
  73 #define SAROUNDUP(X) \
  74       (((struct sockaddr *)(X))->sa_family == AF_INET ?   \
  75         ROUNDUP(sizeof(struct sockaddr_in)):\
  76          (((struct sockaddr *)(X))->sa_family == AF_LINK ? \
  77            ROUNDUP(sizeof(struct sockaddr_dl)) : sizeof(struct sockaddr)))
  78 #endif /* HAVE_SA_LEN */
  79
  80 #define RTA_ADDR_GET(DEST, RTA, RTMADDRS, PNT) \
  81   if ((RTMADDRS) & (RTA)) \
  82     { \
  83       int len = SAROUNDUP ((PNT)); \
  84       if ( ((DEST) != NULL) && \
  85            af_check (((struct sockaddr *)(PNT))->sa_family)) \
  86         memcpy ((caddr_t)(DEST), (PNT), len); \
  87       (PNT) += len; \
  88     }
  89 #define RTA_ATTR_GET(DEST, RTA, RTMADDRS, PNT) \
  90   if ((RTMADDRS) & (RTA)) \
  91     { \
  92       int len = SAROUNDUP ((PNT)); \
  93       if ( ((DEST) != NULL) ) \
  94         memcpy ((caddr_t)(DEST), (PNT), len); \
  95       (PNT) += len; \
  96     }
  97
  98 /* Routing socket message types. */
  99 struct message rtm_type_str[] =
 100 {
 101   {RTM_ADD,      "RTM_ADD"},
 102   {RTM_DELETE,   "RTM_DELETE"},
 103   {RTM_CHANGE,   "RTM_CHANGE"},
 104   {RTM_GET,      "RTM_GET"},
 105   {RTM_LOSING,   "RTM_LOSING"},
 106   {RTM_REDIRECT, "RTM_REDIRECT"},
 107   {RTM_MISS,     "RTM_MISS"},
 108   {RTM_LOCK,     "RTM_LOCK"},
 109   {RTM_OLDADD,   "RTM_OLDADD"},
 110   {RTM_OLDDEL,   "RTM_OLDDEL"},
 111   {RTM_RESOLVE,  "RTM_RESOLVE"},
 112   {RTM_NEWADDR,  "RTM_NEWADDR"},
 113   {RTM_DELADDR,  "RTM_DELADDR"},
 114   {RTM_IFINFO,   "RTM_IFINFO"},
 115 #ifdef RTM_OIFINFO
 116   {RTM_OIFINFO,   "RTM_OIFINFO"},
 117 #endif /* RTM_OIFINFO */
 118 #ifdef RTM_NEWMADDR
 119   {RTM_NEWMADDR, "RTM_NEWMADDR"},
 120 #endif /* RTM_NEWMADDR */
 121 #ifdef RTM_DELMADDR
 122   {RTM_DELMADDR, "RTM_DELMADDR"},
 123 #endif /* RTM_DELMADDR */
 124 #ifdef RTM_IFANNOUNCE
 125   {RTM_IFANNOUNCE, "RTM_IFANNOUNCE"},
 126 #endif /* RTM_IFANNOUNCE */
 127   {0,            NULL}
 128 };
 129
 130 struct message rtm_flag_str[] =
 131 {
 132   {RTF_UP,        "UP"},
 133   {RTF_GATEWAY,   "GATEWAY"},
 134   {RTF_HOST,      "HOST"},
 135   {RTF_REJECT,    "REJECT"},
 136   {RTF_DYNAMIC,   "DYNAMIC"},
 137   {RTF_MODIFIED,  "MODIFIED"},
 138   {RTF_DONE,      "DONE"},
 139 #ifdef RTF_MASK
 140   {RTF_MASK,      "MASK"},
 141 #endif /* RTF_MASK */
 142   {RTF_CLONING,   "CLONING"},
 143   {RTF_XRESOLVE,  "XRESOLVE"},
 144   {RTF_LLINFO,    "LLINFO"},
 145   {RTF_STATIC,    "STATIC"},
 146   {RTF_BLACKHOLE, "BLACKHOLE"},
 147   {RTF_PROTO1,    "PROTO1"},
 148   {RTF_PROTO2,    "PROTO2"},
 149 #ifdef RTF_PRCLONING
 150   {RTF_PRCLONING, "PRCLONING"},
 151 #endif /* RTF_PRCLONING */
 152 #ifdef RTF_WASCLONED
 153   {RTF_WASCLONED, "WASCLONED"},
 154 #endif /* RTF_WASCLONED */
 155 #ifdef RTF_PROTO3
 156   {RTF_PROTO3,    "PROTO3"},
 157 #endif /* RTF_PROTO3 */
 158 #ifdef RTF_PINNED
 159   {RTF_PINNED,    "PINNED"},
 160 #endif /* RTF_PINNED */
 161 #ifdef RTF_LOCAL
 162   {RTF_LOCAL,    "LOCAL"},
 163 #endif /* RTF_LOCAL */
 164 #ifdef RTF_BROADCAST
 165   {RTF_BROADCAST, "BROADCAST"},
 166 #endif /* RTF_BROADCAST */
 167 #ifdef RTF_MULTICAST
 168   {RTF_MULTICAST, "MULTICAST"},
 169 #endif /* RTF_MULTICAST */
 170   {0,             NULL}
 171 };
 172
 173 /* Kernel routing update socket. */
 174 int routing_sock = -1;
 175
 176 /* Yes I'm checking ugly routing socket behavior. */
 177 /* #define DEBUG */
 178
 179 /* Supported address family check. */
 180 static int inline
 181 af_check (int family)
 182 {
 183   if (family == AF_INET)
 184     return 1;
 185 #ifdef HAVE_IPV6
 186   if (family == AF_INET6)
 187     return 1;
 188 #endif /* HAVE_IPV6 */
 189   return 0;
 190 }
 191 \f
 192 /* Dump routing table flag for debug purpose. */
 193 static void
 194 rtm_flag_dump (int flag)
 195 {
 196   struct message *mes;
 197   static char buf[BUFSIZ];
 198
 199   buf[0] = '\0';
 200   for (mes = rtm_flag_str; mes->key != 0; mes++)
 201     {
 202       if (mes->key & flag)
 203         {
 204           strlcat (buf, mes->str, BUFSIZ);
 205           strlcat (buf, " ", BUFSIZ);
 206         }
 207     }
 208   zlog_debug ("Kernel: %s", buf);
 209 }
 210
 211 #ifdef RTM_IFANNOUNCE
 212 /* Interface adding function */
 213 int
 214 ifan_read (struct if_announcemsghdr *ifan)
 215 {
 216   struct interface *ifp;
 217
 218   ifp = if_lookup_by_index (ifan->ifan_index);
 219   if (ifp == NULL && ifan->ifan_what == IFAN_ARRIVAL)
 220     {
 221       /* Create Interface */
 222       ifp = if_get_by_name_len(ifan->ifan_name,
 223                                strnlen(ifan->ifan_name,
 224                                        sizeof(ifan->ifan_name)));
 225       ifp->ifindex = ifan->ifan_index;
 226
 227       if_add_update (ifp);
 228     }
 229   else if (ifp != NULL && ifan->ifan_what == IFAN_DEPARTURE)
 230     if_delete_update (ifp);
 231
 232   if_get_flags (ifp);
 233   if_get_mtu (ifp);
 234   if_get_metric (ifp);
 235
 236   if (IS_ZEBRA_DEBUG_KERNEL)
 237     zlog_debug ("interface %s index %d", ifp->name, ifp->ifindex);
 238
 239   return 0;
 240 }
 241 #endif /* RTM_IFANNOUNCE */
 242
 243 /*
 244  * Handle struct if_msghdr obtained from reading routing socket or
 245  * sysctl (from interface_list).  There may or may not be sockaddrs
 246  * present after the header.
 247  */
 248 int
 249 ifm_read (struct if_msghdr *ifm)
 250 {
 251   struct interface *ifp = NULL;
 252   struct sockaddr_dl *sdl = NULL;
 253   void *cp;
 254   unsigned int i;
 255
 256   /* paranoia: sanity check structure */
 257   if (ifm->ifm_msglen < sizeof(struct if_msghdr))
 258     {
 259       zlog_err ("ifm_read: ifm->ifm_msglen %d too short\n",
 260                 ifm->ifm_msglen);
 261       return -1;
 262     }
 263
 264   /*
 265    * Check for a sockaddr_dl following the message.  First, point to
 266    * where a socakddr might be if one follows the message.
 267    */
 268   cp = (void *)(ifm + 1);
 269
 270 #ifdef SUNOS_5
 271   /*
 272    * XXX This behavior should be narrowed to only the kernel versions
 273    * for which the structures returned do not match the headers.
 274    *
 275    * if_msghdr_t on 64 bit kernels in Solaris 9 and earlier versions
 276    * is 12 bytes larger than the 32 bit version.
 277    */
 278   if (((struct sockaddr *) cp)->sa_family == AF_UNSPEC)
 279         cp = cp + 12;
 280 #endif
 281
 282   /*
 283    * Check for each sockaddr in turn, advancing over it.  After this
 284    * loop, sdl should point to a sockaddr_dl iff one was present.
 285    */
 286   for (i = 1; i != 0; i <<= 1)
 287     {
 288       if (i & ifm->ifm_addrs)
 289         {
 290           if (i == RTA_IFP)
 291             {
 292               sdl = (struct sockaddr_dl *)cp;
 293               break;
 294             }
 295           /* XXX warning: pointer of type `void *' used in arithmetic */
 296           cp += SAROUNDUP(cp);
 297         }
 298     }
 299
 300   /* Ensure that sdl, if present, is actually a sockaddr_dl. */
 301   if (sdl != NULL && sdl->sdl_family != AF_LINK)
 302     {
 303       zlog_err ("ifm_read: sockaddr_dl bad AF %d\n",
 304                 sdl->sdl_family);
 305       return -1;
 306     }
 307
 308   /*
 309    * Look up on ifindex first, because ifindices are the primary
 310    * handle for interfaces across the user/kernel boundary.  (Some
 311    * messages, such as up/down status changes on NetBSD, do not
 312    * include a sockaddr_dl).
 313    */
 314   ifp = if_lookup_by_index (ifm->ifm_index);
 315
 316   /*
 317    * If lookup by index was unsuccessful and we have a name, try
 318    * looking up by name.  Interfaces specified in the configuration
 319    * file for which the ifindex has not been determined will have
 320    * ifindex == IFINDEX_INTERNAL, and such interfaces are found by this search,
 321    * and then their ifindex values can be filled in.
 322    */
 323   if (ifp == NULL && sdl != NULL)
 324     {
 325       /*
 326        * paranoia: sanity check name length.  nlen does not include
 327        * trailing zero, but IFNAMSIZ max length does.
 328        *
 329        * XXX Is this test correct?  Should it be '>=' or '>'?  And is it even
 330        * necessary now that we are using if_lookup_by_name_len?
 331        */
 332       if (sdl->sdl_nlen >= IFNAMSIZ)
 333         {
 334           zlog_err ("ifm_read: illegal sdl_nlen %d\n", sdl->sdl_nlen);
 335           return -1;
 336         }
 337
 338       ifp = if_lookup_by_name_len (sdl->sdl_data, sdl->sdl_nlen);
 339     }
 340
 341   /*
 342    * If ifp does not exist or has an invalid index (IFINDEX_INTERNAL), create or
 343    * fill in an interface.
 344    */
 345   if ((ifp == NULL) || (ifp->ifindex == IFINDEX_INTERNAL))
 346     {
 347       /*
 348        * To create or fill in an interface, a sockaddr_dl (via
 349        * RTA_IFP) is required.
 350        */
 351       if (sdl == NULL)
 352         {
 353           zlog_warn ("Interface index %d (new) missing RTA_IFP sockaddr_dl\n",
 354                      ifm->ifm_index);
 355           return -1;
 356         }
 357
 358       if (ifp == NULL)
 359         /* Interface that zebra was not previously aware of, so create. */
 360         ifp = if_create (sdl->sdl_data, sdl->sdl_nlen);
 361
 362       /*
 363        * Fill in newly created interface structure, or larval
 364        * structure with ifindex IFINDEX_INTERNAL.
 365        */
 366       ifp->ifindex = ifm->ifm_index;
 367       ifp->flags = ifm->ifm_flags;
 368 #if defined(__bsdi__)
 369       if_kvm_get_mtu (ifp);
 370 #else
 371       if_get_mtu (ifp);
 372 #endif /* __bsdi__ */
 373       if_get_metric (ifp);
 374
 375       /*
 376        * XXX sockaddr_dl contents can be larger than the structure
 377        * definition, so the user of the stored structure must be
 378        * careful not to read off the end.
 379        */
 380       memcpy (&ifp->sdl, sdl, sizeof (struct sockaddr_dl));
 381
 382       if_add_update (ifp);
 383     }
 384   else
 385     /*
 386      * Interface structure exists.  Adjust stored flags from
 387      * notification.  If interface has up->down or down->up
 388      * transition, call state change routines (to adjust routes,
 389      * notify routing daemons, etc.).  (Other flag changes are stored
 390      * but apparently do not trigger action.)
 391      */
 392     {
 393       if (if_is_up (ifp))
 394         {
 395           ifp->flags = ifm->ifm_flags;
 396           if (! if_is_up (ifp))
 397             {
 398               if_down (ifp);
 399 #ifndef RTM_IFANNOUNCE
 400               /* No RTM_IFANNOUNCE on this platform, so we can never
 401                * distinguish between down and delete. We must presume
 402                * it has been deleted.
 403                * Eg, Solaris will not notify us of unplumb.
 404                *
 405                * XXX: Fixme - this should be runtime detected
 406                * So that a binary compiled on a system with IFANNOUNCE
 407                * will still behave correctly if run on a platform without
 408                */
 409               if_delete_update (ifp);
 410 #endif /* RTM_IFANNOUNCE */
 411             }
 412         }
 413       else
 414         {
 415           ifp->flags = ifm->ifm_flags;
 416           if (if_is_up (ifp))
 417             if_up (ifp);
 418         }
 419     }
 420
 421 #ifdef HAVE_NET_RT_IFLIST
 422   ifp->stats = ifm->ifm_data;
 423 #endif /* HAVE_NET_RT_IFLIST */
 424
 425   if (IS_ZEBRA_DEBUG_KERNEL)
 426     zlog_debug ("interface %s index %d", ifp->name, ifp->ifindex);
 427
 428   return 0;
 429 }
 430 \f
 431 /* Address read from struct ifa_msghdr. */
 432 void
 433 ifam_read_mesg (struct ifa_msghdr *ifm,
 434                 union sockunion *addr,
 435                 union sockunion *mask,
 436                 union sockunion *dest)
 437 {
 438   caddr_t pnt, end;
 439
 440   pnt = (caddr_t)(ifm + 1);
 441   end = ((caddr_t)ifm) + ifm->ifam_msglen;
 442
 443   /* Be sure structure is cleared */
 444   memset (mask, 0, sizeof (union sockunion));
 445   memset (addr, 0, sizeof (union sockunion));
 446   memset (dest, 0, sizeof (union sockunion));
 447
 448   /* We fetch each socket variable into sockunion. */
 449   RTA_ADDR_GET (NULL, RTA_DST, ifm->ifam_addrs, pnt);
 450   RTA_ADDR_GET (NULL, RTA_GATEWAY, ifm->ifam_addrs, pnt);
 451   RTA_ATTR_GET (mask, RTA_NETMASK, ifm->ifam_addrs, pnt);
 452   RTA_ADDR_GET (NULL, RTA_GENMASK, ifm->ifam_addrs, pnt);
 453   RTA_ADDR_GET (NULL, RTA_IFP, ifm->ifam_addrs, pnt);
 454   RTA_ADDR_GET (addr, RTA_IFA, ifm->ifam_addrs, pnt);
 455   RTA_ADDR_GET (NULL, RTA_AUTHOR, ifm->ifam_addrs, pnt);
 456   RTA_ADDR_GET (dest, RTA_BRD, ifm->ifam_addrs, pnt);
 457
 458   /* Assert read up end point matches to end point */
 459   if (pnt != end)
 460     zlog_warn ("ifam_read() does't read all socket data");
 461 }
 462
 463 /* Interface's address information get. */
 464 int
 465 ifam_read (struct ifa_msghdr *ifam)
 466 {
 467   struct interface *ifp;
 468   union sockunion addr, mask, brd;
 469
 470   /* Check does this interface exist or not. */
 471   ifp = if_lookup_by_index (ifam->ifam_index);
 472   if (ifp == NULL)
 473     {
 474       zlog_warn ("no interface for index %d", ifam->ifam_index);
 475       return -1;
 476     }
 477
 478   /* Allocate and read address information. */
 479   ifam_read_mesg (ifam, &addr, &mask, &brd);
 480
 481   /* Check interface flag for implicit up of the interface. */
 482   if_refresh (ifp);
 483
 484   /* Add connected address. */
 485   switch (sockunion_family (&addr))
 486     {
 487     case AF_INET:
 488       if (ifam->ifam_type == RTM_NEWADDR)
 489         connected_add_ipv4 (ifp, 0, &addr.sin.sin_addr,
 490                             ip_masklen (mask.sin.sin_addr),
 491                             &brd.sin.sin_addr,
 492                             (isalias ? ifname : NULL) );
 493       else
 494         connected_delete_ipv4 (ifp, 0, &addr.sin.sin_addr,
 495                                ip_masklen (mask.sin.sin_addr),
 496                                &brd.sin.sin_addr);
 497       break;
 498 #ifdef HAVE_IPV6
 499     case AF_INET6:
 500       /* Unset interface index from link-local address when IPv6 stack
 501          is KAME. */
 502       if (IN6_IS_ADDR_LINKLOCAL (&addr.sin6.sin6_addr))
 503         SET_IN6_LINKLOCAL_IFINDEX (addr.sin6.sin6_addr, 0);
 504
 505       if (ifam->ifam_type == RTM_NEWADDR)
 506         connected_add_ipv6 (ifp,
 507                             &addr.sin6.sin6_addr,
 508                             ip6_masklen (mask.sin6.sin6_addr),
 509                             &brd.sin6.sin6_addr,
 510                             (isalias ? ifname : NULL) );
 511       else
 512         connected_delete_ipv6 (ifp,
 513                                &addr.sin6.sin6_addr,
 514                                ip6_masklen (mask.sin6.sin6_addr),
 515                                &brd.sin6.sin6_addr);
 516       break;
 517 #endif /* HAVE_IPV6 */
 518     default:
 519       /* Unsupported family silently ignore... */
 520       break;
 521     }
 522   return 0;
 523 }
 524 \f
 525 /* Interface function for reading kernel routing table information. */
 526 int
 527 rtm_read_mesg (struct rt_msghdr *rtm,
 528                union sockunion *dest,
 529                union sockunion *mask,
 530                union sockunion *gate)
 531 {
 532   caddr_t pnt, end;
 533
 534   /* Pnt points out socket data start point. */
 535   pnt = (caddr_t)(rtm + 1);
 536   end = ((caddr_t)rtm) + rtm->rtm_msglen;
 537
 538   /* rt_msghdr version check. */
 539   if (rtm->rtm_version != RTM_VERSION)
 540       zlog (NULL, LOG_WARNING,
 541               "Routing message version different %d should be %d."
 542               "This may cause problem\n", rtm->rtm_version, RTM_VERSION);
 543
 544   /* Be sure structure is cleared */
 545   memset (dest, 0, sizeof (union sockunion));
 546   memset (gate, 0, sizeof (union sockunion));
 547   memset (mask, 0, sizeof (union sockunion));
 548
 549   /* We fetch each socket variable into sockunion. */
 550   RTA_ADDR_GET (dest, RTA_DST, rtm->rtm_addrs, pnt);
 551   RTA_ADDR_GET (gate, RTA_GATEWAY, rtm->rtm_addrs, pnt);
 552   RTA_ATTR_GET (mask, RTA_NETMASK, rtm->rtm_addrs, pnt);
 553   RTA_ADDR_GET (NULL, RTA_GENMASK, rtm->rtm_addrs, pnt);
 554   RTA_ADDR_GET (NULL, RTA_IFP, rtm->rtm_addrs, pnt);
 555   RTA_ADDR_GET (NULL, RTA_IFA, rtm->rtm_addrs, pnt);
 556   RTA_ADDR_GET (NULL, RTA_AUTHOR, rtm->rtm_addrs, pnt);
 557   RTA_ADDR_GET (NULL, RTA_BRD, rtm->rtm_addrs, pnt);
 558
 559   /* If there is netmask information set it's family same as
 560      destination family*/
 561   if (rtm->rtm_addrs & RTA_NETMASK)
 562     mask->sa.sa_family = dest->sa.sa_family;
 563
 564   /* Assert read up to the end of pointer. */
 565   if (pnt != end)
 566       zlog (NULL, LOG_WARNING, "rtm_read() does't read all socket data.");
 567
 568   return rtm->rtm_flags;
 569 }
 570
 571 void
 572 rtm_read (struct rt_msghdr *rtm)
 573 {
 574   int flags;
 575   u_char zebra_flags;
 576   union sockunion dest, mask, gate;
 577
 578   zebra_flags = 0;
 579
 580   /* Discard self send message. */
 581   if (rtm->rtm_type != RTM_GET
 582       && (rtm->rtm_pid == pid || rtm->rtm_pid == old_pid))
 583     return;
 584
 585   /* Read destination and netmask and gateway from rtm message
 586      structure. */
 587   flags = rtm_read_mesg (rtm, &dest, &mask, &gate);
 588
 589 #ifdef RTF_CLONED       /*bsdi, netbsd 1.6*/
 590   if (flags & RTF_CLONED)
 591     return;
 592 #endif
 593 #ifdef RTF_WASCLONED    /*freebsd*/
 594   if (flags & RTF_WASCLONED)
 595     return;
 596 #endif
 597
 598   if ((rtm->rtm_type == RTM_ADD) && ! (flags & RTF_UP))
 599     return;
 600
 601   /* This is connected route. */
 602   if (! (flags & RTF_GATEWAY))
 603       return;
 604
 605   if (flags & RTF_PROTO1)
 606     SET_FLAG (zebra_flags, ZEBRA_FLAG_SELFROUTE);
 607
 608   /* This is persistent route. */
 609   if (flags & RTF_STATIC)
 610     SET_FLAG (zebra_flags, ZEBRA_FLAG_STATIC);
 611
 612   /* This is a reject or blackhole route */
 613   if (flags & RTF_REJECT)
 614     SET_FLAG (zebra_flags, ZEBRA_FLAG_REJECT);
 615   if (flags & RTF_BLACKHOLE)
 616     SET_FLAG (zebra_flags, ZEBRA_FLAG_BLACKHOLE);
 617
 618   if (dest.sa.sa_family == AF_INET)
 619     {
 620       struct prefix_ipv4 p;
 621
 622       p.family = AF_INET;
 623       p.prefix = dest.sin.sin_addr;
 624       if (flags & RTF_HOST)
 625         p.prefixlen = IPV4_MAX_PREFIXLEN;
 626       else
 627         p.prefixlen = ip_masklen (mask.sin.sin_addr);
 628
 629       /* Change, delete the old prefix, we have no further information
 630        * to specify the route really
 631        */
 632       if (rtm->rtm_type == RTM_CHANGE)
 633         rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p,
 634                          NULL, 0, 0);
 635
 636       if (rtm->rtm_type == RTM_GET
 637           || rtm->rtm_type == RTM_ADD
 638           || rtm->rtm_type == RTM_CHANGE)
 639         rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags,
 640                       &p, &gate.sin.sin_addr, 0, 0, 0, 0);
 641       else
 642         rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags,
 643                       &p, &gate.sin.sin_addr, 0, 0);
 644     }
 645 #ifdef HAVE_IPV6
 646   if (dest.sa.sa_family == AF_INET6)
 647     {
 648       struct prefix_ipv6 p;
 649       unsigned int ifindex = 0;
 650
 651       p.family = AF_INET6;
 652       p.prefix = dest.sin6.sin6_addr;
 653       if (flags & RTF_HOST)
 654         p.prefixlen = IPV6_MAX_PREFIXLEN;
 655       else
 656         p.prefixlen = ip6_masklen (mask.sin6.sin6_addr);
 657
 658 #ifdef KAME
 659       if (IN6_IS_ADDR_LINKLOCAL (&gate.sin6.sin6_addr))
 660         {
 661           ifindex = IN6_LINKLOCAL_IFINDEX (gate.sin6.sin6_addr);
 662           SET_IN6_LINKLOCAL_IFINDEX (gate.sin6.sin6_addr, 0);
 663         }
 664 #endif /* KAME */
 665
 666       /* CHANGE: delete the old prefix, we have no further information
 667        * to specify the route really
 668        */
 669       if (rtm->rtm_type == RTM_CHANGE)
 670         rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p,
 671                          NULL, 0, 0);
 672
 673       if (rtm->rtm_type == RTM_GET
 674           || rtm->rtm_type == RTM_ADD
 675           || rtm->rtm_type == RTM_CHANGE)
 676         rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags,
 677                       &p, &gate.sin6.sin6_addr, ifindex, 0, 0, 0);
 678       else
 679         rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags,
 680                          &p, &gate.sin6.sin6_addr, ifindex, 0);
 681     }
 682 #endif /* HAVE_IPV6 */
 683 }
 684
 685 /* Interface function for the kernel routing table updates.  Support
 686    for RTM_CHANGE will be needed. */
 687 int
 688 rtm_write (int message,
 689            union sockunion *dest,
 690            union sockunion *mask,
 691            union sockunion *gate,
 692            unsigned int index,
 693            int zebra_flags,
 694            int metric)
 695 {
 696   int ret;
 697   caddr_t pnt;
 698   struct interface *ifp;
 699   struct sockaddr_in tmp_gate;
 700 #ifdef HAVE_IPV6
 701   struct sockaddr_in6 tmp_gate6;
 702 #endif /* HAVE_IPV6 */
 703
 704   /* Sequencial number of routing message. */
 705   static int msg_seq = 0;
 706
 707   /* Struct of rt_msghdr and buffer for storing socket's data. */
 708   struct
 709   {
 710     struct rt_msghdr rtm;
 711     char buf[512];
 712   } msg;
 713
 714   memset (&tmp_gate, 0, sizeof (struct sockaddr_in));
 715   tmp_gate.sin_family = AF_INET;
 716 #ifdef HAVE_SIN_LEN
 717   tmp_gate.sin_len = sizeof (struct sockaddr_in);
 718 #endif /* HAVE_SIN_LEN */
 719
 720 #ifdef HAVE_IPV6
 721   memset (&tmp_gate6, 0, sizeof (struct sockaddr_in6));
 722   tmp_gate6.sin6_family = AF_INET6;
 723 #ifdef SIN6_LEN
 724   tmp_gate6.sin6_len = sizeof (struct sockaddr_in6);
 725 #endif /* SIN6_LEN */
 726 #endif /* HAVE_IPV6 */
 727
 728   if (routing_sock < 0)
 729     return ZEBRA_ERR_EPERM;
 730
 731   /* Clear and set rt_msghdr values */
 732   memset (&msg, 0, sizeof (struct rt_msghdr));
 733   msg.rtm.rtm_version = RTM_VERSION;
 734   msg.rtm.rtm_type = message;
 735   msg.rtm.rtm_seq = msg_seq++;
 736   msg.rtm.rtm_addrs = RTA_DST;
 737   msg.rtm.rtm_addrs |= RTA_GATEWAY;
 738   msg.rtm.rtm_flags = RTF_UP;
 739   msg.rtm.rtm_index = index;
 740
 741   if (metric != 0)
 742     {
 743       msg.rtm.rtm_rmx.rmx_hopcount = metric;
 744       msg.rtm.rtm_inits |= RTV_HOPCOUNT;
 745     }
 746
 747   ifp = if_lookup_by_index (index);
 748
 749   if (gate && message == RTM_ADD)
 750     msg.rtm.rtm_flags |= RTF_GATEWAY;
 751
 752   if (! gate && message == RTM_ADD && ifp &&
 753       (ifp->flags & IFF_POINTOPOINT) == 0)
 754     msg.rtm.rtm_flags |= RTF_CLONING;
 755
 756   /* If no protocol specific gateway is specified, use link
 757      address for gateway. */
 758   if (! gate)
 759     {
 760       if (!ifp)
 761         {
 762           zlog_warn ("no gateway found for interface index %d", index);
 763           return -1;
 764         }
 765       gate = (union sockunion *) & ifp->sdl;
 766     }
 767
 768   if (mask)
 769     msg.rtm.rtm_addrs |= RTA_NETMASK;
 770   else if (message == RTM_ADD)
 771     msg.rtm.rtm_flags |= RTF_HOST;
 772
 773   /* Tagging route with flags */
 774   msg.rtm.rtm_flags |= (RTF_PROTO1);
 775
 776   /* Additional flags. */
 777   if (zebra_flags & ZEBRA_FLAG_BLACKHOLE)
 778     msg.rtm.rtm_flags |= RTF_BLACKHOLE;
 779   if (zebra_flags & ZEBRA_FLAG_REJECT)
 780     msg.rtm.rtm_flags |= RTF_REJECT;
 781
 782
 783 #ifdef HAVE_SIN_LEN
 784 #define SOCKADDRSET(X,R) \
 785   if (msg.rtm.rtm_addrs & (R)) \
 786     { \
 787       int len = ROUNDUP ((X)->sa.sa_len); \
 788       memcpy (pnt, (caddr_t)(X), len); \
 789       pnt += len; \
 790     }
 791 #else
 792 #define SOCKADDRSET(X,R) \
 793   if (msg.rtm.rtm_addrs & (R)) \
 794     { \
 795       int len = ROUNDUP (sizeof((X)->sa)); \
 796       memcpy (pnt, (caddr_t)(X), len); \
 797       pnt += len; \
 798     }
 799 #endif /* HAVE_SIN_LEN */
 800
 801   pnt = (caddr_t) msg.buf;
 802
 803   /* Write each socket data into rtm message buffer */
 804   SOCKADDRSET (dest, RTA_DST);
 805   SOCKADDRSET (gate, RTA_GATEWAY);
 806   SOCKADDRSET (mask, RTA_NETMASK);
 807
 808   msg.rtm.rtm_msglen = pnt - (caddr_t) &msg;
 809
 810   ret = write (routing_sock, &msg, msg.rtm.rtm_msglen);
 811
 812   if (ret != msg.rtm.rtm_msglen)
 813     {
 814       if (errno == EEXIST)
 815         return ZEBRA_ERR_RTEXIST;
 816       if (errno == ENETUNREACH)
 817         return ZEBRA_ERR_RTUNREACH;
 818
 819       zlog_warn ("write : %s (%d)", safe_strerror (errno), errno);
 820       return -1;
 821     }
 822   return 0;
 823 }
 824
 825 \f
 826 #include "thread.h"
 827 #include "zebra/zserv.h"
 828
 829 /* For debug purpose. */
 830 static void
 831 rtmsg_debug (struct rt_msghdr *rtm)
 832 {
 833   const char *type = "Unknown";
 834   struct message *mes;
 835
 836   for (mes = rtm_type_str; mes->str; mes++)
 837     if (mes->key == rtm->rtm_type)
 838       {
 839         type = mes->str;
 840         break;
 841       }
 842
 843   zlog_debug ("Kernel: Len: %d Type: %s", rtm->rtm_msglen, type);
 844   rtm_flag_dump (rtm->rtm_flags);
 845   zlog_debug ("Kernel: message seq %d", rtm->rtm_seq);
 846   zlog_debug ("Kernel: pid %d", rtm->rtm_pid);
 847 }
 848
 849 /* This is pretty gross, better suggestions welcome -- mhandler */
 850 #ifndef RTAX_MAX
 851 #ifdef RTA_NUMBITS
 852 #define RTAX_MAX        RTA_NUMBITS
 853 #else
 854 #define RTAX_MAX        8
 855 #endif /* RTA_NUMBITS */
 856 #endif /* RTAX_MAX */
 857
 858 /* Kernel routing table and interface updates via routing socket. */
 859 int
 860 kernel_read (struct thread *thread)
 861 {
 862   int sock;
 863   int nbytes;
 864   struct rt_msghdr *rtm;
 865
 866   /*
 867    * This must be big enough for any message the kernel might send.
 868    * Rather than determining how many sockaddrs of what size might be
 869    * in each particular message, just use RTAX_MAX of sockaddr_storage
 870    * for each.  Note that the sockaddrs must be after each message
 871    * definition, or rather after whichever happens to be the largest,
 872    * since the buffer needs to be big enough for a message and the
 873    * sockaddrs together.
 874    */
 875   union
 876   {
 877     /* Routing information. */
 878     struct
 879     {
 880       struct rt_msghdr rtm;
 881       struct sockaddr_storage addr[RTAX_MAX];
 882     } r;
 883
 884     /* Interface information. */
 885     struct
 886     {
 887       struct if_msghdr ifm;
 888       struct sockaddr_storage addr[RTAX_MAX];
 889     } im;
 890
 891     /* Interface address information. */
 892     struct
 893     {
 894       struct ifa_msghdr ifa;
 895       struct sockaddr_storage addr[RTAX_MAX];
 896     } ia;
 897
 898 #ifdef RTM_IFANNOUNCE
 899     /* Interface arrival/departure */
 900     struct
 901     {
 902       struct if_announcemsghdr ifan;
 903       struct sockaddr_storage addr[RTAX_MAX];
 904     } ian;
 905 #endif /* RTM_IFANNOUNCE */
 906
 907   } buf;
 908
 909   /* Fetch routing socket. */
 910   sock = THREAD_FD (thread);
 911
 912   nbytes= read (sock, &buf, sizeof buf);
 913
 914   if (nbytes <= 0)
 915     {
 916       if (nbytes < 0 && errno != EWOULDBLOCK && errno != EAGAIN)
 917         zlog_warn ("routing socket error: %s", safe_strerror (errno));
 918       return 0;
 919     }
 920
 921   thread_add_read (zebrad.master, kernel_read, NULL, sock);
 922
 923   if (IS_ZEBRA_DEBUG_KERNEL)
 924     rtmsg_debug (&buf.r.rtm);
 925
 926   rtm = &buf.r.rtm;
 927
 928   /*
 929    * Ensure that we didn't drop any data, so that processing routines
 930    * can assume they have the whole message.
 931    */
 932   if (rtm->rtm_msglen != nbytes)
 933     {
 934       zlog_warn ("kernel_read: rtm->rtm_msglen %d, nbytes %d, type %d\n",
 935                  rtm->rtm_msglen, nbytes, rtm->rtm_type);
 936       return -1;
 937     }
 938
 939   switch (rtm->rtm_type)
 940     {
 941     case RTM_ADD:
 942     case RTM_DELETE:
 943     case RTM_CHANGE:
 944       rtm_read (rtm);
 945       break;
 946     case RTM_IFINFO:
 947       ifm_read (&buf.im.ifm);
 948       break;
 949     case RTM_NEWADDR:
 950     case RTM_DELADDR:
 951       ifam_read (&buf.ia.ifa);
 952       break;
 953 #ifdef RTM_IFANNOUNCE
 954     case RTM_IFANNOUNCE:
 955       ifan_read (&buf.ian.ifan);
 956       break;
 957 #endif /* RTM_IFANNOUNCE */
 958     default:
 959       if (IS_ZEBRA_DEBUG_KERNEL)
 960         zlog_debug("Unprocessed RTM_type: %d", rtm->rtm_type);
 961       break;
 962     }
 963   return 0;
 964 }
 965
 966 /* Make routing socket. */
 967 void
 968 routing_socket ()
 969 {
 970   if ( zserv_privs.change (ZPRIVS_RAISE) )
 971     zlog_err ("routing_socket: Can't raise privileges");
 972
 973   routing_sock = socket (AF_ROUTE, SOCK_RAW, 0);
 974
 975   if (routing_sock < 0)
 976     {
 977       if ( zserv_privs.change (ZPRIVS_LOWER) )
 978         zlog_err ("routing_socket: Can't lower privileges");
 979       zlog_warn ("Can't init kernel routing socket");
 980       return;
 981     }
 982
 983   /* XXX: Socket should be NONBLOCK, however as we currently
 984    * discard failed writes, this will lead to inconsistencies.
 985    * For now, socket must be blocking.
 986    */
 987   /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0)
 988     zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
 989
 990   if ( zserv_privs.change (ZPRIVS_LOWER) )
 991     zlog_err ("routing_socket: Can't lower privileges");
 992
 993   /* kernel_read needs rewrite. */
 994   thread_add_read (zebrad.master, kernel_read, NULL, routing_sock);
 995 }
 996
 997 /* Exported interface function.  This function simply calls
 998    routing_socket (). */
 999 void
1000 kernel_init ()
1001 {
1002   routing_socket ();
1003 }