zebra/rt_netlink.c

   1 /* Kernel routing table updates using netlink over GNU/Linux system.
   2  * Copyright (C) 1997, 98, 99 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 #include <net/if_arp.h>
  24
  25 /* Hack for GNU libc version 2. */
  26 #ifndef MSG_TRUNC
  27 #define MSG_TRUNC      0x20
  28 #endif /* MSG_TRUNC */
  29
  30 #include "linklist.h"
  31 #include "if.h"
  32 #include "log.h"
  33 #include "prefix.h"
  34 #include "connected.h"
  35 #include "table.h"
  36 #include "memory.h"
  37 #include "rib.h"
  38 #include "thread.h"
  39 #include "privs.h"
  40 #include "vrf.h"
  41 #include "nexthop.h"
  42
  43 #include "zebra/zserv.h"
  44 #include "zebra/rt.h"
  45 #include "zebra/redistribute.h"
  46 #include "zebra/interface.h"
  47 #include "zebra/debug.h"
  48
  49 #include "rt_netlink.h"
  50
  51 static const struct message nlmsg_str[] = {
  52   {RTM_NEWROUTE, "RTM_NEWROUTE"},
  53   {RTM_DELROUTE, "RTM_DELROUTE"},
  54   {RTM_GETROUTE, "RTM_GETROUTE"},
  55   {RTM_NEWLINK,  "RTM_NEWLINK"},
  56   {RTM_DELLINK,  "RTM_DELLINK"},
  57   {RTM_GETLINK,  "RTM_GETLINK"},
  58   {RTM_NEWADDR,  "RTM_NEWADDR"},
  59   {RTM_DELADDR,  "RTM_DELADDR"},
  60   {RTM_GETADDR,  "RTM_GETADDR"},
  61   {0, NULL}
  62 };
  63
  64 extern struct zebra_t zebrad;
  65
  66 extern struct zebra_privs_t zserv_privs;
  67
  68 extern u_int32_t nl_rcvbufsize;
  69
  70 static struct {
  71   char *p;
  72   size_t size;
  73 } nl_rcvbuf;
  74
  75 /* Note: on netlink systems, there should be a 1-to-1 mapping between interface
  76    names and ifindex values. */
  77 static void
  78 set_ifindex(struct interface *ifp, ifindex_t ifi_index)
  79 {
  80   struct interface *oifp;
  81
  82   if (((oifp = if_lookup_by_index(ifi_index)) != NULL) && (oifp != ifp))
  83     {
  84       if (ifi_index == IFINDEX_INTERNAL)
  85         zlog_err("Netlink is setting interface %s ifindex to reserved "
  86                  "internal value %u", ifp->name, ifi_index);
  87       else
  88         {
  89           if (IS_ZEBRA_DEBUG_KERNEL)
  90             zlog_debug("interface index %d was renamed from %s to %s",
  91                        ifi_index, oifp->name, ifp->name);
  92           if (if_is_up(oifp))
  93             zlog_err("interface rename detected on up interface: index %d "
  94                      "was renamed from %s to %s, results are uncertain!",
  95                      ifi_index, oifp->name, ifp->name);
  96           if_delete_update(oifp);
  97         }
  98     }
  99   ifp->ifindex = ifi_index;
 100 }
 101
 102 #ifndef SO_RCVBUFFORCE
 103 #define SO_RCVBUFFORCE  (33)
 104 #endif
 105
 106 static int
 107 netlink_recvbuf (struct nlsock *nl, uint32_t newsize)
 108 {
 109   u_int32_t oldsize;
 110   socklen_t newlen = sizeof(newsize);
 111   socklen_t oldlen = sizeof(oldsize);
 112   int ret;
 113
 114   ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
 115   if (ret < 0)
 116     {
 117       zlog (NULL, LOG_ERR, "Can't get %s receive buffer size: %s", nl->name,
 118             safe_strerror (errno));
 119       return -1;
 120     }
 121
 122   /* Try force option (linux >= 2.6.14) and fall back to normal set */
 123   if ( zserv_privs.change (ZPRIVS_RAISE) )
 124     zlog_err ("routing_socket: Can't raise privileges");
 125   ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUFFORCE, &nl_rcvbufsize,
 126                    sizeof(nl_rcvbufsize));
 127   if ( zserv_privs.change (ZPRIVS_LOWER) )
 128     zlog_err ("routing_socket: Can't lower privileges");
 129   if (ret < 0)
 130      ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &nl_rcvbufsize,
 131                       sizeof(nl_rcvbufsize));
 132   if (ret < 0)
 133     {
 134       zlog (NULL, LOG_ERR, "Can't set %s receive buffer size: %s", nl->name,
 135             safe_strerror (errno));
 136       return -1;
 137     }
 138
 139   ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
 140   if (ret < 0)
 141     {
 142       zlog (NULL, LOG_ERR, "Can't get %s receive buffer size: %s", nl->name,
 143             safe_strerror (errno));
 144       return -1;
 145     }
 146
 147   zlog (NULL, LOG_INFO,
 148         "Setting netlink socket receive buffer size: %u -> %u",
 149         oldsize, newsize);
 150   return 0;
 151 }
 152
 153 /* Make socket for Linux netlink interface. */
 154 static int
 155 netlink_socket (struct nlsock *nl, unsigned long groups, vrf_id_t vrf_id)
 156 {
 157   int ret;
 158   struct sockaddr_nl snl;
 159   int sock;
 160   int namelen;
 161   int save_errno;
 162
 163   if (zserv_privs.change (ZPRIVS_RAISE))
 164     {
 165       zlog (NULL, LOG_ERR, "Can't raise privileges");
 166       return -1;
 167     }
 168
 169   sock = vrf_socket (AF_NETLINK, SOCK_RAW, NETLINK_ROUTE, vrf_id);
 170   if (sock < 0)
 171     {
 172       zlog (NULL, LOG_ERR, "Can't open %s socket: %s", nl->name,
 173             safe_strerror (errno));
 174       return -1;
 175     }
 176
 177   memset (&snl, 0, sizeof snl);
 178   snl.nl_family = AF_NETLINK;
 179   snl.nl_groups = groups;
 180
 181   /* Bind the socket to the netlink structure for anything. */
 182   ret = bind (sock, (struct sockaddr *) &snl, sizeof snl);
 183   save_errno = errno;
 184   if (zserv_privs.change (ZPRIVS_LOWER))
 185     zlog (NULL, LOG_ERR, "Can't lower privileges");
 186
 187   if (ret < 0)
 188     {
 189       zlog (NULL, LOG_ERR, "Can't bind %s socket to group 0x%x: %s",
 190             nl->name, snl.nl_groups, safe_strerror (save_errno));
 191       close (sock);
 192       return -1;
 193     }
 194
 195   /* multiple netlink sockets will have different nl_pid */
 196   namelen = sizeof snl;
 197   ret = getsockname (sock, (struct sockaddr *) &snl, (socklen_t *) &namelen);
 198   if (ret < 0 || namelen != sizeof snl)
 199     {
 200       zlog (NULL, LOG_ERR, "Can't get %s socket name: %s", nl->name,
 201             safe_strerror (errno));
 202       close (sock);
 203       return -1;
 204     }
 205
 206   nl->snl = snl;
 207   nl->sock = sock;
 208   return ret;
 209 }
 210
 211 /* Get type specified information from netlink. */
 212 static int
 213 netlink_request (int family, int type, struct nlsock *nl)
 214 {
 215   int ret;
 216   struct sockaddr_nl snl;
 217   int save_errno;
 218
 219   struct
 220   {
 221     struct nlmsghdr nlh;
 222     struct rtgenmsg g;
 223   } req;
 224
 225
 226   /* Check netlink socket. */
 227   if (nl->sock < 0)
 228     {
 229       zlog (NULL, LOG_ERR, "%s socket isn't active.", nl->name);
 230       return -1;
 231     }
 232
 233   memset (&snl, 0, sizeof snl);
 234   snl.nl_family = AF_NETLINK;
 235
 236   memset (&req, 0, sizeof req);
 237   req.nlh.nlmsg_len = sizeof req;
 238   req.nlh.nlmsg_type = type;
 239   req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 240   req.nlh.nlmsg_pid = nl->snl.nl_pid;
 241   req.nlh.nlmsg_seq = ++nl->seq;
 242   req.g.rtgen_family = family;
 243
 244   /* linux appears to check capabilities on every message
 245    * have to raise caps for every message sent
 246    */
 247   if (zserv_privs.change (ZPRIVS_RAISE))
 248     {
 249       zlog (NULL, LOG_ERR, "Can't raise privileges");
 250       return -1;
 251     }
 252
 253   ret = sendto (nl->sock, (void *) &req, sizeof req, 0,
 254                 (struct sockaddr *) &snl, sizeof snl);
 255   save_errno = errno;
 256
 257   if (zserv_privs.change (ZPRIVS_LOWER))
 258     zlog (NULL, LOG_ERR, "Can't lower privileges");
 259
 260   if (ret < 0)
 261     {
 262       zlog (NULL, LOG_ERR, "%s sendto failed: %s", nl->name,
 263             safe_strerror (save_errno));
 264       return -1;
 265     }
 266
 267   return 0;
 268 }
 269
 270 /* Receive message from netlink interface and pass those information
 271    to the given function. */
 272 static int
 273 netlink_parse_info (int (*filter) (struct sockaddr_nl *, struct nlmsghdr *,
 274                                    vrf_id_t),
 275                     struct nlsock *nl, struct zebra_vrf *zvrf)
 276 {
 277   int status;
 278   int ret = 0;
 279   int error;
 280
 281   while (1)
 282     {
 283       struct iovec iov = {
 284         .iov_base = nl_rcvbuf.p,
 285         .iov_len = nl_rcvbuf.size,
 286       };
 287       struct sockaddr_nl snl;
 288       struct msghdr msg = {
 289         .msg_name = (void *) &snl,
 290         .msg_namelen = sizeof snl,
 291         .msg_iov = &iov,
 292         .msg_iovlen = 1
 293       };
 294       struct nlmsghdr *h;
 295
 296       status = recvmsg (nl->sock, &msg, 0);
 297       if (status < 0)
 298         {
 299           if (errno == EINTR)
 300             continue;
 301           if (errno == EWOULDBLOCK || errno == EAGAIN)
 302             break;
 303           zlog (NULL, LOG_ERR, "%s recvmsg overrun: %s",
 304                 nl->name, safe_strerror(errno));
 305           continue;
 306         }
 307
 308       if (status == 0)
 309         {
 310           zlog (NULL, LOG_ERR, "%s EOF", nl->name);
 311           return -1;
 312         }
 313
 314       if (msg.msg_namelen != sizeof snl)
 315         {
 316           zlog (NULL, LOG_ERR, "%s sender address length error: length %d",
 317                 nl->name, msg.msg_namelen);
 318           return -1;
 319         }
 320
 321       for (h = (struct nlmsghdr *) nl_rcvbuf.p;
 322            NLMSG_OK (h, (unsigned int) status);
 323            h = NLMSG_NEXT (h, status))
 324         {
 325           /* Finish of reading. */
 326           if (h->nlmsg_type == NLMSG_DONE)
 327             return ret;
 328
 329           /* Error handling. */
 330           if (h->nlmsg_type == NLMSG_ERROR)
 331             {
 332               struct nlmsgerr *err = (struct nlmsgerr *) NLMSG_DATA (h);
 333               int errnum = err->error;
 334               int msg_type = err->msg.nlmsg_type;
 335
 336               /* If the error field is zero, then this is an ACK */
 337               if (err->error == 0)
 338                 {
 339                   if (IS_ZEBRA_DEBUG_KERNEL)
 340                     {
 341                       zlog_debug ("%s: %s ACK: type=%s(%u), seq=%u, pid=%u",
 342                                  __FUNCTION__, nl->name,
 343                                  lookup (nlmsg_str, err->msg.nlmsg_type),
 344                                  err->msg.nlmsg_type, err->msg.nlmsg_seq,
 345                                  err->msg.nlmsg_pid);
 346                     }
 347
 348                   /* return if not a multipart message, otherwise continue */
 349                   if (!(h->nlmsg_flags & NLM_F_MULTI))
 350                     {
 351                       return 0;
 352                     }
 353                   continue;
 354                 }
 355
 356               if (h->nlmsg_len < NLMSG_LENGTH (sizeof (struct nlmsgerr)))
 357                 {
 358                   zlog (NULL, LOG_ERR, "%s error: message truncated",
 359                         nl->name);
 360                   return -1;
 361                 }
 362
 363               /* Deal with errors that occur because of races in link handling */
 364               if (nl == &zvrf->netlink_cmd
 365                   && ((msg_type == RTM_DELROUTE &&
 366                        (-errnum == ENODEV || -errnum == ESRCH))
 367                       || (msg_type == RTM_NEWROUTE && -errnum == EEXIST)))
 368                 {
 369                   if (IS_ZEBRA_DEBUG_KERNEL)
 370                     zlog_debug ("%s: error: %s type=%s(%u), seq=%u, pid=%u",
 371                                 nl->name, safe_strerror (-errnum),
 372                                 lookup (nlmsg_str, msg_type),
 373                                 msg_type, err->msg.nlmsg_seq, err->msg.nlmsg_pid);
 374                   return 0;
 375                 }
 376
 377               zlog_err ("%s error: %s, type=%s(%u), seq=%u, pid=%u",
 378                         nl->name, safe_strerror (-errnum),
 379                         lookup (nlmsg_str, msg_type),
 380                         msg_type, err->msg.nlmsg_seq, err->msg.nlmsg_pid);
 381               return -1;
 382             }
 383
 384           /* OK we got netlink message. */
 385           if (IS_ZEBRA_DEBUG_KERNEL)
 386             zlog_debug ("netlink_parse_info: %s type %s(%u), seq=%u, pid=%u",
 387                        nl->name,
 388                        lookup (nlmsg_str, h->nlmsg_type), h->nlmsg_type,
 389                        h->nlmsg_seq, h->nlmsg_pid);
 390
 391           /* skip unsolicited messages originating from command socket
 392            * linux sets the originators port-id for {NEW|DEL}ADDR messages,
 393            * so this has to be checked here. */
 394           if (nl != &zvrf->netlink_cmd
 395               && h->nlmsg_pid == zvrf->netlink_cmd.snl.nl_pid
 396               && (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR))
 397             {
 398               if (IS_ZEBRA_DEBUG_KERNEL)
 399                 zlog_debug ("netlink_parse_info: %s packet comes from %s",
 400                             zvrf->netlink_cmd.name, nl->name);
 401               continue;
 402             }
 403
 404           error = (*filter) (&snl, h, zvrf->vrf_id);
 405           if (error < 0)
 406             {
 407               zlog (NULL, LOG_ERR, "%s filter function error", nl->name);
 408               ret = error;
 409             }
 410         }
 411
 412       /* After error care. */
 413       if (msg.msg_flags & MSG_TRUNC)
 414         {
 415           zlog (NULL, LOG_ERR, "%s error: message truncated!", nl->name);
 416           zlog (NULL, LOG_ERR,
 417                 "Must restart with larger --nl-bufsize value!");
 418           continue;
 419         }
 420       if (status)
 421         {
 422           zlog (NULL, LOG_ERR, "%s error: data remnant size %d", nl->name,
 423                 status);
 424           return -1;
 425         }
 426     }
 427   return ret;
 428 }
 429
 430 /* Utility function for parse rtattr. */
 431 static void
 432 netlink_parse_rtattr (struct rtattr **tb, int max, struct rtattr *rta,
 433                       int len)
 434 {
 435   while (RTA_OK (rta, len))
 436     {
 437       if (rta->rta_type <= max)
 438         tb[rta->rta_type] = rta;
 439       rta = RTA_NEXT (rta, len);
 440     }
 441 }
 442
 443 /* Utility function to parse hardware link-layer address and update ifp */
 444 static void
 445 netlink_interface_update_hw_addr (struct rtattr **tb, struct interface *ifp)
 446 {
 447   int i;
 448
 449   if (tb[IFLA_ADDRESS])
 450     {
 451       int hw_addr_len;
 452
 453       hw_addr_len = RTA_PAYLOAD (tb[IFLA_ADDRESS]);
 454
 455       if (hw_addr_len > INTERFACE_HWADDR_MAX)
 456         zlog_warn ("Hardware address is too large: %d", hw_addr_len);
 457       else
 458         {
 459           ifp->hw_addr_len = hw_addr_len;
 460           memcpy (ifp->hw_addr, RTA_DATA (tb[IFLA_ADDRESS]), hw_addr_len);
 461
 462           for (i = 0; i < hw_addr_len; i++)
 463             if (ifp->hw_addr[i] != 0)
 464               break;
 465
 466           if (i == hw_addr_len)
 467             ifp->hw_addr_len = 0;
 468           else
 469             ifp->hw_addr_len = hw_addr_len;
 470         }
 471     }
 472 }
 473
 474 static enum zebra_link_type
 475 netlink_to_zebra_link_type (unsigned int hwt)
 476 {
 477   switch (hwt)
 478   {
 479     case ARPHRD_ETHER: return ZEBRA_LLT_ETHER;
 480     case ARPHRD_EETHER: return ZEBRA_LLT_EETHER;
 481     case ARPHRD_AX25: return ZEBRA_LLT_AX25;
 482     case ARPHRD_PRONET: return ZEBRA_LLT_PRONET;
 483     case ARPHRD_IEEE802: return ZEBRA_LLT_IEEE802;
 484     case ARPHRD_ARCNET: return ZEBRA_LLT_ARCNET;
 485     case ARPHRD_APPLETLK: return ZEBRA_LLT_APPLETLK;
 486     case ARPHRD_DLCI: return ZEBRA_LLT_DLCI;
 487     case ARPHRD_ATM: return ZEBRA_LLT_ATM;
 488     case ARPHRD_METRICOM: return ZEBRA_LLT_METRICOM;
 489     case ARPHRD_IEEE1394: return ZEBRA_LLT_IEEE1394;
 490     case ARPHRD_EUI64: return ZEBRA_LLT_EUI64;
 491     case ARPHRD_INFINIBAND: return ZEBRA_LLT_INFINIBAND;
 492     case ARPHRD_SLIP: return ZEBRA_LLT_SLIP;
 493     case ARPHRD_CSLIP: return ZEBRA_LLT_CSLIP;
 494     case ARPHRD_SLIP6: return ZEBRA_LLT_SLIP6;
 495     case ARPHRD_CSLIP6: return ZEBRA_LLT_CSLIP6;
 496     case ARPHRD_RSRVD: return ZEBRA_LLT_RSRVD;
 497     case ARPHRD_ADAPT: return ZEBRA_LLT_ADAPT;
 498     case ARPHRD_ROSE: return ZEBRA_LLT_ROSE;
 499     case ARPHRD_X25: return ZEBRA_LLT_X25;
 500     case ARPHRD_PPP: return ZEBRA_LLT_PPP;
 501     case ARPHRD_CISCO: return ZEBRA_LLT_CHDLC;
 502     case ARPHRD_LAPB: return ZEBRA_LLT_LAPB;
 503     case ARPHRD_RAWHDLC: return ZEBRA_LLT_RAWHDLC;
 504     case ARPHRD_TUNNEL: return ZEBRA_LLT_IPIP;
 505     case ARPHRD_TUNNEL6: return ZEBRA_LLT_IPIP6;
 506     case ARPHRD_FRAD: return ZEBRA_LLT_FRAD;
 507     case ARPHRD_SKIP: return ZEBRA_LLT_SKIP;
 508     case ARPHRD_LOOPBACK: return ZEBRA_LLT_LOOPBACK;
 509     case ARPHRD_LOCALTLK: return ZEBRA_LLT_LOCALTLK;
 510     case ARPHRD_FDDI: return ZEBRA_LLT_FDDI;
 511     case ARPHRD_SIT: return ZEBRA_LLT_SIT;
 512     case ARPHRD_IPDDP: return ZEBRA_LLT_IPDDP;
 513     case ARPHRD_IPGRE: return ZEBRA_LLT_IPGRE;
 514     case ARPHRD_PIMREG: return ZEBRA_LLT_PIMREG;
 515     case ARPHRD_HIPPI: return ZEBRA_LLT_HIPPI;
 516     case ARPHRD_ECONET: return ZEBRA_LLT_ECONET;
 517     case ARPHRD_IRDA: return ZEBRA_LLT_IRDA;
 518     case ARPHRD_FCPP: return ZEBRA_LLT_FCPP;
 519     case ARPHRD_FCAL: return ZEBRA_LLT_FCAL;
 520     case ARPHRD_FCPL: return ZEBRA_LLT_FCPL;
 521     case ARPHRD_FCFABRIC: return ZEBRA_LLT_FCFABRIC;
 522     case ARPHRD_IEEE802_TR: return ZEBRA_LLT_IEEE802_TR;
 523     case ARPHRD_IEEE80211: return ZEBRA_LLT_IEEE80211;
 524     case ARPHRD_IEEE802154: return ZEBRA_LLT_IEEE802154;
 525 #ifdef ARPHRD_IP6GRE
 526     case ARPHRD_IP6GRE: return ZEBRA_LLT_IP6GRE;
 527 #endif
 528 #ifdef ARPHRD_IEEE802154_PHY
 529     case ARPHRD_IEEE802154_PHY: return ZEBRA_LLT_IEEE802154_PHY;
 530 #endif
 531
 532     default: return ZEBRA_LLT_UNKNOWN;
 533   }
 534 }
 535
 536 /* Called from interface_lookup_netlink().  This function is only used
 537    during bootstrap. */
 538 static int
 539 netlink_interface (struct sockaddr_nl *snl, struct nlmsghdr *h,
 540     vrf_id_t vrf_id)
 541 {
 542   int len;
 543   struct ifinfomsg *ifi;
 544   struct rtattr *tb[IFLA_MAX + 1];
 545   struct interface *ifp;
 546   char *name;
 547
 548   ifi = NLMSG_DATA (h);
 549
 550   if (h->nlmsg_type != RTM_NEWLINK)
 551     return 0;
 552
 553   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
 554   if (len < 0)
 555     return -1;
 556
 557   /* Looking up interface name. */
 558   memset (tb, 0, sizeof tb);
 559   netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
 560
 561 #ifdef IFLA_WIRELESS
 562   /* check for wireless messages to ignore */
 563   if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
 564     {
 565       if (IS_ZEBRA_DEBUG_KERNEL)
 566         zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
 567       return 0;
 568     }
 569 #endif /* IFLA_WIRELESS */
 570
 571   if (tb[IFLA_IFNAME] == NULL)
 572     return -1;
 573   name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
 574
 575   /* Add interface. */
 576   ifp = if_get_by_name_vrf (name, vrf_id);
 577   set_ifindex(ifp, ifi->ifi_index);
 578   ifp->flags = ifi->ifi_flags & 0x0000fffff;
 579   ifp->mtu6 = ifp->mtu = *(uint32_t *) RTA_DATA (tb[IFLA_MTU]);
 580   ifp->metric = 0;
 581
 582   /* Hardware type and address. */
 583   ifp->ll_type = netlink_to_zebra_link_type (ifi->ifi_type);
 584   netlink_interface_update_hw_addr (tb, ifp);
 585
 586   if_add_update (ifp);
 587
 588   return 0;
 589 }
 590
 591 /* Lookup interface IPv4/IPv6 address. */
 592 static int
 593 netlink_interface_addr (struct sockaddr_nl *snl, struct nlmsghdr *h,
 594     vrf_id_t vrf_id)
 595 {
 596   int len;
 597   struct ifaddrmsg *ifa;
 598   struct rtattr *tb[IFA_MAX + 1];
 599   struct interface *ifp;
 600   void *addr;
 601   void *broad;
 602   u_char flags = 0;
 603   char *label = NULL;
 604
 605   ifa = NLMSG_DATA (h);
 606
 607   if (ifa->ifa_family != AF_INET
 608 #ifdef HAVE_IPV6
 609       && ifa->ifa_family != AF_INET6
 610 #endif /* HAVE_IPV6 */
 611     )
 612     return 0;
 613
 614   if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
 615     return 0;
 616
 617   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifaddrmsg));
 618   if (len < 0)
 619     return -1;
 620
 621   memset (tb, 0, sizeof tb);
 622   netlink_parse_rtattr (tb, IFA_MAX, IFA_RTA (ifa), len);
 623
 624   ifp = if_lookup_by_index_vrf (ifa->ifa_index, vrf_id);
 625   if (ifp == NULL)
 626     {
 627       zlog_err ("netlink_interface_addr can't find interface by index %d vrf %u",
 628                 ifa->ifa_index, vrf_id);
 629       return -1;
 630     }
 631
 632   if (IS_ZEBRA_DEBUG_KERNEL)    /* remove this line to see initial ifcfg */
 633     {
 634       char buf[BUFSIZ];
 635       zlog_debug ("netlink_interface_addr %s %s vrf %u:",
 636                  lookup (nlmsg_str, h->nlmsg_type), ifp->name, vrf_id);
 637       if (tb[IFA_LOCAL])
 638         zlog_debug ("  IFA_LOCAL     %s/%d",
 639                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_LOCAL]),
 640                                buf, BUFSIZ), ifa->ifa_prefixlen);
 641       if (tb[IFA_ADDRESS])
 642         zlog_debug ("  IFA_ADDRESS   %s/%d",
 643                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_ADDRESS]),
 644                                buf, BUFSIZ), ifa->ifa_prefixlen);
 645       if (tb[IFA_BROADCAST])
 646         zlog_debug ("  IFA_BROADCAST %s/%d",
 647                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_BROADCAST]),
 648                                buf, BUFSIZ), ifa->ifa_prefixlen);
 649       if (tb[IFA_LABEL] && strcmp (ifp->name, RTA_DATA (tb[IFA_LABEL])))
 650         zlog_debug ("  IFA_LABEL     %s", (char *)RTA_DATA (tb[IFA_LABEL]));
 651
 652       if (tb[IFA_CACHEINFO])
 653         {
 654           struct ifa_cacheinfo *ci = RTA_DATA (tb[IFA_CACHEINFO]);
 655           zlog_debug ("  IFA_CACHEINFO pref %d, valid %d",
 656                       ci->ifa_prefered, ci->ifa_valid);
 657         }
 658     }
 659
 660   /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
 661   if (tb[IFA_LOCAL] == NULL)
 662     tb[IFA_LOCAL] = tb[IFA_ADDRESS];
 663   if (tb[IFA_ADDRESS] == NULL)
 664     tb[IFA_ADDRESS] = tb[IFA_LOCAL];
 665
 666   /* local interface address */
 667   addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
 668
 669   /* is there a peer address? */
 670   if (tb[IFA_ADDRESS] &&
 671       memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_ADDRESS])))
 672     {
 673       broad = RTA_DATA(tb[IFA_ADDRESS]);
 674       SET_FLAG (flags, ZEBRA_IFA_PEER);
 675     }
 676   else
 677     /* seeking a broadcast address */
 678     broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST]) : NULL);
 679
 680   /* addr is primary key, SOL if we don't have one */
 681   if (addr == NULL)
 682     {
 683       zlog_debug ("%s: NULL address", __func__);
 684       return -1;
 685     }
 686
 687   /* Flags. */
 688   if (ifa->ifa_flags & IFA_F_SECONDARY)
 689     SET_FLAG (flags, ZEBRA_IFA_SECONDARY);
 690
 691   /* Label */
 692   if (tb[IFA_LABEL])
 693     label = (char *) RTA_DATA (tb[IFA_LABEL]);
 694
 695   if (ifp && label && strcmp (ifp->name, label) == 0)
 696     label = NULL;
 697
 698   /* Register interface address to the interface. */
 699   if (ifa->ifa_family == AF_INET)
 700     {
 701       if (h->nlmsg_type == RTM_NEWADDR)
 702         connected_add_ipv4 (ifp, flags,
 703                             (struct in_addr *) addr, ifa->ifa_prefixlen,
 704                             (struct in_addr *) broad, label);
 705       else
 706         connected_delete_ipv4 (ifp, flags,
 707                                (struct in_addr *) addr, ifa->ifa_prefixlen,
 708                                (struct in_addr *) broad);
 709     }
 710 #ifdef HAVE_IPV6
 711   if (ifa->ifa_family == AF_INET6)
 712     {
 713       if (h->nlmsg_type == RTM_NEWADDR)
 714         connected_add_ipv6 (ifp, flags,
 715                             (struct in6_addr *) addr, ifa->ifa_prefixlen,
 716                             (struct in6_addr *) broad, label);
 717       else
 718         connected_delete_ipv6 (ifp,
 719                                (struct in6_addr *) addr, ifa->ifa_prefixlen,
 720                                (struct in6_addr *) broad);
 721     }
 722 #endif /* HAVE_IPV6 */
 723
 724   return 0;
 725 }
 726
 727 /* Looking up routing table by netlink interface. */
 728 static int
 729 netlink_routing_table (struct sockaddr_nl *snl, struct nlmsghdr *h,
 730     vrf_id_t vrf_id)
 731 {
 732   int len;
 733   struct rtmsg *rtm;
 734   struct rtattr *tb[RTA_MAX + 1];
 735   u_char flags = 0;
 736
 737   char anyaddr[16] = { 0 };
 738
 739   int index;
 740   int table;
 741   u_int32_t mtu = 0;
 742
 743   void *dest;
 744   void *gate;
 745   void *src;
 746
 747   rtm = NLMSG_DATA (h);
 748
 749   if (h->nlmsg_type != RTM_NEWROUTE)
 750     return 0;
 751   if (rtm->rtm_type != RTN_UNICAST)
 752     return 0;
 753
 754   table = rtm->rtm_table;
 755 #if 0                           /* we weed them out later in rib_weed_tables () */
 756   if (table != RT_TABLE_MAIN && table != zebrad.rtm_table_default)
 757     return 0;
 758 #endif
 759
 760   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct rtmsg));
 761   if (len < 0)
 762     return -1;
 763
 764   memset (tb, 0, sizeof tb);
 765   netlink_parse_rtattr (tb, RTA_MAX, RTM_RTA (rtm), len);
 766
 767   if (rtm->rtm_flags & RTM_F_CLONED)
 768     return 0;
 769   if (rtm->rtm_protocol == RTPROT_REDIRECT)
 770     return 0;
 771   if (rtm->rtm_protocol == RTPROT_KERNEL)
 772     return 0;
 773
 774   if (rtm->rtm_src_len != 0)
 775     return 0;
 776
 777   /* Route which inserted by Zebra. */
 778   if (rtm->rtm_protocol == RTPROT_ZEBRA)
 779     flags |= ZEBRA_FLAG_SELFROUTE;
 780
 781   index = 0;
 782   dest = NULL;
 783   gate = NULL;
 784   src = NULL;
 785
 786   if (tb[RTA_OIF])
 787     index = *(int *) RTA_DATA (tb[RTA_OIF]);
 788
 789   if (tb[RTA_DST])
 790     dest = RTA_DATA (tb[RTA_DST]);
 791   else
 792     dest = anyaddr;
 793
 794   if (tb[RTA_PREFSRC])
 795     src = RTA_DATA (tb[RTA_PREFSRC]);
 796
 797   if (tb[RTA_GATEWAY])
 798     gate = RTA_DATA (tb[RTA_GATEWAY]);
 799
 800   if (tb[RTA_METRICS])
 801     {
 802       struct rtattr *mxrta[RTAX_MAX+1];
 803
 804       memset (mxrta, 0, sizeof mxrta);
 805       netlink_parse_rtattr (mxrta, RTAX_MAX, RTA_DATA(tb[RTA_METRICS]),
 806                             RTA_PAYLOAD(tb[RTA_METRICS]));
 807
 808       if (mxrta[RTAX_MTU])
 809         mtu = *(u_int32_t *) RTA_DATA(mxrta[RTAX_MTU]);
 810     }
 811
 812   if (rtm->rtm_family == AF_INET)
 813     {
 814       struct prefix_ipv4 p;
 815       p.family = AF_INET;
 816       memcpy (&p.prefix, dest, 4);
 817       p.prefixlen = rtm->rtm_dst_len;
 818
 819       if (!tb[RTA_MULTIPATH])
 820           rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, flags, &p, gate, src, index,
 821                         vrf_id, table, 0, mtu, 0, SAFI_UNICAST);
 822       else
 823         {
 824           /* This is a multipath route */
 825
 826           struct rib *rib;
 827           struct rtnexthop *rtnh =
 828             (struct rtnexthop *) RTA_DATA (tb[RTA_MULTIPATH]);
 829
 830           len = RTA_PAYLOAD (tb[RTA_MULTIPATH]);
 831
 832           rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
 833           rib->type = ZEBRA_ROUTE_KERNEL;
 834           rib->distance = 0;
 835           rib->flags = flags;
 836           rib->metric = 0;
 837           rib->mtu = mtu;
 838           rib->vrf_id = vrf_id;
 839           rib->table = table;
 840           rib->nexthop_num = 0;
 841           rib->uptime = time (NULL);
 842
 843           for (;;)
 844             {
 845               if (len < (int) sizeof (*rtnh) || rtnh->rtnh_len > len)
 846                 break;
 847
 848               index = rtnh->rtnh_ifindex;
 849               gate = 0;
 850               if (rtnh->rtnh_len > sizeof (*rtnh))
 851                 {
 852                   memset (tb, 0, sizeof (tb));
 853                   netlink_parse_rtattr (tb, RTA_MAX, RTNH_DATA (rtnh),
 854                                         rtnh->rtnh_len - sizeof (*rtnh));
 855                   if (tb[RTA_GATEWAY])
 856                     gate = RTA_DATA (tb[RTA_GATEWAY]);
 857                 }
 858
 859               if (gate)
 860                 {
 861                   if (index)
 862                     rib_nexthop_ipv4_ifindex_add (rib, gate, src, index);
 863                   else
 864                     rib_nexthop_ipv4_add (rib, gate, src);
 865                 }
 866               else
 867                 rib_nexthop_ifindex_add (rib, index);
 868
 869               len -= NLMSG_ALIGN(rtnh->rtnh_len);
 870               rtnh = RTNH_NEXT(rtnh);
 871             }
 872
 873           if (rib->nexthop_num == 0)
 874             XFREE (MTYPE_RIB, rib);
 875           else
 876             rib_add_ipv4_multipath (&p, rib, SAFI_UNICAST);
 877         }
 878     }
 879 #ifdef HAVE_IPV6
 880   if (rtm->rtm_family == AF_INET6)
 881     {
 882       struct prefix_ipv6 p;
 883       p.family = AF_INET6;
 884       memcpy (&p.prefix, dest, 16);
 885       p.prefixlen = rtm->rtm_dst_len;
 886
 887       rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, flags, &p, gate, index, vrf_id,
 888                     table, 0, mtu, 0, SAFI_UNICAST);
 889     }
 890 #endif /* HAVE_IPV6 */
 891
 892   return 0;
 893 }
 894
 895 static const struct message rtproto_str[] = {
 896   {RTPROT_REDIRECT, "redirect"},
 897   {RTPROT_KERNEL,   "kernel"},
 898   {RTPROT_BOOT,     "boot"},
 899   {RTPROT_STATIC,   "static"},
 900   {RTPROT_GATED,    "GateD"},
 901   {RTPROT_RA,       "router advertisement"},
 902   {RTPROT_MRT,      "MRT"},
 903   {RTPROT_ZEBRA,    "Zebra"},
 904 #ifdef RTPROT_BIRD
 905   {RTPROT_BIRD,     "BIRD"},
 906 #endif /* RTPROT_BIRD */
 907   {0,               NULL}
 908 };
 909
 910 /* Routing information change from the kernel. */
 911 static int
 912 netlink_route_change (struct sockaddr_nl *snl, struct nlmsghdr *h,
 913     vrf_id_t vrf_id)
 914 {
 915   int len;
 916   struct rtmsg *rtm;
 917   struct rtattr *tb[RTA_MAX + 1];
 918   u_char zebra_flags = 0;
 919
 920   char anyaddr[16] = { 0 };
 921
 922   int index;
 923   int table;
 924   u_int32_t mtu = 0;
 925
 926   void *dest;
 927   void *gate;
 928   void *src;
 929
 930   rtm = NLMSG_DATA (h);
 931
 932   if (!(h->nlmsg_type == RTM_NEWROUTE || h->nlmsg_type == RTM_DELROUTE))
 933     {
 934       /* If this is not route add/delete message print warning. */
 935       zlog_warn ("Kernel message: %d vrf %u\n", h->nlmsg_type, vrf_id);
 936       return 0;
 937     }
 938
 939   /* Connected route. */
 940   if (IS_ZEBRA_DEBUG_KERNEL)
 941     zlog_debug ("%s %s %s proto %s vrf %u",
 942                h->nlmsg_type ==
 943                RTM_NEWROUTE ? "RTM_NEWROUTE" : "RTM_DELROUTE",
 944                rtm->rtm_family == AF_INET ? "ipv4" : "ipv6",
 945                rtm->rtm_type == RTN_UNICAST ? "unicast" : "multicast",
 946                lookup (rtproto_str, rtm->rtm_protocol),
 947                vrf_id);
 948
 949   if (rtm->rtm_type != RTN_UNICAST)
 950     {
 951       return 0;
 952     }
 953
 954   table = rtm->rtm_table;
 955   if (table != RT_TABLE_MAIN && table != zebrad.rtm_table_default)
 956     {
 957       return 0;
 958     }
 959
 960   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct rtmsg));
 961   if (len < 0)
 962     return -1;
 963
 964   memset (tb, 0, sizeof tb);
 965   netlink_parse_rtattr (tb, RTA_MAX, RTM_RTA (rtm), len);
 966
 967   if (rtm->rtm_flags & RTM_F_CLONED)
 968     return 0;
 969   if (rtm->rtm_protocol == RTPROT_REDIRECT)
 970     return 0;
 971   if (rtm->rtm_protocol == RTPROT_KERNEL)
 972     return 0;
 973
 974   if (rtm->rtm_protocol == RTPROT_ZEBRA && h->nlmsg_type == RTM_NEWROUTE)
 975     return 0;
 976   if (rtm->rtm_protocol == RTPROT_ZEBRA)
 977     SET_FLAG(zebra_flags, ZEBRA_FLAG_SELFROUTE);
 978
 979   if (rtm->rtm_src_len != 0)
 980     {
 981       zlog_warn ("netlink_route_change(): no src len, vrf %u", vrf_id);
 982       return 0;
 983     }
 984
 985   index = 0;
 986   dest = NULL;
 987   gate = NULL;
 988   src = NULL;
 989
 990   if (tb[RTA_OIF])
 991     index = *(int *) RTA_DATA (tb[RTA_OIF]);
 992
 993   if (tb[RTA_DST])
 994     dest = RTA_DATA (tb[RTA_DST]);
 995   else
 996     dest = anyaddr;
 997
 998   if (tb[RTA_GATEWAY])
 999     gate = RTA_DATA (tb[RTA_GATEWAY]);
1000
1001   if (tb[RTA_PREFSRC])
1002     src = RTA_DATA (tb[RTA_PREFSRC]);
1003
1004   if (h->nlmsg_type == RTM_NEWROUTE)
1005     {
1006       if (tb[RTA_METRICS])
1007         {
1008           struct rtattr *mxrta[RTAX_MAX+1];
1009
1010           memset (mxrta, 0, sizeof mxrta);
1011           netlink_parse_rtattr (mxrta, RTAX_MAX, RTA_DATA(tb[RTA_METRICS]),
1012                                 RTA_PAYLOAD(tb[RTA_METRICS]));
1013
1014           if (mxrta[RTAX_MTU])
1015             mtu = *(u_int32_t *) RTA_DATA(mxrta[RTAX_MTU]);
1016         }
1017     }
1018
1019   if (rtm->rtm_family == AF_INET)
1020     {
1021       struct prefix_ipv4 p;
1022       p.family = AF_INET;
1023       memcpy (&p.prefix, dest, 4);
1024       p.prefixlen = rtm->rtm_dst_len;
1025
1026       if (IS_ZEBRA_DEBUG_KERNEL)
1027         {
1028           char buf[PREFIX_STRLEN];
1029           zlog_debug ("%s %s vrf %u",
1030                       h->nlmsg_type == RTM_NEWROUTE ? "RTM_NEWROUTE" : "RTM_DELROUTE",
1031                       prefix2str (&p, buf, sizeof(buf)), vrf_id);
1032         }
1033
1034       if (h->nlmsg_type == RTM_NEWROUTE)
1035         {
1036           if (!tb[RTA_MULTIPATH])
1037             rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, 0, &p, gate, src, index, vrf_id,
1038                           table, 0, mtu, 0, SAFI_UNICAST);
1039           else
1040             {
1041               /* This is a multipath route */
1042
1043               struct rib *rib;
1044               struct rtnexthop *rtnh =
1045                 (struct rtnexthop *) RTA_DATA (tb[RTA_MULTIPATH]);
1046
1047               len = RTA_PAYLOAD (tb[RTA_MULTIPATH]);
1048
1049               rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
1050               rib->type = ZEBRA_ROUTE_KERNEL;
1051               rib->distance = 0;
1052               rib->flags = 0;
1053               rib->metric = 0;
1054               rib->mtu = mtu;
1055               rib->vrf_id = vrf_id;
1056               rib->table = table;
1057               rib->nexthop_num = 0;
1058               rib->uptime = time (NULL);
1059
1060               for (;;)
1061                 {
1062                   if (len < (int) sizeof (*rtnh) || rtnh->rtnh_len > len)
1063                     break;
1064
1065                   index = rtnh->rtnh_ifindex;
1066                   gate = 0;
1067                   if (rtnh->rtnh_len > sizeof (*rtnh))
1068                     {
1069                       memset (tb, 0, sizeof (tb));
1070                       netlink_parse_rtattr (tb, RTA_MAX, RTNH_DATA (rtnh),
1071                                             rtnh->rtnh_len - sizeof (*rtnh));
1072                       if (tb[RTA_GATEWAY])
1073                         gate = RTA_DATA (tb[RTA_GATEWAY]);
1074                     }
1075
1076                   if (gate)
1077                     {
1078                       if (index)
1079                         rib_nexthop_ipv4_ifindex_add (rib, gate, src, index);
1080                       else
1081                         rib_nexthop_ipv4_add (rib, gate, src);
1082                     }
1083                   else
1084                     rib_nexthop_ifindex_add (rib, index);
1085
1086                   len -= NLMSG_ALIGN(rtnh->rtnh_len);
1087                   rtnh = RTNH_NEXT(rtnh);
1088                 }
1089
1090               if (rib->nexthop_num == 0)
1091                 XFREE (MTYPE_RIB, rib);
1092               else
1093                 rib_add_ipv4_multipath (&p, rib, SAFI_UNICAST);
1094             }
1095         }
1096       else
1097         rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p, gate,
1098                          index, vrf_id, SAFI_UNICAST);
1099     }
1100
1101 #ifdef HAVE_IPV6
1102   if (rtm->rtm_family == AF_INET6)
1103     {
1104       struct prefix_ipv6 p;
1105
1106       p.family = AF_INET6;
1107       memcpy (&p.prefix, dest, 16);
1108       p.prefixlen = rtm->rtm_dst_len;
1109
1110       if (IS_ZEBRA_DEBUG_KERNEL)
1111         {
1112           char buf[PREFIX_STRLEN];
1113           zlog_debug ("%s %s vrf %u",
1114                       h->nlmsg_type == RTM_NEWROUTE ? "RTM_NEWROUTE" : "RTM_DELROUTE",
1115                       prefix2str (&p, buf, sizeof(buf)), vrf_id);
1116         }
1117
1118       if (h->nlmsg_type == RTM_NEWROUTE)
1119         rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, 0, &p, gate, index, vrf_id, table,
1120                       0, mtu, 0, SAFI_UNICAST);
1121       else
1122         rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p, gate, index, vrf_id,
1123                          SAFI_UNICAST);
1124     }
1125 #endif /* HAVE_IPV6 */
1126
1127   return 0;
1128 }
1129
1130 static int
1131 netlink_link_change (struct sockaddr_nl *snl, struct nlmsghdr *h,
1132     vrf_id_t vrf_id)
1133 {
1134   int len;
1135   struct ifinfomsg *ifi;
1136   struct rtattr *tb[IFLA_MAX + 1];
1137   struct interface *ifp;
1138   char *name;
1139
1140   ifi = NLMSG_DATA (h);
1141
1142   if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK))
1143     {
1144       /* If this is not link add/delete message so print warning. */
1145       zlog_warn ("netlink_link_change: wrong kernel message %d vrf %u\n",
1146                  h->nlmsg_type, vrf_id);
1147       return 0;
1148     }
1149
1150   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
1151   if (len < 0)
1152     return -1;
1153
1154   /* Looking up interface name. */
1155   memset (tb, 0, sizeof tb);
1156   netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
1157
1158 #ifdef IFLA_WIRELESS
1159   /* check for wireless messages to ignore */
1160   if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
1161     {
1162       if (IS_ZEBRA_DEBUG_KERNEL)
1163         zlog_debug ("%s: ignoring IFLA_WIRELESS message, vrf %u", __func__,
1164                     vrf_id);
1165       return 0;
1166     }
1167 #endif /* IFLA_WIRELESS */
1168
1169   if (tb[IFLA_IFNAME] == NULL)
1170     return -1;
1171   name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
1172
1173   /* Add interface. */
1174   if (h->nlmsg_type == RTM_NEWLINK)
1175     {
1176       ifp = if_lookup_by_name_vrf (name, vrf_id);
1177
1178       if (ifp == NULL || !CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
1179         {
1180           if (ifp == NULL)
1181             ifp = if_get_by_name_vrf (name, vrf_id);
1182
1183           set_ifindex(ifp, ifi->ifi_index);
1184           ifp->flags = ifi->ifi_flags & 0x0000fffff;
1185           ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
1186           ifp->metric = 0;
1187
1188           netlink_interface_update_hw_addr (tb, ifp);
1189
1190           /* If new link is added. */
1191           if_add_update (ifp);
1192         }
1193       else
1194         {
1195           /* Interface status change. */
1196           set_ifindex(ifp, ifi->ifi_index);
1197           ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
1198           ifp->metric = 0;
1199
1200           netlink_interface_update_hw_addr (tb, ifp);
1201
1202           if (if_is_operative (ifp))
1203             {
1204               ifp->flags = ifi->ifi_flags & 0x0000fffff;
1205               if (!if_is_operative (ifp))
1206                 if_down (ifp);
1207               else
1208                 /* Must notify client daemons of new interface status. */
1209                 zebra_interface_up_update (ifp);
1210             }
1211           else
1212             {
1213               ifp->flags = ifi->ifi_flags & 0x0000fffff;
1214               if (if_is_operative (ifp))
1215                 if_up (ifp);
1216             }
1217         }
1218     }
1219   else
1220     {
1221       /* RTM_DELLINK. */
1222       ifp = if_lookup_by_name_vrf (name, vrf_id);
1223
1224       if (ifp == NULL)
1225         {
1226           zlog_warn ("interface %s vrf %u is deleted but can't find",
1227                      name, vrf_id);
1228           return 0;
1229         }
1230
1231       if_delete_update (ifp);
1232     }
1233
1234   return 0;
1235 }
1236
1237 static int
1238 netlink_information_fetch (struct sockaddr_nl *snl, struct nlmsghdr *h,
1239     vrf_id_t vrf_id)
1240 {
1241   /* JF: Ignore messages that aren't from the kernel */
1242   if ( snl->nl_pid != 0 )
1243     {
1244       zlog ( NULL, LOG_ERR, "Ignoring message from pid %u", snl->nl_pid );
1245       return 0;
1246     }
1247
1248   switch (h->nlmsg_type)
1249     {
1250     case RTM_NEWROUTE:
1251       return netlink_route_change (snl, h, vrf_id);
1252       break;
1253     case RTM_DELROUTE:
1254       return netlink_route_change (snl, h, vrf_id);
1255       break;
1256     case RTM_NEWLINK:
1257       return netlink_link_change (snl, h, vrf_id);
1258       break;
1259     case RTM_DELLINK:
1260       return netlink_link_change (snl, h, vrf_id);
1261       break;
1262     case RTM_NEWADDR:
1263       return netlink_interface_addr (snl, h, vrf_id);
1264       break;
1265     case RTM_DELADDR:
1266       return netlink_interface_addr (snl, h, vrf_id);
1267       break;
1268     default:
1269       zlog_warn ("Unknown netlink nlmsg_type %d vrf %u\n", h->nlmsg_type,
1270                  vrf_id);
1271       break;
1272     }
1273   return 0;
1274 }
1275
1276 /* Interface lookup by netlink socket. */
1277 int
1278 interface_lookup_netlink (struct zebra_vrf *zvrf)
1279 {
1280   int ret;
1281
1282   /* Get interface information. */
1283   ret = netlink_request (AF_PACKET, RTM_GETLINK, &zvrf->netlink_cmd);
1284   if (ret < 0)
1285     return ret;
1286   ret = netlink_parse_info (netlink_interface, &zvrf->netlink_cmd, zvrf);
1287   if (ret < 0)
1288     return ret;
1289
1290   /* Get IPv4 address of the interfaces. */
1291   ret = netlink_request (AF_INET, RTM_GETADDR, &zvrf->netlink_cmd);
1292   if (ret < 0)
1293     return ret;
1294   ret = netlink_parse_info (netlink_interface_addr, &zvrf->netlink_cmd, zvrf);
1295   if (ret < 0)
1296     return ret;
1297
1298 #ifdef HAVE_IPV6
1299   /* Get IPv6 address of the interfaces. */
1300   ret = netlink_request (AF_INET6, RTM_GETADDR, &zvrf->netlink_cmd);
1301   if (ret < 0)
1302     return ret;
1303   ret = netlink_parse_info (netlink_interface_addr, &zvrf->netlink_cmd, zvrf);
1304   if (ret < 0)
1305     return ret;
1306 #endif /* HAVE_IPV6 */
1307
1308   return 0;
1309 }
1310
1311 /* Routing table read function using netlink interface.  Only called
1312    bootstrap time. */
1313 int
1314 netlink_route_read (struct zebra_vrf *zvrf)
1315 {
1316   int ret;
1317
1318   /* Get IPv4 routing table. */
1319   ret = netlink_request (AF_INET, RTM_GETROUTE, &zvrf->netlink_cmd);
1320   if (ret < 0)
1321     return ret;
1322   ret = netlink_parse_info (netlink_routing_table, &zvrf->netlink_cmd, zvrf);
1323   if (ret < 0)
1324     return ret;
1325
1326 #ifdef HAVE_IPV6
1327   /* Get IPv6 routing table. */
1328   ret = netlink_request (AF_INET6, RTM_GETROUTE, &zvrf->netlink_cmd);
1329   if (ret < 0)
1330     return ret;
1331   ret = netlink_parse_info (netlink_routing_table, &zvrf->netlink_cmd, zvrf);
1332   if (ret < 0)
1333     return ret;
1334 #endif /* HAVE_IPV6 */
1335
1336   return 0;
1337 }
1338
1339 /* Utility function  comes from iproute2.
1340    Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> */
1341 int
1342 addattr_l (struct nlmsghdr *n, size_t maxlen, int type, void *data, size_t alen)
1343 {
1344   size_t len;
1345   struct rtattr *rta;
1346
1347   len = RTA_LENGTH (alen);
1348
1349   if (NLMSG_ALIGN (n->nlmsg_len) + len > maxlen)
1350     return -1;
1351
1352   rta = (struct rtattr *) (((char *) n) + NLMSG_ALIGN (n->nlmsg_len));
1353   rta->rta_type = type;
1354   rta->rta_len = len;
1355   memcpy (RTA_DATA (rta), data, alen);
1356   n->nlmsg_len = NLMSG_ALIGN (n->nlmsg_len) + len;
1357
1358   return 0;
1359 }
1360
1361 int
1362 rta_addattr_l (struct rtattr *rta, size_t maxlen, int type, void *data,
1363                size_t alen)
1364 {
1365   size_t len;
1366   struct rtattr *subrta;
1367
1368   len = RTA_LENGTH (alen);
1369
1370   if (RTA_ALIGN (rta->rta_len) + len > maxlen)
1371     return -1;
1372
1373   subrta = (struct rtattr *) (((char *) rta) + RTA_ALIGN (rta->rta_len));
1374   subrta->rta_type = type;
1375   subrta->rta_len = len;
1376   memcpy (RTA_DATA (subrta), data, alen);
1377   rta->rta_len = NLMSG_ALIGN (rta->rta_len) + len;
1378
1379   return 0;
1380 }
1381
1382 /* Utility function comes from iproute2.
1383    Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> */
1384 int
1385 addattr32 (struct nlmsghdr *n, size_t maxlen, int type, int data)
1386 {
1387   size_t len;
1388   struct rtattr *rta;
1389
1390   len = RTA_LENGTH (4);
1391
1392   if (NLMSG_ALIGN (n->nlmsg_len) + len > maxlen)
1393     return -1;
1394
1395   rta = (struct rtattr *) (((char *) n) + NLMSG_ALIGN (n->nlmsg_len));
1396   rta->rta_type = type;
1397   rta->rta_len = len;
1398   memcpy (RTA_DATA (rta), &data, 4);
1399   n->nlmsg_len = NLMSG_ALIGN (n->nlmsg_len) + len;
1400
1401   return 0;
1402 }
1403
1404 static int
1405 netlink_talk_filter (struct sockaddr_nl *snl, struct nlmsghdr *h,
1406     vrf_id_t vrf_id)
1407 {
1408   zlog_warn ("netlink_talk: ignoring message type 0x%04x vrf %u", h->nlmsg_type,
1409              vrf_id);
1410   return 0;
1411 }
1412
1413 /* sendmsg() to netlink socket then recvmsg(). */
1414 static int
1415 netlink_talk (struct nlmsghdr *n, struct nlsock *nl, struct zebra_vrf *zvrf)
1416 {
1417   int status;
1418   struct sockaddr_nl snl;
1419   struct iovec iov = {
1420     .iov_base = (void *) n,
1421     .iov_len = n->nlmsg_len
1422   };
1423   struct msghdr msg = {
1424     .msg_name = (void *) &snl,
1425     .msg_namelen = sizeof snl,
1426     .msg_iov = &iov,
1427     .msg_iovlen = 1,
1428   };
1429   int save_errno;
1430
1431   memset (&snl, 0, sizeof snl);
1432   snl.nl_family = AF_NETLINK;
1433
1434   n->nlmsg_seq = ++nl->seq;
1435
1436   /* Request an acknowledgement by setting NLM_F_ACK */
1437   n->nlmsg_flags |= NLM_F_ACK;
1438
1439   if (IS_ZEBRA_DEBUG_KERNEL)
1440     zlog_debug ("netlink_talk: %s type %s(%u), seq=%u", nl->name,
1441                lookup (nlmsg_str, n->nlmsg_type), n->nlmsg_type,
1442                n->nlmsg_seq);
1443
1444   /* Send message to netlink interface. */
1445   if (zserv_privs.change (ZPRIVS_RAISE))
1446     zlog (NULL, LOG_ERR, "Can't raise privileges");
1447   status = sendmsg (nl->sock, &msg, 0);
1448   save_errno = errno;
1449   if (zserv_privs.change (ZPRIVS_LOWER))
1450     zlog (NULL, LOG_ERR, "Can't lower privileges");
1451
1452   if (status < 0)
1453     {
1454       zlog (NULL, LOG_ERR, "netlink_talk sendmsg() error: %s",
1455             safe_strerror (save_errno));
1456       return -1;
1457     }
1458
1459
1460   /*
1461    * Get reply from netlink socket.
1462    * The reply should either be an acknowlegement or an error.
1463    */
1464   return netlink_parse_info (netlink_talk_filter, nl, zvrf);
1465 }
1466
1467 /* This function takes a nexthop as argument and adds
1468  * the appropriate netlink attributes to an existing
1469  * netlink message.
1470  *
1471  * @param routedesc: Human readable description of route type
1472  *                   (direct/recursive, single-/multipath)
1473  * @param bytelen: Length of addresses in bytes.
1474  * @param nexthop: Nexthop information
1475  * @param nlmsg: nlmsghdr structure to fill in.
1476  * @param req_size: The size allocated for the message.
1477  */
1478 static void
1479 _netlink_route_build_singlepath(
1480         const char *routedesc,
1481         int bytelen,
1482         struct nexthop *nexthop,
1483         struct nlmsghdr *nlmsg,
1484         struct rtmsg *rtmsg,
1485         size_t req_size)
1486 {
1487   if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ONLINK))
1488     rtmsg->rtm_flags |= RTNH_F_ONLINK;
1489   if (nexthop->type == NEXTHOP_TYPE_IPV4
1490       || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1491     {
1492       addattr_l (nlmsg, req_size, RTA_GATEWAY,
1493                  &nexthop->gate.ipv4, bytelen);
1494       if (nexthop->src.ipv4.s_addr)
1495         addattr_l (nlmsg, req_size, RTA_PREFSRC,
1496                    &nexthop->src.ipv4, bytelen);
1497
1498       if (IS_ZEBRA_DEBUG_KERNEL)
1499         zlog_debug("netlink_route_multipath() (%s): "
1500                    "nexthop via %s if %u",
1501                    routedesc,
1502                    inet_ntoa (nexthop->gate.ipv4),
1503                    nexthop->ifindex);
1504     }
1505 #ifdef HAVE_IPV6
1506   if (nexthop->type == NEXTHOP_TYPE_IPV6
1507       || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
1508       || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1509     {
1510       addattr_l (nlmsg, req_size, RTA_GATEWAY,
1511                  &nexthop->gate.ipv6, bytelen);
1512
1513       if (IS_ZEBRA_DEBUG_KERNEL)
1514         zlog_debug("netlink_route_multipath() (%s): "
1515                    "nexthop via %s if %u",
1516                    routedesc,
1517                    inet6_ntoa (nexthop->gate.ipv6),
1518                    nexthop->ifindex);
1519     }
1520 #endif /* HAVE_IPV6 */
1521   if (nexthop->type == NEXTHOP_TYPE_IFINDEX
1522       || nexthop->type == NEXTHOP_TYPE_IFNAME
1523       || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1524     {
1525       addattr32 (nlmsg, req_size, RTA_OIF, nexthop->ifindex);
1526
1527       if (nexthop->src.ipv4.s_addr)
1528         addattr_l (nlmsg, req_size, RTA_PREFSRC,
1529                    &nexthop->src.ipv4, bytelen);
1530
1531       if (IS_ZEBRA_DEBUG_KERNEL)
1532         zlog_debug("netlink_route_multipath() (%s): "
1533                    "nexthop via if %u", routedesc, nexthop->ifindex);
1534     }
1535
1536   if (nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX
1537       || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME)
1538     {
1539       addattr32 (nlmsg, req_size, RTA_OIF, nexthop->ifindex);
1540
1541       if (IS_ZEBRA_DEBUG_KERNEL)
1542         zlog_debug("netlink_route_multipath() (%s): "
1543                    "nexthop via if %u", routedesc, nexthop->ifindex);
1544     }
1545 }
1546
1547 /* This function takes a nexthop as argument and
1548  * appends to the given rtattr/rtnexthop pair the
1549  * representation of the nexthop. If the nexthop
1550  * defines a preferred source, the src parameter
1551  * will be modified to point to that src, otherwise
1552  * it will be kept unmodified.
1553  *
1554  * @param routedesc: Human readable description of route type
1555  *                   (direct/recursive, single-/multipath)
1556  * @param bytelen: Length of addresses in bytes.
1557  * @param nexthop: Nexthop information
1558  * @param rta: rtnetlink attribute structure
1559  * @param rtnh: pointer to an rtnetlink nexthop structure
1560  * @param src: pointer pointing to a location where
1561  *             the prefsrc should be stored.
1562  */
1563 static void
1564 _netlink_route_build_multipath(
1565         const char *routedesc,
1566         int bytelen,
1567         struct nexthop *nexthop,
1568         struct rtattr *rta,
1569         struct rtnexthop *rtnh,
1570         union g_addr **src
1571         )
1572 {
1573   rtnh->rtnh_len = sizeof (*rtnh);
1574   rtnh->rtnh_flags = 0;
1575   rtnh->rtnh_hops = 0;
1576   rta->rta_len += rtnh->rtnh_len;
1577
1578   if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ONLINK))
1579     rtnh->rtnh_flags |= RTNH_F_ONLINK;
1580
1581   if (nexthop->type == NEXTHOP_TYPE_IPV4
1582       || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1583     {
1584       rta_addattr_l (rta, NL_PKT_BUF_SIZE, RTA_GATEWAY,
1585                      &nexthop->gate.ipv4, bytelen);
1586       rtnh->rtnh_len += sizeof (struct rtattr) + bytelen;
1587
1588       if (nexthop->src.ipv4.s_addr)
1589         *src = &nexthop->src;
1590
1591       if (IS_ZEBRA_DEBUG_KERNEL)
1592         zlog_debug("netlink_route_multipath() (%s): "
1593                    "nexthop via %s if %u",
1594                    routedesc,
1595                    inet_ntoa (nexthop->gate.ipv4),
1596                    nexthop->ifindex);
1597     }
1598 #ifdef HAVE_IPV6
1599   if (nexthop->type == NEXTHOP_TYPE_IPV6
1600       || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
1601       || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1602     {
1603       rta_addattr_l (rta, NL_PKT_BUF_SIZE, RTA_GATEWAY,
1604                      &nexthop->gate.ipv6, bytelen);
1605       rtnh->rtnh_len += sizeof (struct rtattr) + bytelen;
1606
1607       if (IS_ZEBRA_DEBUG_KERNEL)
1608         zlog_debug("netlink_route_multipath() (%s): "
1609                    "nexthop via %s if %u",
1610                    routedesc,
1611                    inet6_ntoa (nexthop->gate.ipv6),
1612                    nexthop->ifindex);
1613     }
1614 #endif /* HAVE_IPV6 */
1615   /* ifindex */
1616   if (nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX
1617       || nexthop->type == NEXTHOP_TYPE_IFINDEX
1618       || nexthop->type == NEXTHOP_TYPE_IFNAME)
1619     {
1620       rtnh->rtnh_ifindex = nexthop->ifindex;
1621       if (nexthop->src.ipv4.s_addr)
1622         *src = &nexthop->src;
1623       if (IS_ZEBRA_DEBUG_KERNEL)
1624         zlog_debug("netlink_route_multipath() (%s): "
1625                    "nexthop via if %u", routedesc, nexthop->ifindex);
1626     }
1627   else if (nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
1628       || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1629     {
1630       rtnh->rtnh_ifindex = nexthop->ifindex;
1631
1632       if (IS_ZEBRA_DEBUG_KERNEL)
1633         zlog_debug("netlink_route_multipath() (%s): "
1634                    "nexthop via if %u", routedesc, nexthop->ifindex);
1635     }
1636   else
1637     {
1638       rtnh->rtnh_ifindex = 0;
1639     }
1640 }
1641
1642 /* Log debug information for netlink_route_multipath
1643  * if debug logging is enabled.
1644  *
1645  * @param cmd: Netlink command which is to be processed
1646  * @param p: Prefix for which the change is due
1647  * @param nexthop: Nexthop which is currently processed
1648  * @param routedesc: Semantic annotation for nexthop
1649  *                     (recursive, multipath, etc.)
1650  * @param family: Address family which the change concerns
1651  */
1652 static void
1653 _netlink_route_debug(
1654         int cmd,
1655         struct prefix *p,
1656         struct nexthop *nexthop,
1657         const char *routedesc,
1658         int family,
1659         struct zebra_vrf *zvrf)
1660 {
1661   if (IS_ZEBRA_DEBUG_KERNEL)
1662     {
1663       char buf[PREFIX_STRLEN];
1664       zlog_debug ("netlink_route_multipath() (%s): %s %s vrf %u type %s",
1665          routedesc,
1666          lookup (nlmsg_str, cmd),
1667          prefix2str (p, buf, sizeof(buf)),
1668          zvrf->vrf_id,
1669          nexthop_type_to_str (nexthop->type));
1670     }
1671 }
1672
1673 /* Routing table change via netlink interface. */
1674 static int
1675 netlink_route_multipath (int cmd, struct prefix *p, struct rib *rib)
1676 {
1677   int bytelen;
1678   struct sockaddr_nl snl;
1679   struct nexthop *nexthop = NULL, *tnexthop;
1680   int recursing;
1681   int nexthop_num;
1682   int discard;
1683   int family = PREFIX_FAMILY(p);
1684   const char *routedesc;
1685
1686   struct
1687   {
1688     struct nlmsghdr n;
1689     struct rtmsg r;
1690     char buf[NL_PKT_BUF_SIZE];
1691   } req;
1692
1693   struct zebra_vrf *zvrf = vrf_info_lookup (rib->vrf_id);
1694
1695   memset (&req, 0, sizeof req - NL_PKT_BUF_SIZE);
1696
1697   bytelen = (family == AF_INET ? 4 : 16);
1698
1699   req.n.nlmsg_len = NLMSG_LENGTH (sizeof (struct rtmsg));
1700   req.n.nlmsg_flags = NLM_F_CREATE | NLM_F_REPLACE | NLM_F_REQUEST;
1701   req.n.nlmsg_type = cmd;
1702   req.r.rtm_family = family;
1703   req.r.rtm_table = rib->table;
1704   req.r.rtm_dst_len = p->prefixlen;
1705   req.r.rtm_protocol = RTPROT_ZEBRA;
1706   req.r.rtm_scope = RT_SCOPE_LINK;
1707
1708   if ((rib->flags & ZEBRA_FLAG_BLACKHOLE) || (rib->flags & ZEBRA_FLAG_REJECT))
1709     discard = 1;
1710   else
1711     discard = 0;
1712
1713   if (cmd == RTM_NEWROUTE)
1714     {
1715       if (discard)
1716         {
1717           if (rib->flags & ZEBRA_FLAG_BLACKHOLE)
1718             req.r.rtm_type = RTN_BLACKHOLE;
1719           else if (rib->flags & ZEBRA_FLAG_REJECT)
1720             req.r.rtm_type = RTN_UNREACHABLE;
1721           else
1722             assert (RTN_BLACKHOLE != RTN_UNREACHABLE);  /* false */
1723         }
1724       else
1725         req.r.rtm_type = RTN_UNICAST;
1726     }
1727
1728   addattr_l (&req.n, sizeof req, RTA_DST, &p->u.prefix, bytelen);
1729
1730   /* Metric. */
1731   addattr32 (&req.n, sizeof req, RTA_PRIORITY, NL_DEFAULT_ROUTE_METRIC);
1732
1733   if (rib->mtu || rib->nexthop_mtu)
1734     {
1735       char buf[NL_PKT_BUF_SIZE];
1736       struct rtattr *rta = (void *) buf;
1737       u_int32_t mtu = rib->mtu;
1738       if (!mtu || (rib->nexthop_mtu && rib->nexthop_mtu < mtu))
1739         mtu = rib->nexthop_mtu;
1740       rta->rta_type = RTA_METRICS;
1741       rta->rta_len = RTA_LENGTH(0);
1742       rta_addattr_l (rta, NL_PKT_BUF_SIZE, RTAX_MTU, &mtu, sizeof mtu);
1743       addattr_l (&req.n, NL_PKT_BUF_SIZE, RTA_METRICS, RTA_DATA (rta),
1744                  RTA_PAYLOAD (rta));
1745     }
1746
1747   if (discard)
1748     {
1749       if (cmd == RTM_NEWROUTE)
1750         for (ALL_NEXTHOPS_RO(rib->nexthop, nexthop, tnexthop, recursing))
1751           {
1752             /* We shouldn't encounter recursive nexthops on discard routes,
1753              * but it is probably better to handle that case correctly anyway.
1754              */
1755             if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1756               continue;
1757             SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1758           }
1759       goto skip;
1760     }
1761
1762   /* Count overall nexthops so we can decide whether to use singlepath
1763    * or multipath case. */
1764   nexthop_num = 0;
1765   for (ALL_NEXTHOPS_RO(rib->nexthop, nexthop, tnexthop, recursing))
1766     {
1767       if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1768         continue;
1769       if (cmd == RTM_NEWROUTE && !CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
1770         continue;
1771       if (cmd == RTM_DELROUTE && !CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
1772         continue;
1773
1774       if (nexthop->type != NEXTHOP_TYPE_IFINDEX &&
1775           nexthop->type != NEXTHOP_TYPE_IFNAME)
1776         req.r.rtm_scope = RT_SCOPE_UNIVERSE;
1777
1778       nexthop_num++;
1779     }
1780
1781   /* Singlepath case. */
1782   if (nexthop_num == 1 || MULTIPATH_NUM == 1)
1783     {
1784       nexthop_num = 0;
1785       for (ALL_NEXTHOPS_RO(rib->nexthop, nexthop, tnexthop, recursing))
1786         {
1787           if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1788             continue;
1789
1790           if ((cmd == RTM_NEWROUTE
1791                && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
1792               || (cmd == RTM_DELROUTE
1793                   && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
1794             {
1795               routedesc = recursing ? "recursive, 1 hop" : "single hop";
1796
1797               _netlink_route_debug(cmd, p, nexthop, routedesc, family, zvrf);
1798               _netlink_route_build_singlepath(routedesc, bytelen,
1799                                               nexthop, &req.n, &req.r,
1800                                               sizeof req);
1801
1802               if (cmd == RTM_NEWROUTE)
1803                 SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1804
1805               nexthop_num++;
1806               break;
1807             }
1808         }
1809     }
1810   else
1811     {
1812       char buf[NL_PKT_BUF_SIZE];
1813       struct rtattr *rta = (void *) buf;
1814       struct rtnexthop *rtnh;
1815       union g_addr *src = NULL;
1816
1817       rta->rta_type = RTA_MULTIPATH;
1818       rta->rta_len = RTA_LENGTH (0);
1819       rtnh = RTA_DATA (rta);
1820
1821       nexthop_num = 0;
1822       for (ALL_NEXTHOPS_RO(rib->nexthop, nexthop, tnexthop, recursing))
1823         {
1824           if (nexthop_num >= MULTIPATH_NUM)
1825             break;
1826
1827           if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1828             continue;
1829
1830           if ((cmd == RTM_NEWROUTE
1831                && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
1832               || (cmd == RTM_DELROUTE
1833                   && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
1834             {
1835               routedesc = recursing ? "recursive, multihop" : "multihop";
1836               nexthop_num++;
1837
1838               _netlink_route_debug(cmd, p, nexthop,
1839                                    routedesc, family, zvrf);
1840               _netlink_route_build_multipath(routedesc, bytelen,
1841                                              nexthop, rta, rtnh, &src);
1842               rtnh = RTNH_NEXT (rtnh);
1843
1844               if (cmd == RTM_NEWROUTE)
1845                 SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1846             }
1847         }
1848       if (src)
1849         addattr_l (&req.n, sizeof req, RTA_PREFSRC, &src->ipv4, bytelen);
1850
1851       if (rta->rta_len > RTA_LENGTH (0))
1852         addattr_l (&req.n, NL_PKT_BUF_SIZE, RTA_MULTIPATH, RTA_DATA (rta),
1853                    RTA_PAYLOAD (rta));
1854     }
1855
1856   /* If there is no useful nexthop then return. */
1857   if (nexthop_num == 0)
1858     {
1859       if (IS_ZEBRA_DEBUG_KERNEL)
1860         zlog_debug ("netlink_route_multipath(): No useful nexthop.");
1861       return 0;
1862     }
1863
1864 skip:
1865
1866   /* Destination netlink address. */
1867   memset (&snl, 0, sizeof snl);
1868   snl.nl_family = AF_NETLINK;
1869
1870   /* Talk to netlink socket. */
1871   return netlink_talk (&req.n, &zvrf->netlink_cmd, zvrf);
1872 }
1873
1874 int
1875 kernel_route_rib (struct prefix *p, struct rib *old, struct rib *new)
1876 {
1877   if (!old && new)
1878     return netlink_route_multipath (RTM_NEWROUTE, p, new);
1879   if (old && !new)
1880     return netlink_route_multipath (RTM_DELROUTE, p, old);
1881
1882    /* Replace, can be done atomically if metric does not change;
1883     * netlink uses [prefix, tos, priority] to identify prefix.
1884     * Now metric is not sent to kernel, so we can just do atomic replace. */
1885   return netlink_route_multipath (RTM_NEWROUTE, p, new);
1886 }
1887
1888 /* Interface address modification. */
1889 static int
1890 netlink_address (int cmd, int family, struct interface *ifp,
1891                  struct connected *ifc)
1892 {
1893   int bytelen;
1894   struct prefix *p;
1895
1896   struct
1897   {
1898     struct nlmsghdr n;
1899     struct ifaddrmsg ifa;
1900     char buf[NL_PKT_BUF_SIZE];
1901   } req;
1902
1903   struct zebra_vrf *zvrf = vrf_info_lookup (ifp->vrf_id);
1904
1905   p = ifc->address;
1906   memset (&req, 0, sizeof req - NL_PKT_BUF_SIZE);
1907
1908   bytelen = (family == AF_INET ? 4 : 16);
1909
1910   req.n.nlmsg_len = NLMSG_LENGTH (sizeof (struct ifaddrmsg));
1911   req.n.nlmsg_flags = NLM_F_REQUEST;
1912   req.n.nlmsg_type = cmd;
1913   req.ifa.ifa_family = family;
1914
1915   req.ifa.ifa_index = ifp->ifindex;
1916   req.ifa.ifa_prefixlen = p->prefixlen;
1917
1918   addattr_l (&req.n, sizeof req, IFA_LOCAL, &p->u.prefix, bytelen);
1919
1920   if (family == AF_INET && cmd == RTM_NEWADDR)
1921     {
1922       if (!CONNECTED_PEER(ifc) && ifc->destination)
1923         {
1924           p = ifc->destination;
1925           addattr_l (&req.n, sizeof req, IFA_BROADCAST, &p->u.prefix,
1926                      bytelen);
1927         }
1928     }
1929
1930   if (CHECK_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY))
1931     SET_FLAG (req.ifa.ifa_flags, IFA_F_SECONDARY);
1932
1933   if (ifc->label)
1934     addattr_l (&req.n, sizeof req, IFA_LABEL, ifc->label,
1935                strlen (ifc->label) + 1);
1936
1937   return netlink_talk (&req.n, &zvrf->netlink_cmd, zvrf);
1938 }
1939
1940 int
1941 kernel_address_add_ipv4 (struct interface *ifp, struct connected *ifc)
1942 {
1943   return netlink_address (RTM_NEWADDR, AF_INET, ifp, ifc);
1944 }
1945
1946 int
1947 kernel_address_delete_ipv4 (struct interface *ifp, struct connected *ifc)
1948 {
1949   return netlink_address (RTM_DELADDR, AF_INET, ifp, ifc);
1950 }
1951
1952
1953 extern struct thread_master *master;
1954
1955 /* Kernel route reflection. */
1956 static int
1957 kernel_read (struct thread *thread)
1958 {
1959   struct zebra_vrf *zvrf = (struct zebra_vrf *)THREAD_ARG (thread);
1960   netlink_parse_info (netlink_information_fetch, &zvrf->netlink, zvrf);
1961   zvrf->t_netlink = thread_add_read (zebrad.master, kernel_read, zvrf,
1962                                      zvrf->netlink.sock);
1963
1964   return 0;
1965 }
1966
1967 /* Filter out messages from self that occur on listener socket,
1968    caused by our actions on the command socket
1969  */
1970 static void netlink_install_filter (int sock, __u32 pid)
1971 {
1972   struct sock_filter filter[] = {
1973     /* 0: ldh [4]                 */
1974     BPF_STMT(BPF_LD|BPF_ABS|BPF_H, offsetof(struct nlmsghdr, nlmsg_type)),
1975     /* 1: jeq 0x18 jt 3 jf 6  */
1976     BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htons(RTM_NEWROUTE), 1, 0),
1977     /* 2: jeq 0x19 jt 3 jf 6  */
1978     BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htons(RTM_DELROUTE), 0, 3),
1979     /* 3: ldw [12]                */
1980     BPF_STMT(BPF_LD|BPF_ABS|BPF_W, offsetof(struct nlmsghdr, nlmsg_pid)),
1981     /* 4: jeq XX  jt 5 jf 6   */
1982     BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htonl(pid), 0, 1),
1983     /* 5: ret 0    (skip)     */
1984     BPF_STMT(BPF_RET|BPF_K, 0),
1985     /* 6: ret 0xffff (keep)   */
1986     BPF_STMT(BPF_RET|BPF_K, 0xffff),
1987   };
1988
1989   struct sock_fprog prog = {
1990     .len = array_size(filter),
1991     .filter = filter,
1992   };
1993
1994   if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)) < 0)
1995     zlog_warn ("Can't install socket filter: %s\n", safe_strerror(errno));
1996 }
1997
1998 /* Exported interface function.  This function simply calls
1999    netlink_socket (). */
2000 void
2001 kernel_init (struct zebra_vrf *zvrf)
2002 {
2003   unsigned long groups;
2004
2005   groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE | RTMGRP_IPV4_IFADDR;
2006 #ifdef HAVE_IPV6
2007   groups |= RTMGRP_IPV6_ROUTE | RTMGRP_IPV6_IFADDR;
2008 #endif /* HAVE_IPV6 */
2009   netlink_socket (&zvrf->netlink, groups, zvrf->vrf_id);
2010   netlink_socket (&zvrf->netlink_cmd, 0, zvrf->vrf_id);
2011
2012   /* Register kernel socket. */
2013   if (zvrf->netlink.sock > 0)
2014     {
2015       size_t bufsize = MAX(nl_rcvbufsize, 2 * sysconf(_SC_PAGESIZE));
2016
2017       /* Only want non-blocking on the netlink event socket */
2018       if (fcntl (zvrf->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
2019         zlog_err ("Can't set %s socket flags: %s", zvrf->netlink.name,
2020                   safe_strerror (errno));
2021
2022       /* Set receive buffer size if it's set from command line */
2023       if (nl_rcvbufsize)
2024         netlink_recvbuf (&zvrf->netlink, nl_rcvbufsize);
2025
2026       nl_rcvbuf.p = XMALLOC (MTYPE_NETLINK_RCVBUF, bufsize);
2027       nl_rcvbuf.size = bufsize;
2028
2029       netlink_install_filter (zvrf->netlink.sock, zvrf->netlink_cmd.snl.nl_pid);
2030       zvrf->t_netlink = thread_add_read (zebrad.master, kernel_read, zvrf,
2031                                          zvrf->netlink.sock);
2032     }
2033 }
2034
2035 void
2036 kernel_terminate (struct zebra_vrf *zvrf)
2037 {
2038   THREAD_READ_OFF (zvrf->t_netlink);
2039
2040   if (zvrf->netlink.sock >= 0)
2041     {
2042       close (zvrf->netlink.sock);
2043       zvrf->netlink.sock = -1;
2044     }
2045
2046   if (zvrf->netlink_cmd.sock >= 0)
2047     {
2048       close (zvrf->netlink_cmd.sock);
2049       zvrf->netlink_cmd.sock = -1;
2050     }
2051 }
2052
2053 /*
2054  * nl_msg_type_to_str
2055  */
2056 const char *
2057 nl_msg_type_to_str (uint16_t msg_type)
2058 {
2059   return lookup (nlmsg_str, msg_type);
2060 }
2061
2062 /*
2063  * nl_rtproto_to_str
2064  */
2065 const char *
2066 nl_rtproto_to_str (u_char rtproto)
2067 {
2068   return lookup (rtproto_str, rtproto);
2069 }