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.n.nlmsg_pid = zns->netlink_cmd.snl.nl_pid;
 499
 500   req.ifa.ifa_family = family;
 501
 502   req.ifa.ifa_index = ifp->ifindex;
 503   req.ifa.ifa_prefixlen = p->prefixlen;
 504
 505   addattr_l (&req.n, sizeof req, IFA_LOCAL, &p->u.prefix, bytelen);
 506
 507   if (family == AF_INET && cmd == RTM_NEWADDR)
 508     {
 509       if (!CONNECTED_PEER(ifc) && ifc->destination)
 510         {
 511           p = ifc->destination;
 512           addattr_l (&req.n, sizeof req, IFA_BROADCAST, &p->u.prefix,
 513                      bytelen);
 514         }
 515     }
 516
 517   if (CHECK_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY))
 518     SET_FLAG (req.ifa.ifa_flags, IFA_F_SECONDARY);
 519
 520   if (ifc->label)
 521     addattr_l (&req.n, sizeof req, IFA_LABEL, ifc->label,
 522                strlen (ifc->label) + 1);
 523
 524   return netlink_talk (netlink_talk_filter, &req.n, &zns->netlink_cmd, zns, 0);
 525 }
 526
 527 int
 528 kernel_address_add_ipv4 (struct interface *ifp, struct connected *ifc)
 529 {
 530   return netlink_address (RTM_NEWADDR, AF_INET, ifp, ifc);
 531 }
 532
 533 int
 534 kernel_address_delete_ipv4 (struct interface *ifp, struct connected *ifc)
 535 {
 536   return netlink_address (RTM_DELADDR, AF_INET, ifp, ifc);
 537 }
 538
 539 int
 540 netlink_interface_addr (struct sockaddr_nl *snl, struct nlmsghdr *h,
 541                         ns_id_t ns_id, int startup)
 542 {
 543   int len;
 544   struct ifaddrmsg *ifa;
 545   struct rtattr *tb[IFA_MAX + 1];
 546   struct interface *ifp;
 547   void *addr;
 548   void *broad;
 549   u_char flags = 0;
 550   char *label = NULL;
 551   struct zebra_ns *zns;
 552
 553   zns = zebra_ns_lookup (ns_id);
 554   ifa = NLMSG_DATA (h);
 555
 556   if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6)
 557     return 0;
 558
 559   if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
 560     return 0;
 561
 562   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifaddrmsg));
 563   if (len < 0)
 564     return -1;
 565
 566   memset (tb, 0, sizeof tb);
 567   netlink_parse_rtattr (tb, IFA_MAX, IFA_RTA (ifa), len);
 568
 569   ifp = if_lookup_by_index_per_ns (zns, ifa->ifa_index);
 570   if (ifp == NULL)
 571     {
 572       zlog_err ("netlink_interface_addr can't find interface by index %d",
 573                 ifa->ifa_index);
 574       return -1;
 575     }
 576
 577   if (IS_ZEBRA_DEBUG_KERNEL)    /* remove this line to see initial ifcfg */
 578     {
 579       char buf[BUFSIZ];
 580       zlog_debug ("netlink_interface_addr %s %s flags 0x%x:",
 581                  nl_msg_type_to_str (h->nlmsg_type), ifp->name,
 582                  ifa->ifa_flags);
 583       if (tb[IFA_LOCAL])
 584         zlog_debug ("  IFA_LOCAL     %s/%d",
 585                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_LOCAL]),
 586                                buf, BUFSIZ), ifa->ifa_prefixlen);
 587       if (tb[IFA_ADDRESS])
 588         zlog_debug ("  IFA_ADDRESS   %s/%d",
 589                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_ADDRESS]),
 590                                buf, BUFSIZ), ifa->ifa_prefixlen);
 591       if (tb[IFA_BROADCAST])
 592         zlog_debug ("  IFA_BROADCAST %s/%d",
 593                     inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_BROADCAST]),
 594                                buf, BUFSIZ), ifa->ifa_prefixlen);
 595       if (tb[IFA_LABEL] && strcmp (ifp->name, RTA_DATA (tb[IFA_LABEL])))
 596         zlog_debug ("  IFA_LABEL     %s", (char *)RTA_DATA (tb[IFA_LABEL]));
 597
 598       if (tb[IFA_CACHEINFO])
 599         {
 600           struct ifa_cacheinfo *ci = RTA_DATA (tb[IFA_CACHEINFO]);
 601           zlog_debug ("  IFA_CACHEINFO pref %d, valid %d",
 602                       ci->ifa_prefered, ci->ifa_valid);
 603         }
 604     }
 605
 606   /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
 607   if (tb[IFA_LOCAL] == NULL)
 608     tb[IFA_LOCAL] = tb[IFA_ADDRESS];
 609   if (tb[IFA_ADDRESS] == NULL)
 610     tb[IFA_ADDRESS] = tb[IFA_LOCAL];
 611
 612   /* local interface address */
 613   addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
 614
 615   /* is there a peer address? */
 616   if (tb[IFA_ADDRESS] &&
 617       memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_ADDRESS])))
 618     {
 619       broad = RTA_DATA(tb[IFA_ADDRESS]);
 620       SET_FLAG (flags, ZEBRA_IFA_PEER);
 621     }
 622   else
 623     /* seeking a broadcast address */
 624     broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST]) : NULL);
 625
 626   /* addr is primary key, SOL if we don't have one */
 627   if (addr == NULL)
 628     {
 629       zlog_debug ("%s: NULL address", __func__);
 630       return -1;
 631     }
 632
 633   /* Flags. */
 634   if (ifa->ifa_flags & IFA_F_SECONDARY)
 635     SET_FLAG (flags, ZEBRA_IFA_SECONDARY);
 636
 637   /* Label */
 638   if (tb[IFA_LABEL])
 639     label = (char *) RTA_DATA (tb[IFA_LABEL]);
 640
 641   if (ifp && label && strcmp (ifp->name, label) == 0)
 642     label = NULL;
 643
 644   /* Register interface address to the interface. */
 645   if (ifa->ifa_family == AF_INET)
 646     {
 647       if (h->nlmsg_type == RTM_NEWADDR)
 648         connected_add_ipv4 (ifp, flags,
 649                             (struct in_addr *) addr, ifa->ifa_prefixlen,
 650                             (struct in_addr *) broad, label);
 651       else
 652         connected_delete_ipv4 (ifp, flags,
 653                                (struct in_addr *) addr, ifa->ifa_prefixlen,
 654                                (struct in_addr *) broad);
 655     }
 656   if (ifa->ifa_family == AF_INET6)
 657     {
 658       if (h->nlmsg_type == RTM_NEWADDR)
 659         {
 660           /* Only consider valid addresses; we'll not get a notification from
 661            * the kernel till IPv6 DAD has completed, but at init time, Quagga
 662            * does query for and will receive all addresses.
 663            */
 664           if (!(ifa->ifa_flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE)))
 665             connected_add_ipv6 (ifp, flags, (struct in6_addr *) addr,
 666                     ifa->ifa_prefixlen, (struct in6_addr *) broad, label);
 667         }
 668       else
 669         connected_delete_ipv6 (ifp,
 670                                (struct in6_addr *) addr, ifa->ifa_prefixlen,
 671                                (struct in6_addr *) broad);
 672     }
 673
 674   return 0;
 675 }
 676
 677 int
 678 netlink_link_change (struct sockaddr_nl *snl, struct nlmsghdr *h,
 679                      ns_id_t ns_id, int startup)
 680 {
 681   int len;
 682   struct ifinfomsg *ifi;
 683   struct rtattr *tb[IFLA_MAX + 1];
 684   struct rtattr *linkinfo[IFLA_MAX + 1];
 685   struct interface *ifp;
 686   char *name = NULL;
 687   char *kind = NULL;
 688   char *slave_kind = NULL;
 689   int vrf_device = 0;
 690   struct zebra_ns *zns;
 691   vrf_id_t vrf_id = VRF_DEFAULT;
 692
 693   zns = zebra_ns_lookup (ns_id);
 694   ifi = NLMSG_DATA (h);
 695
 696   if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK))
 697     {
 698       /* If this is not link add/delete message so print warning. */
 699       zlog_warn ("netlink_link_change: wrong kernel message %d",
 700                  h->nlmsg_type);
 701       return 0;
 702     }
 703
 704   len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
 705   if (len < 0)
 706     return -1;
 707
 708   if (ifi->ifi_family == AF_BRIDGE)
 709     return 0;
 710
 711   /* Looking up interface name. */
 712   memset (tb, 0, sizeof tb);
 713   netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
 714
 715 #ifdef IFLA_WIRELESS
 716   /* check for wireless messages to ignore */
 717   if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
 718     {
 719       if (IS_ZEBRA_DEBUG_KERNEL)
 720         zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
 721       return 0;
 722     }
 723 #endif /* IFLA_WIRELESS */
 724
 725   if (tb[IFLA_IFNAME] == NULL)
 726     return -1;
 727   name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
 728
 729   if (tb[IFLA_LINKINFO])
 730     {
 731       memset (linkinfo, 0, sizeof linkinfo);
 732       parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
 733
 734       if (linkinfo[IFLA_INFO_KIND])
 735         kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
 736
 737 #if HAVE_DECL_IFLA_INFO_SLAVE_KIND
 738       if (linkinfo[IFLA_INFO_SLAVE_KIND])
 739           slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
 740 #endif
 741
 742       if (kind && strcmp(kind, "vrf") == 0)
 743         {
 744           vrf_device = 1;
 745           netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
 746           vrf_id = (vrf_id_t)ifi->ifi_index;
 747         }
 748     }
 749
 750   /* See if interface is present. */
 751   ifp = if_lookup_by_name_per_ns (zns, name);
 752
 753   if (h->nlmsg_type == RTM_NEWLINK)
 754     {
 755       if (tb[IFLA_MASTER])
 756         {
 757           if (slave_kind && (strcmp(slave_kind, "vrf") == 0))
 758             vrf_id = *(u_int32_t *)RTA_DATA(tb[IFLA_MASTER]);
 759         }
 760
 761       if (ifp == NULL || !CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
 762         {
 763           /* Add interface notification from kernel */
 764           if (IS_ZEBRA_DEBUG_KERNEL)
 765             zlog_debug ("RTM_NEWLINK for %s(%u) (ifp %p) vrf_id %u flags 0x%x",
 766                         name, ifi->ifi_index, ifp, vrf_id, ifi->ifi_flags);
 767
 768           if (ifp == NULL)
 769             {
 770               /* unknown interface */
 771               ifp = if_get_by_name (name, vrf_id);
 772             }
 773           else
 774             {
 775               /* pre-configured interface, learnt now */
 776               if (ifp->vrf_id != vrf_id)
 777                 if_update (ifp, name, strlen(name), vrf_id);
 778             }
 779
 780           /* Update interface information. */
 781           set_ifindex(ifp, ifi->ifi_index, zns);
 782           ifp->flags = ifi->ifi_flags & 0x0000fffff;
 783           if (vrf_device)
 784             SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
 785           ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
 786           ifp->metric = 0;
 787           ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
 788
 789           netlink_interface_update_hw_addr (tb, ifp);
 790
 791           /* Inform clients, install any configured addresses. */
 792           if_add_update (ifp);
 793         }
 794       else if (ifp->vrf_id != vrf_id)
 795         {
 796           /* VRF change for an interface. */
 797           if (IS_ZEBRA_DEBUG_KERNEL)
 798             zlog_debug ("RTM_NEWLINK vrf-change for %s(%u) "
 799                         "vrf_id %u -> %u flags 0x%x",
 800                         name, ifp->ifindex, ifp->vrf_id,
 801                         vrf_id, ifi->ifi_flags);
 802
 803           if_handle_vrf_change (ifp, vrf_id);
 804         }
 805       else
 806         {
 807           /* Interface status change. */
 808           if (IS_ZEBRA_DEBUG_KERNEL)
 809              zlog_debug ("RTM_NEWLINK status for %s(%u) flags 0x%x",
 810                           name, ifp->ifindex, ifi->ifi_flags);
 811
 812           set_ifindex(ifp, ifi->ifi_index, zns);
 813           ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
 814           ifp->metric = 0;
 815
 816           netlink_interface_update_hw_addr (tb, ifp);
 817
 818           if (if_is_no_ptm_operative (ifp))
 819             {
 820               ifp->flags = ifi->ifi_flags & 0x0000fffff;
 821               if (!if_is_no_ptm_operative (ifp))
 822                 if_down (ifp);
 823               else if (if_is_operative (ifp))
 824                 /* Must notify client daemons of new interface status. */
 825                 zebra_interface_up_update (ifp);
 826             }
 827           else
 828             {
 829               ifp->flags = ifi->ifi_flags & 0x0000fffff;
 830               if (if_is_operative (ifp))
 831                 if_up (ifp);
 832             }
 833         }
 834     }
 835   else
 836     {
 837       /* Delete interface notification from kernel */
 838       if (ifp == NULL)
 839         {
 840           zlog_warn ("RTM_DELLINK for unknown interface %s(%u)",
 841                      name, ifi->ifi_index);
 842           return 0;
 843         }
 844
 845       if (IS_ZEBRA_DEBUG_KERNEL)
 846         zlog_debug ("RTM_DELLINK for %s(%u)", name, ifp->ifindex);
 847
 848       UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
 849
 850       if (!vrf_device)
 851         if_delete_update (ifp);
 852     }
 853
 854   return 0;
 855 }
 856
 857 /* Interface information read by netlink. */
 858 void
 859 interface_list (struct zebra_ns *zns)
 860 {
 861   interface_lookup_netlink (zns);
 862 }