zebra/if_netlink.c

   1 /*
   2  * Interface looking up by netlink.
   3  * Copyright (C) 1998 Kunihiro Ishiguro
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23 #include <net/if_arp.h>
  24 #include <linux/sockios.h>
  25 #include <linux/ethtool.h>
  26
  27 #include "linklist.h"
  28 #include "if.h"
  29 #include "log.h"
  30 #include "prefix.h"
  31 #include "connected.h"
  32 #include "table.h"
  33 #include "memory.h"
  34 #include "zebra_memory.h"
  35 #include "rib.h"
  36 #include "thread.h"
  37 #include "privs.h"
  38 #include "nexthop.h"
  39 #include "vrf.h"
  40 #include "vrf_int.h"
  41 #include "mpls.h"
  42
  43 #include "vty.h"
  44 #include "zebra/zserv.h"
  45 #include "zebra/zebra_ns.h"
  46 #include "zebra/zebra_vrf.h"
  47 #include "zebra/rt.h"
  48 #include "zebra/redistribute.h"
  49 #include "zebra/interface.h"
  50 #include "zebra/debug.h"
  51 #include "zebra/rtadv.h"
  52 #include "zebra/zebra_ptm.h"
  53 #include "zebra/zebra_mpls.h"
  54 #include "zebra/kernel_netlink.h"
  55 #include "zebra/if_netlink.h"
  56
  57
  58 /* Note: on netlink systems, there should be a 1-to-1 mapping between interface
  59    names and ifindex values. */
  60 static void
  61 set_ifindex(struct interface *ifp, ifindex_t ifi_index, struct zebra_ns *zns)
  62 {
  63   struct interface *oifp;
  64
  65   if (((oifp = if_lookup_by_index_per_ns (zns, ifi_index)) != NULL) && (oifp != ifp))
  66     {
  67       if (ifi_index == IFINDEX_INTERNAL)
  68         zlog_err("Netlink is setting interface %s ifindex to reserved "
  69                  "internal value %u", ifp->name, ifi_index);
  70       else
  71         {
  72           if (IS_ZEBRA_DEBUG_KERNEL)
  73             zlog_debug("interface index %d was renamed from %s to %s",
  74                       ifi_index, oifp->name, ifp->name);
  75           if (if_is_up(oifp))
  76             zlog_err("interface rename detected on up interface: index %d "
  77                      "was renamed from %s to %s, results are uncertain!",
  78                     ifi_index, oifp->name, ifp->name);
  79           if_delete_update(oifp);
  80         }
  81     }
  82   ifp->ifindex = ifi_index;
  83 }
  84
  85 /* Utility function to parse hardware link-layer address and update ifp */
  86 static void
  87 netlink_interface_update_hw_addr (struct rtattr **tb, struct interface *ifp)
  88 {
  89   int i;
  90
  91   if (tb[IFLA_ADDRESS])
  92     {
  93       int hw_addr_len;
  94
  95       hw_addr_len = RTA_PAYLOAD (tb[IFLA_ADDRESS]);
  96
  97       if (hw_addr_len > INTERFACE_HWADDR_MAX)
  98         zlog_warn ("Hardware address is too large: %d", hw_addr_len);
  99       else
 100         {
 101           ifp->hw_addr_len = hw_addr_len;
 102           memcpy (ifp->hw_addr, RTA_DATA (tb[IFLA_ADDRESS]), hw_addr_len);
 103
 104           for (i = 0; i < hw_addr_len; i++)
 105             if (ifp->hw_addr[i] != 0)
 106               break;
 107
 108           if (i == hw_addr_len)
 109             ifp->hw_addr_len = 0;
 110           else
 111             ifp->hw_addr_len = hw_addr_len;
 112         }
 113     }
 114 }
 115
 116 static enum zebra_link_type
 117 netlink_to_zebra_link_type (unsigned int hwt)
 118 {
 119   switch (hwt)
 120   {
 121     case ARPHRD_ETHER: return ZEBRA_LLT_ETHER;
 122     case ARPHRD_EETHER: return ZEBRA_LLT_EETHER;
 123     case ARPHRD_AX25: return ZEBRA_LLT_AX25;
 124     case ARPHRD_PRONET: return ZEBRA_LLT_PRONET;
 125     case ARPHRD_IEEE802: return ZEBRA_LLT_IEEE802;
 126     case ARPHRD_ARCNET: return ZEBRA_LLT_ARCNET;
 127     case ARPHRD_APPLETLK: return ZEBRA_LLT_APPLETLK;
 128     case ARPHRD_DLCI: return ZEBRA_LLT_DLCI;
 129     case ARPHRD_ATM: return ZEBRA_LLT_ATM;
 130     case ARPHRD_METRICOM: return ZEBRA_LLT_METRICOM;
 131     case ARPHRD_IEEE1394: return ZEBRA_LLT_IEEE1394;
 132     case ARPHRD_EUI64: return ZEBRA_LLT_EUI64;
 133     case ARPHRD_INFINIBAND: return ZEBRA_LLT_INFINIBAND;
 134     case ARPHRD_SLIP: return ZEBRA_LLT_SLIP;
 135     case ARPHRD_CSLIP: return ZEBRA_LLT_CSLIP;
 136     case ARPHRD_SLIP6: return ZEBRA_LLT_SLIP6;
 137     case ARPHRD_CSLIP6: return ZEBRA_LLT_CSLIP6;
 138     case ARPHRD_RSRVD: return ZEBRA_LLT_RSRVD;
 139     case ARPHRD_ADAPT: return ZEBRA_LLT_ADAPT;
 140     case ARPHRD_ROSE: return ZEBRA_LLT_ROSE;
 141     case ARPHRD_X25: return ZEBRA_LLT_X25;
 142     case ARPHRD_PPP: return ZEBRA_LLT_PPP;
 143     case ARPHRD_CISCO: return ZEBRA_LLT_CHDLC;
 144     case ARPHRD_LAPB: return ZEBRA_LLT_LAPB;
 145     case ARPHRD_RAWHDLC: return ZEBRA_LLT_RAWHDLC;
 146     case ARPHRD_TUNNEL: return ZEBRA_LLT_IPIP;
 147     case ARPHRD_TUNNEL6: return ZEBRA_LLT_IPIP6;
 148     case ARPHRD_FRAD: return ZEBRA_LLT_FRAD;
 149     case ARPHRD_SKIP: return ZEBRA_LLT_SKIP;
 150     case ARPHRD_LOOPBACK: return ZEBRA_LLT_LOOPBACK;
 151     case ARPHRD_LOCALTLK: return ZEBRA_LLT_LOCALTLK;
 152     case ARPHRD_FDDI: return ZEBRA_LLT_FDDI;
 153     case ARPHRD_SIT: return ZEBRA_LLT_SIT;
 154     case ARPHRD_IPDDP: return ZEBRA_LLT_IPDDP;
 155     case ARPHRD_IPGRE: return ZEBRA_LLT_IPGRE;
 156     case ARPHRD_PIMREG: return ZEBRA_LLT_PIMREG;
 157     case ARPHRD_HIPPI: return ZEBRA_LLT_HIPPI;
 158     case ARPHRD_ECONET: return ZEBRA_LLT_ECONET;
 159     case ARPHRD_IRDA: return ZEBRA_LLT_IRDA;
 160     case ARPHRD_FCPP: return ZEBRA_LLT_FCPP;
 161     case ARPHRD_FCAL: return ZEBRA_LLT_FCAL;
 162     case ARPHRD_FCPL: return ZEBRA_LLT_FCPL;
 163     case ARPHRD_FCFABRIC: return ZEBRA_LLT_FCFABRIC;
 164     case ARPHRD_IEEE802_TR: return ZEBRA_LLT_IEEE802_TR;
 165     case ARPHRD_IEEE80211: return ZEBRA_LLT_IEEE80211;
 166     case ARPHRD_IEEE802154: return ZEBRA_LLT_IEEE802154;
 167 #ifdef ARPHRD_IP6GRE
 168     case ARPHRD_IP6GRE: return ZEBRA_LLT_IP6GRE;
 169 #endif
 170 #ifdef ARPHRD_IEEE802154_PHY
 171     case ARPHRD_IEEE802154_PHY: return ZEBRA_LLT_IEEE802154_PHY;
 172 #endif
 173
 174     default: return ZEBRA_LLT_UNKNOWN;
 175   }
 176 }
 177
 178
 179 //Temporary Assignments to compile on older platforms.
 180 #ifndef IFLA_BR_MAX
 181 #define IFLA_BR_MAX   39
 182 #endif
 183
 184 #ifndef IFLA_VXLAN_ID
 185 #define IFLA_VXLAN_ID 1
 186 #endif
 187
 188 #ifndef IFLA_VXLAN_LOCAL
 189 #define IFLA_VXLAN_LOCAL  4
 190 #endif
 191
 192 #ifndef IFLA_VXLAN_MAX
 193 #define IFLA_VXLAN_MAX 26
 194 #endif
 195
 196 #ifndef IFLA_BRIDGE_MAX
 197 #define IFLA_BRIDGE_MAX   2
 198 #endif
 199
 200 #ifndef IFLA_BRIDGE_VLAN_INFO
 201 #define IFLA_BRIDGE_VLAN_INFO 2
 202 #endif
 203
 204 #ifndef BRIDGE_VLAN_INFO_PVID
 205 #define BRIDGE_VLAN_INFO_PVID  (1<<1)
 206 #endif
 207
 208 #ifndef RTEXT_FILTER_BRVLAN
 209 #define RTEXT_FILTER_BRVLAN    (1<<1)
 210 #endif
 211
 212 #ifndef NTF_SELF
 213 #define NTF_SELF   0x02
 214 #endif
 215
 216 #ifndef IFLA_BR_VLAN_FILTERING
 217 #define IFLA_BR_VLAN_FILTERING  7
 218 #endif
 219
 220 #define parse_rtattr_nested(tb, max, rta) \
 221           netlink_parse_rtattr((tb), (max), RTA_DATA(rta), RTA_PAYLOAD(rta))
 222
 223 static void
 224 netlink_vrf_change (struct nlmsghdr *h, struct rtattr *tb, const char *name)
 225 {
 226   struct ifinfomsg *ifi;
 227   struct rtattr *linkinfo[IFLA_INFO_MAX+1];
 228   struct rtattr *attr[IFLA_VRF_MAX+1];
 229   struct vrf *vrf;
 230   struct zebra_vrf *zvrf;
 231   u_int32_t nl_table_id;
 232
 233   ifi = NLMSG_DATA (h);
 234
 235   memset (linkinfo, 0, sizeof linkinfo);
 236   parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb);
 237
 238   if (!linkinfo[IFLA_INFO_DATA]) {
 239     if (IS_ZEBRA_DEBUG_KERNEL)
 240       zlog_debug ("%s: IFLA_INFO_DATA missing from VRF message: %s", __func__, name);
 241     return;
 242   }
 243
 244   memset (attr, 0, sizeof attr);
 245   parse_rtattr_nested(attr, IFLA_VRF_MAX, linkinfo[IFLA_INFO_DATA]);
 246   if (!attr[IFLA_VRF_TABLE]) {
 247     if (IS_ZEBRA_DEBUG_KERNEL)
 248       zlog_debug ("%s: IFLA_VRF_TABLE missing from VRF message: %s", __func__, name);
 249     return;
 250   }
 251
 252   nl_table_id = *(u_int32_t *)RTA_DATA(attr[IFLA_VRF_TABLE]);
 253
 254   if (h->nlmsg_type == RTM_NEWLINK)
 255     {
 256       if (IS_ZEBRA_DEBUG_KERNEL)
 257         zlog_debug ("RTM_NEWLINK for VRF %s(%u) table %u",
 258                     name, ifi->ifi_index, nl_table_id);
 259
 260       /*
 261        * vrf_get is implied creation if it does not exist
 262        */
 263       vrf = vrf_get((vrf_id_t)ifi->ifi_index, name); // It would create vrf
 264       if (!vrf)
 265         {
 266           zlog_err ("VRF %s id %u not created", name, ifi->ifi_index);
 267           return;
 268         }
 269
 270       /* Enable the created VRF. */
 271       if (!vrf_enable (vrf))
 272         {
 273           zlog_err ("Failed to enable VRF %s id %u", name, ifi->ifi_index);
 274           return;
 275         }
 276
 277       /*
 278        * This is the only place that we get the actual kernel table_id
 279        * being used.  We need it to set the table_id of the routes
 280        * we are passing to the kernel.... And to throw some totally
 281        * awesome parties. that too.
 282        */
 283       zvrf = (struct zebra_vrf *)vrf->info;
 284       zvrf->table_id = nl_table_id;
 285     }
 286   else //h->nlmsg_type == RTM_DELLINK
 287     {
 288       if (IS_ZEBRA_DEBUG_KERNEL)
 289         zlog_debug ("RTM_DELLINK for VRF %s(%u)", name, ifi->ifi_index);
 290
 291       vrf = vrf_lookup_by_id ((vrf_id_t)ifi->ifi_index);
 292
 293       if (!vrf)
 294         {
 295           zlog_warn ("%s: vrf not found", __func__);
 296           return;
 297         }
 298
 299       vrf_delete (vrf);
 300     }
 301 }
 302
 303 static int
 304 get_iflink_speed (const char *ifname)
 305 {
 306   struct ifreq ifdata;
 307   struct ethtool_cmd ecmd;
 308   int sd;
 309   int rc;
 310
 311   /* initialize struct */
 312   memset(&ifdata, 0, sizeof(ifdata));
 313
 314   /* set interface name */
 315   strcpy(ifdata.ifr_name, ifname);
 316
 317   /* initialize ethtool interface */
 318   memset(&ecmd, 0, sizeof(ecmd));
 319   ecmd.cmd = ETHTOOL_GSET;  /* ETHTOOL_GLINK */
 320   ifdata.ifr_data = (__caddr_t) &ecmd;
 321
 322   /* use ioctl to get IP address of an interface */
 323   sd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 324   if(sd < 0) {
 325     zlog_debug ("Failure to read interface %s speed: %d %s",
 326                 ifname, errno, safe_strerror(errno));
 327     return 0;
 328   }
 329
 330   /* Get the current link state for the interface */
 331   rc = ioctl(sd, SIOCETHTOOL, (char *)&ifdata);
 332   if(rc < 0) {
 333     zlog_debug("IOCTL failure to read interface %s speed: %d %s",
 334                ifname, errno, safe_strerror(errno));
 335     ecmd.speed_hi = 0;
 336     ecmd.speed = 0;
 337   }
 338
 339   close(sd);
 340
 341   return (ecmd.speed_hi << 16 ) | ecmd.speed;
 342 }
 343
 344 /* Called from interface_lookup_netlink().  This function is only used
 345    during bootstrap. */
 346 static int
 347 netlink_interface (struct sockaddr_nl *snl, struct nlmsghdr *h,
 348                    ns_id_t ns_id, int startup)
 349 {
 350   int len;
 351   struct ifinfomsg *ifi;
 352   struct rtattr *tb[IFLA_MAX + 1];
 353   struct rtattr *linkinfo[IFLA_MAX + 1];
 354   struct interface *ifp;
 355   char *name = NULL;
 356   char *kind = NULL;
 357   char *slave_kind = NULL;
 358   int vrf_device = 0;
 359   struct zebra_ns *zns;
 360   vrf_id_t vrf_id = VRF_DEFAULT;
 361
 362   zns = zebra_ns_lookup (ns_id);
 363   ifi = NLMSG_DATA (h);
 364
 365   if (h->nlmsg_type != RTM_NEWLINK)
 366     return 0;
 367
 368   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
 369   if (len < 0)
 370     return -1;
 371
 372   if (ifi->ifi_family == AF_BRIDGE)
 373     return 0;
 374
 375   /* Looking up interface name. */
 376   memset (tb, 0, sizeof tb);
 377   netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
 378
 379 #ifdef IFLA_WIRELESS
 380   /* check for wireless messages to ignore */
 381   if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
 382     {
 383       if (IS_ZEBRA_DEBUG_KERNEL)
 384         zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
 385       return 0;
 386     }
 387 #endif /* IFLA_WIRELESS */
 388
 389   if (tb[IFLA_IFNAME] == NULL)
 390     return -1;
 391   name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
 392
 393   if (tb[IFLA_LINKINFO])
 394     {
 395       memset (linkinfo, 0, sizeof linkinfo);
 396       parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
 397
 398       if (linkinfo[IFLA_INFO_KIND])
 399         kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
 400
 401 #if HAVE_DECL_IFLA_INFO_SLAVE_KIND
 402       if (linkinfo[IFLA_INFO_SLAVE_KIND])
 403          slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
 404 #endif
 405
 406       if (kind && strcmp(kind, "vrf") == 0)
 407         {
 408           vrf_device = 1;
 409           netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
 410           vrf_id = (vrf_id_t)ifi->ifi_index;
 411         }
 412     }
 413
 414   if (tb[IFLA_MASTER])
 415     {
 416       if (slave_kind && (strcmp(slave_kind, "vrf") == 0))
 417         vrf_id = *(u_int32_t *)RTA_DATA(tb[IFLA_MASTER]);
 418     }
 419
 420   /* Add interface. */
 421   ifp = if_get_by_name (name, vrf_id);
 422   set_ifindex(ifp, ifi->ifi_index, zns);
 423   ifp->flags = ifi->ifi_flags & 0x0000fffff;
 424   if (vrf_device)
 425     SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
 426   ifp->mtu6 = ifp->mtu = *(uint32_t *) RTA_DATA (tb[IFLA_MTU]);
 427   ifp->metric = 0;
 428   ifp->speed = get_iflink_speed (name);
 429   ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
 430
 431   /* Hardware type and address. */
 432   ifp->ll_type = netlink_to_zebra_link_type (ifi->ifi_type);
 433   netlink_interface_update_hw_addr (tb, ifp);
 434
 435   if_add_update (ifp);
 436
 437   return 0;
 438 }
 439
 440 /* Interface lookup by netlink socket. */
 441 int
 442 interface_lookup_netlink (struct zebra_ns *zns)
 443 {
 444   int ret;
 445
 446   /* Get interface information. */
 447   ret = netlink_request (AF_PACKET, RTM_GETLINK, &zns->netlink_cmd);
 448   if (ret < 0)
 449     return ret;
 450   ret = netlink_parse_info (netlink_interface, &zns->netlink_cmd, zns, 0, 1);
 451   if (ret < 0)
 452     return ret;
 453
 454   /* Get IPv4 address of the interfaces. */
 455   ret = netlink_request (AF_INET, RTM_GETADDR, &zns->netlink_cmd);
 456   if (ret < 0)
 457     return ret;
 458   ret = netlink_parse_info (netlink_interface_addr, &zns->netlink_cmd, zns, 0, 1);
 459   if (ret < 0)
 460     return ret;
 461
 462   /* Get IPv6 address of the interfaces. */
 463   ret = netlink_request (AF_INET6, RTM_GETADDR, &zns->netlink_cmd);
 464   if (ret < 0)
 465     return ret;
 466   ret = netlink_parse_info (netlink_interface_addr, &zns->netlink_cmd, zns, 0, 1);
 467   if (ret < 0)
 468     return ret;
 469
 470   return 0;
 471 }
 472
 473 /* Interface address modification. */
 474 static int
 475 netlink_address (int cmd, int family, struct interface *ifp,
 476                  struct connected *ifc)
 477 {
 478   int bytelen;
 479   struct prefix *p;
 480
 481   struct
 482   {
 483     struct nlmsghdr n;
 484     struct ifaddrmsg ifa;
 485     char buf[NL_PKT_BUF_SIZE];
 486   } req;
 487
 488   struct zebra_ns *zns = zebra_ns_lookup (NS_DEFAULT);
 489
 490   p = ifc->address;
 491   memset (&req, 0, sizeof req - NL_PKT_BUF_SIZE);
 492
 493   bytelen = (family == AF_INET ? 4 : 16);
 494
 495   req.n.nlmsg_len = NLMSG_LENGTH (sizeof (struct ifaddrmsg));
 496   req.n.nlmsg_flags = NLM_F_REQUEST;
 497   req.n.nlmsg_type = cmd;
 498   req.ifa.ifa_family = family;
 499
 500   req.ifa.ifa_index = ifp->ifindex;
 501   req.ifa.ifa_prefixlen = p->prefixlen;
 502
 503   addattr_l (&req.n, sizeof req, IFA_LOCAL, &p->u.prefix, bytelen);
 504
 505   if (family == AF_INET && cmd == RTM_NEWADDR)
 506     {
 507       if (!CONNECTED_PEER(ifc) && ifc->destination)
 508         {
 509           p = ifc->destination;
 510           addattr_l (&req.n, sizeof req, IFA_BROADCAST, &p->u.prefix,
 511                      bytelen);
 512         }
 513     }
 514
 515   if (CHECK_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY))
 516     SET_FLAG (req.ifa.ifa_flags, IFA_F_SECONDARY);
 517
 518   if (ifc->label)
 519     addattr_l (&req.n, sizeof req, IFA_LABEL, ifc->label,
 520                strlen (ifc->label) + 1);
 521
 522   return netlink_talk (netlink_talk_filter, &req.n, &zns->netlink_cmd, zns, 0);
 523 }
 524
 525 int
 526 kernel_address_add_ipv4 (struct interface *ifp, struct connected *ifc)
 527 {
 528   return netlink_address (RTM_NEWADDR, AF_INET, ifp, ifc);
 529 }
 530
 531 int
 532 kernel_address_delete_ipv4 (struct interface *ifp, struct connected *ifc)
 533 {
 534   return netlink_address (RTM_DELADDR, AF_INET, ifp, ifc);
 535 }
 536
 537 int
 538 netlink_interface_addr (struct sockaddr_nl *snl, struct nlmsghdr *h,
 539                         ns_id_t ns_id, int startup)
 540 {
 541   int len;
 542   struct ifaddrmsg *ifa;
 543   struct rtattr *tb[IFA_MAX + 1];
 544   struct interface *ifp;
 545   void *addr;
 546   void *broad;
 547   u_char flags = 0;
 548   char *label = NULL;
 549   struct zebra_ns *zns;
 550
 551   zns = zebra_ns_lookup (ns_id);
 552   ifa = NLMSG_DATA (h);
 553
 554   if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6)
 555     return 0;
 556
 557   if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
 558     return 0;
 559
 560   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifaddrmsg));
 561   if (len < 0)
 562     return -1;
 563
 564   memset (tb, 0, sizeof tb);
 565   netlink_parse_rtattr (tb, IFA_MAX, IFA_RTA (ifa), len);
 566
 567   ifp = if_lookup_by_index_per_ns (zns, ifa->ifa_index);
 568   if (ifp == NULL)
 569     {
 570       zlog_err ("netlink_interface_addr can't find interface by index %d",
 571                 ifa->ifa_index);
 572       return -1;
 573     }
 574
 575   if (IS_ZEBRA_DEBUG_KERNEL)    /* remove this line to see initial ifcfg */
 576     {
 577       char buf[BUFSIZ];
 578       zlog_debug ("netlink_interface_addr %s %s flags 0x%x:",
 579                  nl_msg_type_to_str (h->nlmsg_type), ifp->name,
 580                  ifa->ifa_flags);
 581       if (tb[IFA_LOCAL])
 582         zlog_debug ("  IFA_LOCAL     %s/%d",
 583                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_LOCAL]),
 584                                buf, BUFSIZ), ifa->ifa_prefixlen);
 585       if (tb[IFA_ADDRESS])
 586         zlog_debug ("  IFA_ADDRESS   %s/%d",
 587                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_ADDRESS]),
 588                                buf, BUFSIZ), ifa->ifa_prefixlen);
 589       if (tb[IFA_BROADCAST])
 590         zlog_debug ("  IFA_BROADCAST %s/%d",
 591                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_BROADCAST]),
 592                                buf, BUFSIZ), ifa->ifa_prefixlen);
 593       if (tb[IFA_LABEL] && strcmp (ifp->name, RTA_DATA (tb[IFA_LABEL])))
 594         zlog_debug ("  IFA_LABEL     %s", (char *)RTA_DATA (tb[IFA_LABEL]));
 595
 596       if (tb[IFA_CACHEINFO])
 597         {
 598           struct ifa_cacheinfo *ci = RTA_DATA (tb[IFA_CACHEINFO]);
 599           zlog_debug ("  IFA_CACHEINFO pref %d, valid %d",
 600                       ci->ifa_prefered, ci->ifa_valid);
 601         }
 602     }
 603
 604   /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
 605   if (tb[IFA_LOCAL] == NULL)
 606     tb[IFA_LOCAL] = tb[IFA_ADDRESS];
 607   if (tb[IFA_ADDRESS] == NULL)
 608     tb[IFA_ADDRESS] = tb[IFA_LOCAL];
 609
 610   /* local interface address */
 611   addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
 612
 613   /* is there a peer address? */
 614   if (tb[IFA_ADDRESS] &&
 615       memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_ADDRESS])))
 616     {
 617       broad = RTA_DATA(tb[IFA_ADDRESS]);
 618       SET_FLAG (flags, ZEBRA_IFA_PEER);
 619     }
 620   else
 621     /* seeking a broadcast address */
 622     broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST]) : NULL);
 623
 624   /* addr is primary key, SOL if we don't have one */
 625   if (addr == NULL)
 626     {
 627       zlog_debug ("%s: NULL address", __func__);
 628       return -1;
 629     }
 630
 631   /* Flags. */
 632   if (ifa->ifa_flags & IFA_F_SECONDARY)
 633     SET_FLAG (flags, ZEBRA_IFA_SECONDARY);
 634
 635   /* Label */
 636   if (tb[IFA_LABEL])
 637     label = (char *) RTA_DATA (tb[IFA_LABEL]);
 638
 639   if (ifp && label && strcmp (ifp->name, label) == 0)
 640     label = NULL;
 641
 642   /* Register interface address to the interface. */
 643   if (ifa->ifa_family == AF_INET)
 644     {
 645       if (h->nlmsg_type == RTM_NEWADDR)
 646         connected_add_ipv4 (ifp, flags,
 647                             (struct in_addr *) addr, ifa->ifa_prefixlen,
 648                             (struct in_addr *) broad, label);
 649       else
 650         connected_delete_ipv4 (ifp, flags,
 651                                (struct in_addr *) addr, ifa->ifa_prefixlen,
 652                                (struct in_addr *) broad);
 653     }
 654   if (ifa->ifa_family == AF_INET6)
 655     {
 656       if (h->nlmsg_type == RTM_NEWADDR)
 657         {
 658           /* Only consider valid addresses; we'll not get a notification from
 659            * the kernel till IPv6 DAD has completed, but at init time, Quagga
 660            * does query for and will receive all addresses.
 661            */
 662           if (!(ifa->ifa_flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE)))
 663             connected_add_ipv6 (ifp, flags, (struct in6_addr *) addr,
 664                     ifa->ifa_prefixlen, (struct in6_addr *) broad, label);
 665         }
 666       else
 667         connected_delete_ipv6 (ifp,
 668                                (struct in6_addr *) addr, ifa->ifa_prefixlen,
 669                                (struct in6_addr *) broad);
 670     }
 671
 672   return 0;
 673 }
 674
 675 int
 676 netlink_link_change (struct sockaddr_nl *snl, struct nlmsghdr *h,
 677                      ns_id_t ns_id, int startup)
 678 {
 679   int len;
 680   struct ifinfomsg *ifi;
 681   struct rtattr *tb[IFLA_MAX + 1];
 682   struct rtattr *linkinfo[IFLA_MAX + 1];
 683   struct interface *ifp;
 684   char *name = NULL;
 685   char *kind = NULL;
 686   char *slave_kind = NULL;
 687   int vrf_device = 0;
 688   struct zebra_ns *zns;
 689   vrf_id_t vrf_id = VRF_DEFAULT;
 690
 691   zns = zebra_ns_lookup (ns_id);
 692   ifi = NLMSG_DATA (h);
 693
 694   if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK))
 695     {
 696       /* If this is not link add/delete message so print warning. */
 697       zlog_warn ("netlink_link_change: wrong kernel message %d",
 698                  h->nlmsg_type);
 699       return 0;
 700     }
 701
 702   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
 703   if (len < 0)
 704     return -1;
 705
 706   if (ifi->ifi_family == AF_BRIDGE)
 707     return 0;
 708
 709   /* Looking up interface name. */
 710   memset (tb, 0, sizeof tb);
 711   netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
 712
 713 #ifdef IFLA_WIRELESS
 714   /* check for wireless messages to ignore */
 715   if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
 716     {
 717       if (IS_ZEBRA_DEBUG_KERNEL)
 718         zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
 719       return 0;
 720     }
 721 #endif /* IFLA_WIRELESS */
 722
 723   if (tb[IFLA_IFNAME] == NULL)
 724     return -1;
 725   name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
 726
 727   if (tb[IFLA_LINKINFO])
 728     {
 729       memset (linkinfo, 0, sizeof linkinfo);
 730       parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
 731
 732       if (linkinfo[IFLA_INFO_KIND])
 733         kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
 734
 735 #if HAVE_DECL_IFLA_INFO_SLAVE_KIND
 736       if (linkinfo[IFLA_INFO_SLAVE_KIND])
 737           slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
 738 #endif
 739
 740       if (kind && strcmp(kind, "vrf") == 0)
 741         {
 742           vrf_device = 1;
 743           netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
 744           vrf_id = (vrf_id_t)ifi->ifi_index;
 745         }
 746     }
 747
 748   /* See if interface is present. */
 749   ifp = if_lookup_by_name_per_ns (zns, name);
 750
 751   if (h->nlmsg_type == RTM_NEWLINK)
 752     {
 753       if (tb[IFLA_MASTER])
 754         {
 755           if (slave_kind && (strcmp(slave_kind, "vrf") == 0))
 756             vrf_id = *(u_int32_t *)RTA_DATA(tb[IFLA_MASTER]);
 757         }
 758
 759       if (ifp == NULL || !CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
 760         {
 761           /* Add interface notification from kernel */
 762           if (IS_ZEBRA_DEBUG_KERNEL)
 763             zlog_debug ("RTM_NEWLINK for %s(%u) (ifp %p) vrf_id %u flags 0x%x",
 764                         name, ifi->ifi_index, ifp, vrf_id, ifi->ifi_flags);
 765
 766           if (ifp == NULL)
 767             {
 768               /* unknown interface */
 769               ifp = if_get_by_name (name, vrf_id);
 770             }
 771           else
 772             {
 773               /* pre-configured interface, learnt now */
 774               if (ifp->vrf_id != vrf_id)
 775                 if_update (ifp, name, strlen(name), vrf_id);
 776             }
 777
 778           /* Update interface information. */
 779           set_ifindex(ifp, ifi->ifi_index, zns);
 780           ifp->flags = ifi->ifi_flags & 0x0000fffff;
 781           if (vrf_device)
 782             SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
 783           ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
 784           ifp->metric = 0;
 785           ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
 786
 787           netlink_interface_update_hw_addr (tb, ifp);
 788
 789           /* Inform clients, install any configured addresses. */
 790           if_add_update (ifp);
 791         }
 792       else if (ifp->vrf_id != vrf_id)
 793         {
 794           /* VRF change for an interface. */
 795           if (IS_ZEBRA_DEBUG_KERNEL)
 796             zlog_debug ("RTM_NEWLINK vrf-change for %s(%u) "
 797                         "vrf_id %u -> %u flags 0x%x",
 798                         name, ifp->ifindex, ifp->vrf_id,
 799                         vrf_id, ifi->ifi_flags);
 800
 801           if_handle_vrf_change (ifp, vrf_id);
 802         }
 803       else
 804         {
 805           /* Interface status change. */
 806           if (IS_ZEBRA_DEBUG_KERNEL)
 807              zlog_debug ("RTM_NEWLINK status for %s(%u) flags 0x%x",
 808                           name, ifp->ifindex, ifi->ifi_flags);
 809
 810           set_ifindex(ifp, ifi->ifi_index, zns);
 811           ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
 812           ifp->metric = 0;
 813
 814           netlink_interface_update_hw_addr (tb, ifp);
 815
 816           if (if_is_no_ptm_operative (ifp))
 817             {
 818               ifp->flags = ifi->ifi_flags & 0x0000fffff;
 819               if (!if_is_no_ptm_operative (ifp))
 820                 if_down (ifp);
 821               else if (if_is_operative (ifp))
 822                 /* Must notify client daemons of new interface status. */
 823                 zebra_interface_up_update (ifp);
 824             }
 825           else
 826             {
 827               ifp->flags = ifi->ifi_flags & 0x0000fffff;
 828               if (if_is_operative (ifp))
 829                 if_up (ifp);
 830             }
 831         }
 832     }
 833   else
 834     {
 835       /* Delete interface notification from kernel */
 836       if (ifp == NULL)
 837         {
 838           zlog_warn ("RTM_DELLINK for unknown interface %s(%u)",
 839                      name, ifi->ifi_index);
 840           return 0;
 841         }
 842
 843       if (IS_ZEBRA_DEBUG_KERNEL)
 844         zlog_debug ("RTM_DELLINK for %s(%u)", name, ifp->ifindex);
 845
 846       UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
 847
 848       if (!vrf_device)
 849         if_delete_update (ifp);
 850     }
 851
 852   return 0;
 853 }
 854
 855 /* Interface information read by netlink. */
 856 void
 857 interface_list (struct zebra_ns *zns)
 858 {
 859   interface_lookup_netlink (zns);
 860 }