lib/if.c

   1
   2 /*
   3  * Interface functions.
   4  * Copyright (C) 1997, 98 Kunihiro Ishiguro
   5  *
   6  * This file is part of GNU Zebra.
   7  *
   8  * GNU Zebra is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published
  10  * by the Free Software Foundation; either version 2, or (at your
  11  * option) any later version.
  12  *
  13  * GNU Zebra is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with GNU Zebra; see the file COPYING.  If not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <zebra.h>
  25
  26 #include "linklist.h"
  27 #include "vector.h"
  28 #include "vty.h"
  29 #include "command.h"
  30 #include "vrf.h"
  31 #include "if.h"
  32 #include "sockunion.h"
  33 #include "prefix.h"
  34 #include "memory.h"
  35 #include "table.h"
  36 #include "buffer.h"
  37 #include "str.h"
  38 #include "log.h"
  39
  40 DEFINE_MTYPE(       LIB, IF,              "Interface")
  41 DEFINE_MTYPE_STATIC(LIB, CONNECTED,       "Connected")
  42 DEFINE_MTYPE_STATIC(LIB, NBR_CONNECTED,   "Neighbor Connected")
  43 DEFINE_MTYPE(       LIB, CONNECTED_LABEL, "Connected interface label")
  44 DEFINE_MTYPE_STATIC(LIB, IF_LINK_PARAMS,  "Informational Link Parameters")
  45
  46 /* List of interfaces in only the default VRF */
  47 int ptm_enable = 0;
  48
  49 /* One for each program.  This structure is needed to store hooks. */
  50 struct if_master
  51 {
  52   int (*if_new_hook) (struct interface *);
  53   int (*if_delete_hook) (struct interface *);
  54 } if_master = {0,};
  55
  56 /* Compare interface names, returning an integer greater than, equal to, or
  57  * less than 0, (following the strcmp convention), according to the
  58  * relationship between ifp1 and ifp2.  Interface names consist of an
  59  * alphabetic prefix and a numeric suffix.  The primary sort key is
  60  * lexicographic by name, and then numeric by number.  No number sorts
  61  * before all numbers.  Examples: de0 < de1, de100 < fxp0 < xl0, devpty <
  62  * devpty0, de0 < del0
  63  */
  64 int
  65 if_cmp_name_func (char *p1, char *p2)
  66 {
  67   unsigned int l1, l2;
  68   long int x1, x2;
  69   int res;
  70
  71   while (*p1 && *p2) {
  72     /* look up to any number */
  73     l1 = strcspn(p1, "0123456789");
  74     l2 = strcspn(p2, "0123456789");
  75
  76     /* name lengths are different -> compare names */
  77     if (l1 != l2)
  78       return (strcmp(p1, p2));
  79
  80     /* Note that this relies on all numbers being less than all letters, so
  81      * that de0 < del0.
  82      */
  83     res = strncmp(p1, p2, l1);
  84
  85     /* names are different -> compare them */
  86     if (res)
  87       return res;
  88
  89     /* with identical name part, go to numeric part */
  90     p1 += l1;
  91     p2 += l1;
  92
  93     if (!*p1)
  94       return -1;
  95     if (!*p2)
  96       return 1;
  97
  98     x1 = strtol(p1, &p1, 10);
  99     x2 = strtol(p2, &p2, 10);
 100
 101     /* let's compare numbers now */
 102     if (x1 < x2)
 103       return -1;
 104     if (x1 > x2)
 105       return 1;
 106
 107     /* numbers were equal, lets do it again..
 108     (it happens with name like "eth123.456:789") */
 109   }
 110   if (*p1)
 111     return 1;
 112   if (*p2)
 113     return -1;
 114   return 0;
 115 }
 116
 117 static int
 118 if_cmp_func (struct interface *ifp1, struct interface *ifp2)
 119 {
 120   return if_cmp_name_func (ifp1->name, ifp2->name);
 121 }
 122
 123 /* Create new interface structure. */
 124 struct interface *
 125 if_create_vrf (const char *name, int namelen, vrf_id_t vrf_id)
 126 {
 127   struct interface *ifp;
 128   struct list *intf_list = vrf_iflist_get (vrf_id);
 129
 130   ifp = XCALLOC (MTYPE_IF, sizeof (struct interface));
 131   ifp->ifindex = IFINDEX_INTERNAL;
 132
 133   assert (name);
 134   assert (namelen <= INTERFACE_NAMSIZ); /* Need space for '\0' at end. */
 135   strncpy (ifp->name, name, namelen);
 136   ifp->name[namelen] = '\0';
 137   ifp->vrf_id = vrf_id;
 138   if (if_lookup_by_name_vrf (ifp->name, vrf_id) == NULL)
 139     listnode_add_sort (intf_list, ifp);
 140   else
 141     zlog_err("if_create(%s): corruption detected -- interface with this "
 142              "name exists already in VRF %u!", ifp->name, vrf_id);
 143   ifp->connected = list_new ();
 144   ifp->connected->del = (void (*) (void *)) connected_free;
 145
 146   ifp->nbr_connected = list_new ();
 147   ifp->nbr_connected->del = (void (*) (void *)) nbr_connected_free;
 148
 149   /* Enable Link-detection by default */
 150   SET_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION);
 151
 152   if (if_master.if_new_hook)
 153     (*if_master.if_new_hook) (ifp);
 154
 155   return ifp;
 156 }
 157
 158 struct interface *
 159 if_create (const char *name, int namelen)
 160 {
 161   return if_create_vrf (name, namelen, VRF_DEFAULT);
 162 }
 163
 164 /* Create new interface structure. */
 165 void
 166 if_update_vrf (struct interface *ifp, const char *name, int namelen, vrf_id_t vrf_id)
 167 {
 168   struct list *intf_list = vrf_iflist_get (vrf_id);
 169
 170   /* remove interface from old master vrf list */
 171   if (vrf_iflist (ifp->vrf_id))
 172     listnode_delete (vrf_iflist (ifp->vrf_id), ifp);
 173
 174   assert (name);
 175   assert (namelen <= INTERFACE_NAMSIZ); /* Need space for '\0' at end. */
 176   strncpy (ifp->name, name, namelen);
 177   ifp->name[namelen] = '\0';
 178   ifp->vrf_id = vrf_id;
 179   if (if_lookup_by_name_vrf (ifp->name, vrf_id) == NULL)
 180     listnode_add_sort (intf_list, ifp);
 181   else
 182     zlog_err("if_create(%s): corruption detected -- interface with this "
 183              "name exists already in VRF %u!", ifp->name, vrf_id);
 184
 185   return;
 186 }
 187
 188
 189 /* Delete interface structure. */
 190 void
 191 if_delete_retain (struct interface *ifp)
 192 {
 193   if (if_master.if_delete_hook)
 194     (*if_master.if_delete_hook) (ifp);
 195
 196   /* Free connected address list */
 197   list_delete_all_node (ifp->connected);
 198
 199   /* Free connected nbr address list */
 200   list_delete_all_node (ifp->nbr_connected);
 201 }
 202
 203 /* Delete and free interface structure. */
 204 void
 205 if_delete (struct interface *ifp)
 206 {
 207   listnode_delete (vrf_iflist (ifp->vrf_id), ifp);
 208
 209   if_delete_retain(ifp);
 210
 211   list_free (ifp->connected);
 212   list_free (ifp->nbr_connected);
 213
 214   if_link_params_free (ifp);
 215
 216   XFREE (MTYPE_IF, ifp);
 217 }
 218
 219 /* Add hook to interface master. */
 220 void
 221 if_add_hook (int type, int (*func)(struct interface *ifp))
 222 {
 223   switch (type) {
 224   case IF_NEW_HOOK:
 225     if_master.if_new_hook = func;
 226     break;
 227   case IF_DELETE_HOOK:
 228     if_master.if_delete_hook = func;
 229     break;
 230   default:
 231     break;
 232   }
 233 }
 234
 235 /* Interface existance check by index. */
 236 struct interface *
 237 if_lookup_by_index_vrf (ifindex_t ifindex, vrf_id_t vrf_id)
 238 {
 239   struct listnode *node;
 240   struct interface *ifp;
 241
 242   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 243     {
 244       if (ifp->ifindex == ifindex)
 245         return ifp;
 246     }
 247   return NULL;
 248 }
 249
 250 struct interface *
 251 if_lookup_by_index (ifindex_t ifindex)
 252 {
 253   return if_lookup_by_index_vrf (ifindex, VRF_DEFAULT);
 254 }
 255
 256 const char *
 257 ifindex2ifname_vrf (ifindex_t ifindex, vrf_id_t vrf_id)
 258 {
 259   struct interface *ifp;
 260
 261   return ((ifp = if_lookup_by_index_vrf (ifindex, vrf_id)) != NULL) ?
 262          ifp->name : "unknown";
 263 }
 264
 265 const char *
 266 ifindex2ifname (ifindex_t ifindex)
 267 {
 268   return ifindex2ifname_vrf (ifindex, VRF_DEFAULT);
 269 }
 270
 271 ifindex_t
 272 ifname2ifindex_vrf (const char *name, vrf_id_t vrf_id)
 273 {
 274   struct interface *ifp;
 275
 276   return ((ifp = if_lookup_by_name_vrf (name, vrf_id)) != NULL) ? ifp->ifindex
 277                                                    : IFINDEX_INTERNAL;
 278 }
 279
 280 ifindex_t
 281 ifname2ifindex (const char *name)
 282 {
 283   return ifname2ifindex_vrf (name, VRF_DEFAULT);
 284 }
 285
 286 /* Interface existance check by interface name. */
 287 struct interface *
 288 if_lookup_by_name_vrf (const char *name, vrf_id_t vrf_id)
 289 {
 290   struct listnode *node;
 291   struct interface *ifp;
 292
 293   if (name)
 294     for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 295       {
 296         if (strcmp(name, ifp->name) == 0)
 297           return ifp;
 298       }
 299   return NULL;
 300 }
 301
 302 struct interface *
 303 if_lookup_by_name_all_vrf (const char *name)
 304 {
 305   struct interface *ifp;
 306   struct vrf *vrf = NULL;
 307   vrf_iter_t iter;
 308
 309   for (iter = vrf_first (); iter != VRF_ITER_INVALID; iter = vrf_next (iter))
 310     {
 311       vrf = vrf_iter2vrf (iter);
 312       ifp = if_lookup_by_name_vrf (name, vrf->vrf_id);
 313       if (ifp)
 314         return ifp;
 315     }
 316
 317   return NULL;
 318 }
 319
 320 struct interface *
 321 if_lookup_by_name (const char *name)
 322 {
 323   return if_lookup_by_name_vrf (name, VRF_DEFAULT);
 324 }
 325
 326 struct interface *
 327 if_lookup_by_name_len_vrf (const char *name, size_t namelen, vrf_id_t vrf_id)
 328 {
 329   struct listnode *node;
 330   struct interface *ifp;
 331
 332   if (namelen > INTERFACE_NAMSIZ)
 333     return NULL;
 334
 335   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 336     {
 337       if (!memcmp(name, ifp->name, namelen) && (ifp->name[namelen] == '\0'))
 338         return ifp;
 339     }
 340   return NULL;
 341 }
 342
 343 struct interface *
 344 if_lookup_by_name_len(const char *name, size_t namelen)
 345 {
 346   return if_lookup_by_name_len_vrf (name, namelen, VRF_DEFAULT);
 347 }
 348
 349 /* Lookup interface by IPv4 address. */
 350 struct interface *
 351 if_lookup_exact_address_vrf (void *src, int family, vrf_id_t vrf_id)
 352 {
 353   struct listnode *node;
 354   struct listnode *cnode;
 355   struct interface *ifp;
 356   struct prefix *p;
 357   struct connected *c;
 358
 359   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 360     {
 361       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
 362         {
 363           p = c->address;
 364
 365           if (p && (p->family == family))
 366             {
 367               if (family == AF_INET)
 368                 {
 369                   if (IPV4_ADDR_SAME (&p->u.prefix4, (struct in_addr *)src))
 370                     return ifp;
 371                 }
 372               else if (family == AF_INET6)
 373                 {
 374                   if (IPV6_ADDR_SAME (&p->u.prefix4, (struct in6_addr *)src))
 375                     return ifp;
 376                 }
 377             }
 378         }
 379     }
 380   return NULL;
 381 }
 382
 383 struct interface *
 384 if_lookup_exact_address (void *src, int family)
 385 {
 386   return if_lookup_exact_address_vrf (src, family, VRF_DEFAULT);
 387 }
 388
 389 /* Lookup interface by IPv4 address. */
 390 struct interface *
 391 if_lookup_address_vrf (void *matchaddr, int family, vrf_id_t vrf_id)
 392 {
 393   struct listnode *node;
 394   struct prefix addr;
 395   int bestlen = 0;
 396   struct listnode *cnode;
 397   struct interface *ifp;
 398   struct connected *c;
 399   struct interface *match;
 400
 401   if (family == AF_INET)
 402     {
 403       addr.family = AF_INET;
 404       addr.u.prefix4 = *((struct in_addr *)matchaddr);
 405       addr.prefixlen = IPV4_MAX_BITLEN;
 406     }
 407   else if (family == AF_INET6)
 408     {
 409       addr.family = AF_INET6;
 410       addr.u.prefix6 = *((struct in6_addr *)matchaddr);
 411       addr.prefixlen = IPV6_MAX_BITLEN;
 412     }
 413
 414   match = NULL;
 415
 416   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 417     {
 418       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
 419         {
 420           if (c->address && (c->address->family == AF_INET) &&
 421               prefix_match(CONNECTED_PREFIX(c), &addr) &&
 422               (c->address->prefixlen > bestlen))
 423             {
 424               bestlen = c->address->prefixlen;
 425               match = ifp;
 426             }
 427         }
 428     }
 429   return match;
 430 }
 431
 432 struct interface *
 433 if_lookup_address (void *matchaddr, int family)
 434 {
 435   return if_lookup_address_vrf (matchaddr, family, VRF_DEFAULT);
 436 }
 437
 438 /* Lookup interface by prefix */
 439 struct interface *
 440 if_lookup_prefix_vrf (struct prefix *prefix, vrf_id_t vrf_id)
 441 {
 442   struct listnode *node;
 443   struct listnode *cnode;
 444   struct interface *ifp;
 445   struct connected *c;
 446
 447   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 448     {
 449       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
 450         {
 451           if (prefix_cmp(c->address, prefix) == 0)
 452             {
 453               return ifp;
 454             }
 455         }
 456     }
 457   return NULL;
 458 }
 459
 460 struct interface *
 461 if_lookup_prefix (struct prefix *prefix)
 462 {
 463   return if_lookup_prefix_vrf (prefix, VRF_DEFAULT);
 464 }
 465
 466 /* Get interface by name if given name interface doesn't exist create
 467    one. */
 468 struct interface *
 469 if_get_by_name_vrf (const char *name, vrf_id_t vrf_id)
 470 {
 471   struct interface *ifp;
 472
 473   return ((ifp = if_lookup_by_name_vrf (name, vrf_id)) != NULL) ? ifp :
 474          if_create_vrf (name, strlen(name), vrf_id);
 475 }
 476
 477 struct interface *
 478 if_get_by_name (const char *name)
 479 {
 480   return if_get_by_name_vrf (name, VRF_DEFAULT);
 481 }
 482
 483 struct interface *
 484 if_get_by_name_len_vrf (const char *name, size_t namelen, vrf_id_t vrf_id, int vty)
 485 {
 486   struct interface *ifp;
 487   struct listnode *node;
 488   struct vrf *vrf = NULL;
 489   vrf_iter_t iter;
 490
 491   ifp = if_lookup_by_name_len_vrf (name, namelen, vrf_id);
 492   if (ifp)
 493     return ifp;
 494
 495   /* Didn't find the interface on that vrf. Defined on a different one? */
 496   for (iter = vrf_first (); iter != VRF_ITER_INVALID; iter = vrf_next (iter))
 497     {
 498       vrf = vrf_iter2vrf(iter);
 499       for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf->vrf_id), node, ifp))
 500         {
 501           if (!memcmp(name, ifp->name, namelen) && (ifp->name[namelen] == '\0'))
 502             {
 503               /* Found a match.  If the interface command was entered in vty without a
 504                * VRF (passed as VRF_DEFAULT), accept the ifp we found.   If a vrf was
 505                * entered and there is a mismatch, reject it if from vty. If it came
 506                * from the kernel by way of zclient,  believe it and update
 507                * the ifp accordingly.
 508                */
 509               if (vty)
 510                 {
 511                   if (vrf_id == VRF_DEFAULT)
 512                     return ifp;
 513                   return NULL;
 514                 }
 515               else
 516                 {
 517                   if_update_vrf (ifp, name, namelen, vrf_id);
 518                   return ifp;
 519                 }
 520             }
 521         }
 522     }
 523   return (if_create_vrf (name, namelen, vrf_id));
 524 }
 525
 526 struct interface *
 527 if_get_by_name_len (const char *name, size_t namelen)
 528 {
 529   return if_get_by_name_len_vrf (name, namelen, VRF_DEFAULT, 0);
 530 }
 531
 532 /* Does interface up ? */
 533 int
 534 if_is_up (struct interface *ifp)
 535 {
 536   return ifp->flags & IFF_UP;
 537 }
 538
 539 /* Is interface running? */
 540 int
 541 if_is_running (struct interface *ifp)
 542 {
 543   return ifp->flags & IFF_RUNNING;
 544 }
 545
 546 /* Is the interface operative, eg. either UP & RUNNING
 547    or UP & !ZEBRA_INTERFACE_LINK_DETECTION and
 548    if ptm checking is enabled, then ptm check has passed */
 549 int
 550 if_is_operative (struct interface *ifp)
 551 {
 552   return ((ifp->flags & IFF_UP) &&
 553           (((ifp->flags & IFF_RUNNING) &&
 554             (ifp->ptm_status || !ifp->ptm_enable)) ||
 555            !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)));
 556 }
 557
 558 /* Is the interface operative, eg. either UP & RUNNING
 559    or UP & !ZEBRA_INTERFACE_LINK_DETECTION, without PTM check */
 560 int
 561 if_is_no_ptm_operative (struct interface *ifp)
 562 {
 563   return ((ifp->flags & IFF_UP) &&
 564           ((ifp->flags & IFF_RUNNING) ||
 565            !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)));
 566 }
 567
 568 /* Is this loopback interface ? */
 569 int
 570 if_is_loopback (struct interface *ifp)
 571 {
 572   /* XXX: Do this better, eg what if IFF_WHATEVER means X on platform M
 573    * but Y on platform N?
 574    */
 575   return (ifp->flags & (IFF_LOOPBACK|IFF_NOXMIT|IFF_VIRTUAL));
 576 }
 577
 578 /* Does this interface support broadcast ? */
 579 int
 580 if_is_broadcast (struct interface *ifp)
 581 {
 582   return ifp->flags & IFF_BROADCAST;
 583 }
 584
 585 /* Does this interface support broadcast ? */
 586 int
 587 if_is_pointopoint (struct interface *ifp)
 588 {
 589   return ifp->flags & IFF_POINTOPOINT;
 590 }
 591
 592 /* Does this interface support multicast ? */
 593 int
 594 if_is_multicast (struct interface *ifp)
 595 {
 596   return ifp->flags & IFF_MULTICAST;
 597 }
 598
 599 /* Printout flag information into log */
 600 const char *
 601 if_flag_dump (unsigned long flag)
 602 {
 603   int separator = 0;
 604   static char logbuf[BUFSIZ];
 605
 606 #define IFF_OUT_LOG(X,STR) \
 607   if (flag & (X)) \
 608     { \
 609       if (separator) \
 610         strlcat (logbuf, ",", BUFSIZ); \
 611       else \
 612         separator = 1; \
 613       strlcat (logbuf, STR, BUFSIZ); \
 614     }
 615
 616   strlcpy (logbuf, "<", BUFSIZ);
 617   IFF_OUT_LOG (IFF_UP, "UP");
 618   IFF_OUT_LOG (IFF_BROADCAST, "BROADCAST");
 619   IFF_OUT_LOG (IFF_DEBUG, "DEBUG");
 620   IFF_OUT_LOG (IFF_LOOPBACK, "LOOPBACK");
 621   IFF_OUT_LOG (IFF_POINTOPOINT, "POINTOPOINT");
 622   IFF_OUT_LOG (IFF_NOTRAILERS, "NOTRAILERS");
 623   IFF_OUT_LOG (IFF_RUNNING, "RUNNING");
 624   IFF_OUT_LOG (IFF_NOARP, "NOARP");
 625   IFF_OUT_LOG (IFF_PROMISC, "PROMISC");
 626   IFF_OUT_LOG (IFF_ALLMULTI, "ALLMULTI");
 627   IFF_OUT_LOG (IFF_OACTIVE, "OACTIVE");
 628   IFF_OUT_LOG (IFF_SIMPLEX, "SIMPLEX");
 629   IFF_OUT_LOG (IFF_LINK0, "LINK0");
 630   IFF_OUT_LOG (IFF_LINK1, "LINK1");
 631   IFF_OUT_LOG (IFF_LINK2, "LINK2");
 632   IFF_OUT_LOG (IFF_MULTICAST, "MULTICAST");
 633   IFF_OUT_LOG (IFF_NOXMIT, "NOXMIT");
 634   IFF_OUT_LOG (IFF_NORTEXCH, "NORTEXCH");
 635   IFF_OUT_LOG (IFF_VIRTUAL, "VIRTUAL");
 636   IFF_OUT_LOG (IFF_IPV4, "IPv4");
 637   IFF_OUT_LOG (IFF_IPV6, "IPv6");
 638
 639   strlcat (logbuf, ">", BUFSIZ);
 640
 641   return logbuf;
 642 #undef IFF_OUT_LOG
 643 }
 644
 645 /* For debugging */
 646 static void
 647 if_dump (const struct interface *ifp)
 648 {
 649   struct listnode *node;
 650   struct connected *c __attribute__((unused));
 651
 652   for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, c))
 653     zlog_info ("Interface %s vrf %u index %d metric %d mtu %d "
 654                "mtu6 %d %s",
 655                ifp->name, ifp->vrf_id, ifp->ifindex, ifp->metric, ifp->mtu,
 656                ifp->mtu6, if_flag_dump (ifp->flags));
 657 }
 658
 659 /* Interface printing for all interface. */
 660 void
 661 if_dump_all (void)
 662 {
 663   struct list *intf_list;
 664   struct listnode *node;
 665   void *p;
 666   vrf_iter_t iter;
 667
 668   for (iter = vrf_first (); iter != VRF_ITER_INVALID; iter = vrf_next (iter))
 669     if ((intf_list = vrf_iter2iflist (iter)) != NULL)
 670       for (ALL_LIST_ELEMENTS_RO (intf_list, node, p))
 671         if_dump (p);
 672 }
 673
 674 DEFUN (interface_desc,
 675        interface_desc_cmd,
 676        "description LINE...",
 677        "Interface specific description\n"
 678        "Characters describing this interface\n")
 679 {
 680   struct interface *ifp;
 681
 682   if (argc == 1)
 683     return CMD_SUCCESS;
 684
 685   ifp = vty->index;
 686   if (ifp->desc)
 687     XFREE (MTYPE_TMP, ifp->desc);
 688   ifp->desc = argv_concat(argv, argc, 1);
 689
 690   return CMD_SUCCESS;
 691 }
 692
 693 DEFUN (no_interface_desc,
 694        no_interface_desc_cmd,
 695        "no description",
 696        NO_STR
 697        "Interface specific description\n")
 698 {
 699   struct interface *ifp;
 700
 701   ifp = vty->index;
 702   if (ifp->desc)
 703     XFREE (MTYPE_TMP, ifp->desc);
 704   ifp->desc = NULL;
 705
 706   return CMD_SUCCESS;
 707 }
 708
 709 #ifdef SUNOS_5
 710 /* Need to handle upgrade from SUNWzebra to Quagga. SUNWzebra created
 711  * a seperate struct interface for each logical interface, so config
 712  * file may be full of 'interface fooX:Y'. Solaris however does not
 713  * expose logical interfaces via PF_ROUTE, so trying to track logical
 714  * interfaces can be fruitless, for that reason Quagga only tracks
 715  * the primary IP interface.
 716  *
 717  * We try accomodate SUNWzebra by:
 718  * - looking up the interface name, to see whether it exists, if so
 719  *   its useable
 720  *   - for protocol daemons, this could only because zebra told us of
 721  *     the interface
 722  *   - for zebra, only because it learnt from kernel
 723  * - if not:
 724  *   - search the name to see if it contains a sub-ipif / logical interface
 725  *     seperator, the ':' char. If it does:
 726  *     - text up to that char must be the primary name - get that name.
 727  *     if not:
 728  *     - no idea, just get the name in its entirety.
 729  */
 730 static struct interface *
 731 if_sunwzebra_get (const char *name, size_t nlen, vrf_id_t vrf_id)
 732 {
 733   struct interface *ifp;
 734   size_t seppos = 0;
 735
 736   if ( (ifp = if_lookup_by_name_len_vrf (name, nlen, vrf_id)) != NULL)
 737     return ifp;
 738
 739   /* hunt the primary interface name... */
 740   while (seppos < nlen && name[seppos] != ':')
 741     seppos++;
 742
 743   /* Wont catch seperator as last char, e.g. 'foo0:' but thats invalid */
 744   if (seppos < nlen)
 745     return if_get_by_name_len_vrf (name, seppos, vrf_id, 1);
 746   else
 747     return if_get_by_name_len_vrf (name, nlen, vrf_id, 1);
 748 }
 749 #endif /* SUNOS_5 */
 750
 751 DEFUN (interface,
 752        interface_cmd,
 753        "interface IFNAME ["VRF_CMD_STR"]",
 754        "Select an interface to configure\n"
 755        "Interface's name\n"
 756        VRF_CMD_HELP_STR)
 757 {
 758   int idx_ifname = 1;
 759   const char *ifname = argv[idx_ifname]->arg;
 760   const char *vrfname = (argc > 2) ? argv[3]->arg : NULL;
 761
 762   struct interface *ifp;
 763   size_t sl;
 764   vrf_id_t vrf_id = VRF_DEFAULT;
 765
 766   if ((sl = strlen(ifname)) > INTERFACE_NAMSIZ)
 767     {
 768       vty_out (vty, "%% Interface name %s is invalid: length exceeds "
 769                     "%d characters%s",
 770                ifname, INTERFACE_NAMSIZ, VTY_NEWLINE);
 771       return CMD_WARNING;
 772     }
 773
 774 /*Pending: need proper vrf name based lookup/(possible creation of VRF)
 775  Imagine forward reference of a vrf by name in this interface config */
 776   if (vrfname)
 777     VRF_GET_ID (vrf_id, vrfname);
 778
 779 #ifdef SUNOS_5
 780   ifp = if_sunwzebra_get (ifname, sl, vrf_id);
 781 #else
 782   ifp = if_get_by_name_len_vrf (ifname, sl, vrf_id, 1);
 783 #endif /* SUNOS_5 */
 784
 785   if (!ifp)
 786     {
 787       vty_out (vty, "%% interface %s not in %s%s", ifname, vrfname, VTY_NEWLINE);
 788       return CMD_WARNING;
 789     }
 790   vty->index = ifp;
 791   vty->node = INTERFACE_NODE;
 792
 793   return CMD_SUCCESS;
 794 }
 795
 796 DEFUN_NOSH (no_interface,
 797            no_interface_cmd,
 798            "no interface IFNAME [VRF_CMD_STR]",
 799            NO_STR
 800            "Delete a pseudo interface's configuration\n"
 801            "Interface's name\n"
 802            VRF_CMD_HELP_STR)
 803 {
 804   const char *ifname = argv[2]->arg;
 805   const char *vrfname = (argc > 3) ? argv[3]->arg : NULL;
 806
 807   // deleting interface
 808   struct interface *ifp;
 809   vrf_id_t vrf_id = VRF_DEFAULT;
 810
 811   if (argc > 3)
 812     VRF_GET_ID (vrf_id, vrfname);
 813
 814   ifp = if_lookup_by_name_vrf (ifname, vrf_id);
 815
 816   if (ifp == NULL)
 817     {
 818       vty_out (vty, "%% Interface %s does not exist%s", ifname, VTY_NEWLINE);
 819       return CMD_WARNING;
 820     }
 821
 822   if (CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
 823     {
 824       vty_out (vty, "%% Only inactive interfaces can be deleted%s",
 825               VTY_NEWLINE);
 826       return CMD_WARNING;
 827     }
 828
 829   if_delete(ifp);
 830
 831   return CMD_SUCCESS;
 832 }
 833
 834 DEFUN (vrf,
 835        vrf_cmd,
 836        "vrf NAME",
 837        "Select a VRF to configure\n"
 838        "VRF's name\n")
 839 {
 840   int idx_name = 1;
 841   const char *vrfname = argv[idx_name]->arg;
 842
 843   struct vrf *vrfp;
 844   size_t sl;
 845
 846   if ((sl = strlen(vrfname)) > VRF_NAMSIZ)
 847     {
 848       vty_out (vty, "%% VRF name %s is invalid: length exceeds "
 849                     "%d characters%s",
 850                vrfname, VRF_NAMSIZ, VTY_NEWLINE);
 851       return CMD_WARNING;
 852     }
 853
 854   vrfp = vrf_get (VRF_UNKNOWN, vrfname);
 855
 856   vty->index = vrfp;
 857   vty->node = VRF_NODE;
 858
 859   return CMD_SUCCESS;
 860 }
 861
 862 DEFUN_NOSH (no_vrf,
 863            no_vrf_cmd,
 864            "no vrf NAME",
 865            NO_STR
 866            "Delete a pseudo VRF's configuration\n"
 867            "VRF's name\n")
 868 {
 869   const char *vrfname = argv[2]->arg;
 870
 871   struct vrf *vrfp;
 872
 873   vrfp = vrf_list_lookup_by_name (vrfname);;
 874
 875   if (vrfp == NULL)
 876     {
 877       vty_out (vty, "%% VRF %s does not exist%s", vrfname, VTY_NEWLINE);
 878       return CMD_WARNING;
 879     }
 880
 881   if (CHECK_FLAG (vrfp->status, VRF_ACTIVE))
 882     {
 883       vty_out (vty, "%% Only inactive VRFs can be deleted%s",
 884               VTY_NEWLINE);
 885       return CMD_WARNING;
 886     }
 887
 888   vrf_delete(vrfp);
 889
 890   return CMD_SUCCESS;
 891 }
 892
 893
 894 /* For debug purpose. */
 895 DEFUN (show_address,
 896        show_address_cmd,
 897        "show address [VRF_CMD_STR]",
 898        SHOW_STR
 899        "address\n"
 900        VRF_CMD_HELP_STR)
 901 {
 902   int idx_vrf_cmd_str = 2;
 903   struct listnode *node;
 904   struct listnode *node2;
 905   struct interface *ifp;
 906   struct connected *ifc;
 907   struct prefix *p;
 908   vrf_id_t vrf_id = VRF_DEFAULT;
 909
 910   if (argc > 2)
 911     VRF_GET_ID (vrf_id, argv[idx_vrf_cmd_str]->arg);
 912
 913   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), node, ifp))
 914     {
 915       for (ALL_LIST_ELEMENTS_RO (ifp->connected, node2, ifc))
 916         {
 917           p = ifc->address;
 918
 919           if (p->family == AF_INET)
 920             vty_out (vty, "%s/%d%s", inet_ntoa (p->u.prefix4), p->prefixlen,
 921                      VTY_NEWLINE);
 922         }
 923     }
 924   return CMD_SUCCESS;
 925 }
 926
 927 DEFUN (show_address_vrf_all,
 928        show_address_vrf_all_cmd,
 929        "show address " VRF_ALL_CMD_STR,
 930        SHOW_STR
 931        "address\n"
 932        VRF_ALL_CMD_HELP_STR)
 933 {
 934   struct list *intf_list;
 935   struct listnode *node;
 936   struct listnode *node2;
 937   struct interface *ifp;
 938   struct connected *ifc;
 939   struct prefix *p;
 940   vrf_iter_t iter;
 941
 942   for (iter = vrf_first (); iter != VRF_ITER_INVALID; iter = vrf_next (iter))
 943     {
 944       intf_list = vrf_iter2iflist (iter);
 945       if (!intf_list || !listcount (intf_list))
 946         continue;
 947
 948       vty_out (vty, "%sVRF %u%s%s", VTY_NEWLINE, vrf_iter2id (iter),
 949                VTY_NEWLINE, VTY_NEWLINE);
 950
 951       for (ALL_LIST_ELEMENTS_RO (intf_list, node, ifp))
 952         {
 953           for (ALL_LIST_ELEMENTS_RO (ifp->connected, node2, ifc))
 954             {
 955               p = ifc->address;
 956
 957               if (p->family == AF_INET)
 958                 vty_out (vty, "%s/%d%s", inet_ntoa (p->u.prefix4), p->prefixlen,
 959                          VTY_NEWLINE);
 960             }
 961         }
 962     }
 963   return CMD_SUCCESS;
 964 }
 965
 966 /* Allocate connected structure. */
 967 struct connected *
 968 connected_new (void)
 969 {
 970   return XCALLOC (MTYPE_CONNECTED, sizeof (struct connected));
 971 }
 972
 973 /* Allocate nbr connected structure. */
 974 struct nbr_connected *
 975 nbr_connected_new (void)
 976 {
 977   return XCALLOC (MTYPE_NBR_CONNECTED, sizeof (struct nbr_connected));
 978 }
 979
 980 /* Free connected structure. */
 981 void
 982 connected_free (struct connected *connected)
 983 {
 984   if (connected->address)
 985     prefix_free (connected->address);
 986
 987   if (connected->destination)
 988     prefix_free (connected->destination);
 989
 990   if (connected->label)
 991     XFREE (MTYPE_CONNECTED_LABEL, connected->label);
 992
 993   XFREE (MTYPE_CONNECTED, connected);
 994 }
 995
 996 /* Free nbr connected structure. */
 997 void
 998 nbr_connected_free (struct nbr_connected *connected)
 999 {
1000   if (connected->address)
1001     prefix_free (connected->address);
1002
1003   XFREE (MTYPE_NBR_CONNECTED, connected);
1004 }
1005
1006 /* If same interface nbr address already exists... */
1007 struct nbr_connected *
1008 nbr_connected_check (struct interface *ifp, struct prefix *p)
1009 {
1010   struct nbr_connected *ifc;
1011   struct listnode *node;
1012
1013   for (ALL_LIST_ELEMENTS_RO (ifp->nbr_connected, node, ifc))
1014     if (prefix_same (ifc->address, p))
1015       return ifc;
1016
1017   return NULL;
1018 }
1019
1020 /* Print if_addr structure. */
1021 static void __attribute__ ((unused))
1022 connected_log (struct connected *connected, char *str)
1023 {
1024   struct prefix *p;
1025   struct interface *ifp;
1026   char logbuf[BUFSIZ];
1027   char buf[BUFSIZ];
1028
1029   ifp = connected->ifp;
1030   p = connected->address;
1031
1032   snprintf (logbuf, BUFSIZ, "%s interface %s vrf %u %s %s/%d ",
1033             str, ifp->name, ifp->vrf_id, prefix_family_str (p),
1034             inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
1035             p->prefixlen);
1036
1037   p = connected->destination;
1038   if (p)
1039     {
1040       strncat (logbuf, inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
1041                BUFSIZ - strlen(logbuf));
1042     }
1043   zlog (NULL, LOG_INFO, "%s", logbuf);
1044 }
1045
1046 /* Print if_addr structure. */
1047 static void __attribute__ ((unused))
1048 nbr_connected_log (struct nbr_connected *connected, char *str)
1049 {
1050   struct prefix *p;
1051   struct interface *ifp;
1052   char logbuf[BUFSIZ];
1053   char buf[BUFSIZ];
1054
1055   ifp = connected->ifp;
1056   p = connected->address;
1057
1058   snprintf (logbuf, BUFSIZ, "%s interface %s %s %s/%d ",
1059             str, ifp->name, prefix_family_str (p),
1060             inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
1061             p->prefixlen);
1062
1063   zlog (NULL, LOG_INFO, "%s", logbuf);
1064 }
1065
1066 /* If two connected address has same prefix return 1. */
1067 static int
1068 connected_same_prefix (struct prefix *p1, struct prefix *p2)
1069 {
1070   if (p1->family == p2->family)
1071     {
1072       if (p1->family == AF_INET &&
1073           IPV4_ADDR_SAME (&p1->u.prefix4, &p2->u.prefix4))
1074         return 1;
1075 #ifdef HAVE_IPV6
1076       if (p1->family == AF_INET6 &&
1077           IPV6_ADDR_SAME (&p1->u.prefix6, &p2->u.prefix6))
1078         return 1;
1079 #endif /* HAVE_IPV6 */
1080     }
1081   return 0;
1082 }
1083
1084 struct connected *
1085 connected_lookup_prefix_exact (struct interface *ifp, struct prefix *p)
1086 {
1087   struct listnode *node;
1088   struct listnode *next;
1089   struct connected *ifc;
1090
1091   for (node = listhead (ifp->connected); node; node = next)
1092     {
1093       ifc = listgetdata (node);
1094       next = node->next;
1095
1096       if (connected_same_prefix (ifc->address, p))
1097         return ifc;
1098     }
1099   return NULL;
1100 }
1101
1102 struct connected *
1103 connected_delete_by_prefix (struct interface *ifp, struct prefix *p)
1104 {
1105   struct listnode *node;
1106   struct listnode *next;
1107   struct connected *ifc;
1108
1109   /* In case of same prefix come, replace it with new one. */
1110   for (node = listhead (ifp->connected); node; node = next)
1111     {
1112       ifc = listgetdata (node);
1113       next = node->next;
1114
1115       if (connected_same_prefix (ifc->address, p))
1116         {
1117           listnode_delete (ifp->connected, ifc);
1118           return ifc;
1119         }
1120     }
1121   return NULL;
1122 }
1123
1124 /* Find the address on our side that will be used when packets
1125    are sent to dst. */
1126 struct connected *
1127 connected_lookup_prefix (struct interface *ifp, struct prefix *addr)
1128 {
1129   struct listnode *cnode;
1130   struct connected *c;
1131   struct connected *match;
1132
1133   match = NULL;
1134
1135   for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
1136     {
1137       if (c->address && (c->address->family == addr->family) &&
1138           prefix_match(CONNECTED_PREFIX(c), addr) &&
1139           (!match || (c->address->prefixlen > match->address->prefixlen)))
1140         match = c;
1141     }
1142   return match;
1143 }
1144
1145 struct connected *
1146 connected_add_by_prefix (struct interface *ifp, struct prefix *p,
1147                          struct prefix *destination)
1148 {
1149   struct connected *ifc;
1150
1151   /* Allocate new connected address. */
1152   ifc = connected_new ();
1153   ifc->ifp = ifp;
1154
1155   /* Fetch interface address */
1156   ifc->address = prefix_new();
1157   memcpy (ifc->address, p, sizeof(struct prefix));
1158
1159   /* Fetch dest address */
1160   if (destination)
1161     {
1162       ifc->destination = prefix_new();
1163       memcpy (ifc->destination, destination, sizeof(struct prefix));
1164     }
1165
1166   /* Add connected address to the interface. */
1167   listnode_add (ifp->connected, ifc);
1168   return ifc;
1169 }
1170
1171 #ifndef HAVE_IF_NAMETOINDEX
1172 ifindex_t
1173 if_nametoindex (const char *name)
1174 {
1175   struct interface *ifp;
1176
1177   return ((ifp = if_lookup_by_name_len(name, strnlen(name, IFNAMSIZ))) != NULL)
1178          ? ifp->ifindex : 0;
1179 }
1180 #endif
1181
1182 #ifndef HAVE_IF_INDEXTONAME
1183 char *
1184 if_indextoname (ifindex_t ifindex, char *name)
1185 {
1186   struct interface *ifp;
1187
1188   if (!(ifp = if_lookup_by_index(ifindex)))
1189     return NULL;
1190   strncpy (name, ifp->name, IFNAMSIZ);
1191   return ifp->name;
1192 }
1193 #endif
1194
1195 #if 0 /* this route_table of struct connected's is unused
1196        * however, it would be good to use a route_table rather than
1197        * a list..
1198        */
1199 /* Interface looking up by interface's address. */
1200 /* Interface's IPv4 address reverse lookup table. */
1201 struct route_table *ifaddr_ipv4_table;
1202 /* struct route_table *ifaddr_ipv6_table; */
1203
1204 static void
1205 ifaddr_ipv4_add (struct in_addr *ifaddr, struct interface *ifp)
1206 {
1207   struct route_node *rn;
1208   struct prefix_ipv4 p;
1209
1210   p.family = AF_INET;
1211   p.prefixlen = IPV4_MAX_PREFIXLEN;
1212   p.prefix = *ifaddr;
1213
1214   rn = route_node_get (ifaddr_ipv4_table, (struct prefix *) &p);
1215   if (rn)
1216     {
1217       route_unlock_node (rn);
1218       zlog_info ("ifaddr_ipv4_add(): address %s is already added",
1219                  inet_ntoa (*ifaddr));
1220       return;
1221     }
1222   rn->info = ifp;
1223 }
1224
1225 static void
1226 ifaddr_ipv4_delete (struct in_addr *ifaddr, struct interface *ifp)
1227 {
1228   struct route_node *rn;
1229   struct prefix_ipv4 p;
1230
1231   p.family = AF_INET;
1232   p.prefixlen = IPV4_MAX_PREFIXLEN;
1233   p.prefix = *ifaddr;
1234
1235   rn = route_node_lookup (ifaddr_ipv4_table, (struct prefix *) &p);
1236   if (! rn)
1237     {
1238       zlog_info ("ifaddr_ipv4_delete(): can't find address %s",
1239                  inet_ntoa (*ifaddr));
1240       return;
1241     }
1242   rn->info = NULL;
1243   route_unlock_node (rn);
1244   route_unlock_node (rn);
1245 }
1246
1247 /* Lookup interface by interface's IP address or interface index. */
1248 static struct interface *
1249 ifaddr_ipv4_lookup (struct in_addr *addr, ifindex_t ifindex)
1250 {
1251   struct prefix_ipv4 p;
1252   struct route_node *rn;
1253   struct interface *ifp;
1254
1255   if (addr)
1256     {
1257       p.family = AF_INET;
1258       p.prefixlen = IPV4_MAX_PREFIXLEN;
1259       p.prefix = *addr;
1260
1261       rn = route_node_lookup (ifaddr_ipv4_table, (struct prefix *) &p);
1262       if (! rn)
1263         return NULL;
1264
1265       ifp = rn->info;
1266       route_unlock_node (rn);
1267       return ifp;
1268     }
1269   else
1270     return if_lookup_by_index(ifindex);
1271 }
1272 #endif /* ifaddr_ipv4_table */
1273
1274 /* Initialize interface list. */
1275 void
1276 if_init (struct list **intf_list)
1277 {
1278   *intf_list = list_new ();
1279 #if 0
1280   ifaddr_ipv4_table = route_table_init ();
1281 #endif /* ifaddr_ipv4_table */
1282
1283   (*intf_list)->cmp = (int (*)(void *, void *))if_cmp_func;
1284 }
1285
1286 void
1287 if_terminate (struct list **intf_list)
1288 {
1289   for (;;)
1290     {
1291       struct interface *ifp;
1292
1293       ifp = listnode_head (*intf_list);
1294       if (ifp == NULL)
1295         break;
1296
1297       if (ifp->node)
1298         {
1299           ifp->node->info = NULL;
1300           route_unlock_node (ifp->node);
1301         }
1302
1303       if_delete (ifp);
1304     }
1305
1306   list_delete (*intf_list);
1307   *intf_list = NULL;
1308 }
1309
1310 const char *
1311 if_link_type_str (enum zebra_link_type llt)
1312 {
1313   switch (llt)
1314     {
1315 #define llts(T,S) case (T): return (S)
1316       llts(ZEBRA_LLT_UNKNOWN,               "Unknown");
1317       llts(ZEBRA_LLT_ETHER,                 "Ethernet");
1318       llts(ZEBRA_LLT_EETHER,                "Experimental Ethernet");
1319       llts(ZEBRA_LLT_AX25,                  "AX.25 Level 2");
1320       llts(ZEBRA_LLT_PRONET,                "PROnet token ring");
1321       llts(ZEBRA_LLT_IEEE802,               "IEEE 802.2 Ethernet/TR/TB");
1322       llts(ZEBRA_LLT_ARCNET,                "ARCnet");
1323       llts(ZEBRA_LLT_APPLETLK,              "AppleTalk");
1324       llts(ZEBRA_LLT_DLCI,                  "Frame Relay DLCI");
1325       llts(ZEBRA_LLT_ATM,                   "ATM");
1326       llts(ZEBRA_LLT_METRICOM,              "Metricom STRIP");
1327       llts(ZEBRA_LLT_IEEE1394,              "IEEE 1394 IPv4");
1328       llts(ZEBRA_LLT_EUI64,                 "EUI-64");
1329       llts(ZEBRA_LLT_INFINIBAND,            "InfiniBand");
1330       llts(ZEBRA_LLT_SLIP,                  "SLIP");
1331       llts(ZEBRA_LLT_CSLIP,                 "Compressed SLIP");
1332       llts(ZEBRA_LLT_SLIP6,                 "SLIPv6");
1333       llts(ZEBRA_LLT_CSLIP6,                "Compressed SLIPv6");
1334       llts(ZEBRA_LLT_ROSE,                  "ROSE packet radio");
1335       llts(ZEBRA_LLT_X25,                   "CCITT X.25");
1336       llts(ZEBRA_LLT_PPP,                   "PPP");
1337       llts(ZEBRA_LLT_CHDLC,                 "Cisco HDLC");
1338       llts(ZEBRA_LLT_RAWHDLC,               "Raw HDLC");
1339       llts(ZEBRA_LLT_LAPB,                  "LAPB");
1340       llts(ZEBRA_LLT_IPIP,                  "IPIP Tunnel");
1341       llts(ZEBRA_LLT_IPIP6,                 "IPIP6 Tunnel");
1342       llts(ZEBRA_LLT_FRAD,                  "FRAD");
1343       llts(ZEBRA_LLT_SKIP,                  "SKIP vif");
1344       llts(ZEBRA_LLT_LOOPBACK,              "Loopback");
1345       llts(ZEBRA_LLT_LOCALTLK,              "Localtalk");
1346       llts(ZEBRA_LLT_FDDI,                  "FDDI");
1347       llts(ZEBRA_LLT_SIT,                   "IPv6-in-IPv4 SIT");
1348       llts(ZEBRA_LLT_IPDDP,                 "IP-in-DDP tunnel");
1349       llts(ZEBRA_LLT_IPGRE,                 "GRE over IP");
1350       llts(ZEBRA_LLT_PIMREG,                "PIMSM registration");
1351       llts(ZEBRA_LLT_HIPPI,                 "HiPPI");
1352       llts(ZEBRA_LLT_IRDA,                  "IrDA");
1353       llts(ZEBRA_LLT_FCPP,                  "Fibre-Channel PtP");
1354       llts(ZEBRA_LLT_FCAL,                  "Fibre-Channel Arbitrated Loop");
1355       llts(ZEBRA_LLT_FCPL,                  "Fibre-Channel Public Loop");
1356       llts(ZEBRA_LLT_FCFABRIC,              "Fibre-Channel Fabric");
1357       llts(ZEBRA_LLT_IEEE802_TR,            "IEEE 802.2 Token Ring");
1358       llts(ZEBRA_LLT_IEEE80211,             "IEEE 802.11");
1359       llts(ZEBRA_LLT_IEEE80211_RADIOTAP,    "IEEE 802.11 Radiotap");
1360       llts(ZEBRA_LLT_IEEE802154,            "IEEE 802.15.4");
1361       llts(ZEBRA_LLT_IEEE802154_PHY,        "IEEE 802.15.4 Phy");
1362       default:
1363         zlog_warn ("Unknown value %d", llt);
1364         return "Unknown type!";
1365 #undef llts
1366     }
1367   return NULL;
1368 }
1369
1370 struct if_link_params *
1371 if_link_params_get (struct interface *ifp)
1372 {
1373   int i;
1374
1375   if (ifp->link_params != NULL)
1376     return ifp->link_params;
1377
1378   struct if_link_params *iflp = XCALLOC(MTYPE_IF_LINK_PARAMS,
1379                                       sizeof (struct if_link_params));
1380   if (iflp == NULL) return NULL;
1381
1382   /* Set TE metric == standard metric */
1383   iflp->te_metric = ifp->metric;
1384
1385   /* Compute default bandwidth based on interface */
1386   int bw = (float)((ifp->bandwidth ? ifp->bandwidth : DEFAULT_BANDWIDTH)
1387                    * TE_KILO_BIT / TE_BYTE);
1388
1389   /* Set Max, Reservable and Unreserved Bandwidth */
1390   iflp->max_bw = bw;
1391   iflp->max_rsv_bw = bw;
1392   for (i = 0; i < MAX_CLASS_TYPE; i++)
1393     iflp->unrsv_bw[i] = bw;
1394
1395   /* Update Link parameters status */
1396   iflp->lp_status = LP_TE | LP_MAX_BW | LP_MAX_RSV_BW | LP_UNRSV_BW;
1397
1398   /* Finally attach newly created Link Parameters */
1399   ifp->link_params = iflp;
1400
1401   return iflp;
1402 }
1403
1404 void
1405 if_link_params_free (struct interface *ifp)
1406 {
1407   if (ifp->link_params == NULL) return;
1408   XFREE(MTYPE_IF_LINK_PARAMS, ifp->link_params);
1409   ifp->link_params = NULL;
1410 }