Annotation of embedaddon/quagga/zebra/interface.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Interface function.
! 3: * Copyright (C) 1997, 1999 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
! 18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 20: * 02111-1307, USA.
! 21: */
! 22:
! 23: #include <zebra.h>
! 24:
! 25: #include "if.h"
! 26: #include "vty.h"
! 27: #include "sockunion.h"
! 28: #include "prefix.h"
! 29: #include "command.h"
! 30: #include "memory.h"
! 31: #include "ioctl.h"
! 32: #include "connected.h"
! 33: #include "log.h"
! 34: #include "zclient.h"
! 35:
! 36: #include "zebra/interface.h"
! 37: #include "zebra/rtadv.h"
! 38: #include "zebra/rib.h"
! 39: #include "zebra/zserv.h"
! 40: #include "zebra/redistribute.h"
! 41: #include "zebra/debug.h"
! 42: #include "zebra/irdp.h"
! 43:
! 44: #ifdef RTADV
! 45: /* Order is intentional. Matches RFC4191. This array is also used for
! 46: command matching, so only modify with care. */
! 47: const char *rtadv_pref_strs[] = { "medium", "high", "INVALID", "low", 0 };
! 48: #endif /* RTADV */
! 49:
! 50: /* Called when new interface is added. */
! 51: static int
! 52: if_zebra_new_hook (struct interface *ifp)
! 53: {
! 54: struct zebra_if *zebra_if;
! 55:
! 56: zebra_if = XCALLOC (MTYPE_TMP, sizeof (struct zebra_if));
! 57:
! 58: zebra_if->multicast = IF_ZEBRA_MULTICAST_UNSPEC;
! 59: zebra_if->shutdown = IF_ZEBRA_SHUTDOWN_UNSPEC;
! 60:
! 61: #ifdef RTADV
! 62: {
! 63: /* Set default router advertise values. */
! 64: struct rtadvconf *rtadv;
! 65:
! 66: rtadv = &zebra_if->rtadv;
! 67:
! 68: rtadv->AdvSendAdvertisements = 0;
! 69: rtadv->MaxRtrAdvInterval = RTADV_MAX_RTR_ADV_INTERVAL;
! 70: rtadv->MinRtrAdvInterval = RTADV_MIN_RTR_ADV_INTERVAL;
! 71: rtadv->AdvIntervalTimer = 0;
! 72: rtadv->AdvManagedFlag = 0;
! 73: rtadv->AdvOtherConfigFlag = 0;
! 74: rtadv->AdvHomeAgentFlag = 0;
! 75: rtadv->AdvLinkMTU = 0;
! 76: rtadv->AdvReachableTime = 0;
! 77: rtadv->AdvRetransTimer = 0;
! 78: rtadv->AdvCurHopLimit = 0;
! 79: rtadv->AdvDefaultLifetime = RTADV_ADV_DEFAULT_LIFETIME;
! 80: rtadv->HomeAgentPreference = 0;
! 81: rtadv->HomeAgentLifetime = RTADV_ADV_DEFAULT_LIFETIME;
! 82: rtadv->AdvIntervalOption = 0;
! 83: rtadv->DefaultPreference = RTADV_PREF_MEDIUM;
! 84:
! 85: rtadv->AdvPrefixList = list_new ();
! 86: }
! 87: #endif /* RTADV */
! 88:
! 89: /* Initialize installed address chains tree. */
! 90: zebra_if->ipv4_subnets = route_table_init ();
! 91:
! 92: ifp->info = zebra_if;
! 93: return 0;
! 94: }
! 95:
! 96: /* Called when interface is deleted. */
! 97: static int
! 98: if_zebra_delete_hook (struct interface *ifp)
! 99: {
! 100: struct zebra_if *zebra_if;
! 101:
! 102: if (ifp->info)
! 103: {
! 104: zebra_if = ifp->info;
! 105:
! 106: /* Free installed address chains tree. */
! 107: if (zebra_if->ipv4_subnets)
! 108: route_table_finish (zebra_if->ipv4_subnets);
! 109:
! 110: XFREE (MTYPE_TMP, zebra_if);
! 111: }
! 112:
! 113: return 0;
! 114: }
! 115:
! 116: /* Tie an interface address to its derived subnet list of addresses. */
! 117: int
! 118: if_subnet_add (struct interface *ifp, struct connected *ifc)
! 119: {
! 120: struct route_node *rn;
! 121: struct zebra_if *zebra_if;
! 122: struct prefix cp;
! 123: struct list *addr_list;
! 124:
! 125: assert (ifp && ifp->info && ifc);
! 126: zebra_if = ifp->info;
! 127:
! 128: /* Get address derived subnet node and associated address list, while marking
! 129: address secondary attribute appropriately. */
! 130: cp = *ifc->address;
! 131: apply_mask (&cp);
! 132: rn = route_node_get (zebra_if->ipv4_subnets, &cp);
! 133:
! 134: if ((addr_list = rn->info))
! 135: SET_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY);
! 136: else
! 137: {
! 138: UNSET_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY);
! 139: rn->info = addr_list = list_new ();
! 140: route_lock_node (rn);
! 141: }
! 142:
! 143: /* Tie address at the tail of address list. */
! 144: listnode_add (addr_list, ifc);
! 145:
! 146: /* Return list element count. */
! 147: return (addr_list->count);
! 148: }
! 149:
! 150: /* Untie an interface address from its derived subnet list of addresses. */
! 151: int
! 152: if_subnet_delete (struct interface *ifp, struct connected *ifc)
! 153: {
! 154: struct route_node *rn;
! 155: struct zebra_if *zebra_if;
! 156: struct list *addr_list;
! 157:
! 158: assert (ifp && ifp->info && ifc);
! 159: zebra_if = ifp->info;
! 160:
! 161: /* Get address derived subnet node. */
! 162: rn = route_node_lookup (zebra_if->ipv4_subnets, ifc->address);
! 163: if (! (rn && rn->info))
! 164: return -1;
! 165: route_unlock_node (rn);
! 166:
! 167: /* Untie address from subnet's address list. */
! 168: addr_list = rn->info;
! 169: listnode_delete (addr_list, ifc);
! 170: route_unlock_node (rn);
! 171:
! 172: /* Return list element count, if not empty. */
! 173: if (addr_list->count)
! 174: {
! 175: /* If deleted address is primary, mark subsequent one as such and distribute. */
! 176: if (! CHECK_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY))
! 177: {
! 178: ifc = listgetdata (listhead (addr_list));
! 179: zebra_interface_address_delete_update (ifp, ifc);
! 180: UNSET_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY);
! 181: zebra_interface_address_add_update (ifp, ifc);
! 182: }
! 183:
! 184: return addr_list->count;
! 185: }
! 186:
! 187: /* Otherwise, free list and route node. */
! 188: list_free (addr_list);
! 189: rn->info = NULL;
! 190: route_unlock_node (rn);
! 191:
! 192: return 0;
! 193: }
! 194:
! 195: /* if_flags_mangle: A place for hacks that require mangling
! 196: * or tweaking the interface flags.
! 197: *
! 198: * ******************** Solaris flags hacks **************************
! 199: *
! 200: * Solaris IFF_UP flag reflects only the primary interface as the
! 201: * routing socket only sends IFINFO for the primary interface. Hence
! 202: * ~IFF_UP does not per se imply all the logical interfaces are also
! 203: * down - which we only know of as addresses. Instead we must determine
! 204: * whether the interface really is up or not according to how many
! 205: * addresses are still attached. (Solaris always sends RTM_DELADDR if
! 206: * an interface, logical or not, goes ~IFF_UP).
! 207: *
! 208: * Ie, we mangle IFF_UP to *additionally* reflect whether or not there
! 209: * are addresses left in struct connected, not just the actual underlying
! 210: * IFF_UP flag.
! 211: *
! 212: * We must hence remember the real state of IFF_UP, which we do in
! 213: * struct zebra_if.primary_state.
! 214: *
! 215: * Setting IFF_UP within zebra to administratively shutdown the
! 216: * interface will affect only the primary interface/address on Solaris.
! 217: ************************End Solaris flags hacks ***********************
! 218: */
! 219: static inline void
! 220: if_flags_mangle (struct interface *ifp, uint64_t *newflags)
! 221: {
! 222: #ifdef SUNOS_5
! 223: struct zebra_if *zif = ifp->info;
! 224:
! 225: zif->primary_state = *newflags & (IFF_UP & 0xff);
! 226:
! 227: if (CHECK_FLAG (zif->primary_state, IFF_UP)
! 228: || listcount(ifp->connected) > 0)
! 229: SET_FLAG (*newflags, IFF_UP);
! 230: else
! 231: UNSET_FLAG (*newflags, IFF_UP);
! 232: #endif /* SUNOS_5 */
! 233: }
! 234:
! 235: /* Update the flags field of the ifp with the new flag set provided.
! 236: * Take whatever actions are required for any changes in flags we care
! 237: * about.
! 238: *
! 239: * newflags should be the raw value, as obtained from the OS.
! 240: */
! 241: void
! 242: if_flags_update (struct interface *ifp, uint64_t newflags)
! 243: {
! 244: if_flags_mangle (ifp, &newflags);
! 245:
! 246: if (if_is_operative (ifp))
! 247: {
! 248: /* operative -> inoperative? */
! 249: ifp->flags = newflags;
! 250: if (!if_is_operative (ifp))
! 251: if_down (ifp);
! 252: }
! 253: else
! 254: {
! 255: /* inoperative -> operative? */
! 256: ifp->flags = newflags;
! 257: if (if_is_operative (ifp))
! 258: if_up (ifp);
! 259: }
! 260: }
! 261:
! 262: /* Wake up configured address if it is not in current kernel
! 263: address. */
! 264: static void
! 265: if_addr_wakeup (struct interface *ifp)
! 266: {
! 267: struct listnode *node, *nnode;
! 268: struct connected *ifc;
! 269: struct prefix *p;
! 270: int ret;
! 271:
! 272: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, ifc))
! 273: {
! 274: p = ifc->address;
! 275:
! 276: if (CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED)
! 277: && ! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
! 278: {
! 279: /* Address check. */
! 280: if (p->family == AF_INET)
! 281: {
! 282: if (! if_is_up (ifp))
! 283: {
! 284: /* XXX: WTF is it trying to set flags here?
! 285: * caller has just gotten a new interface, has been
! 286: * handed the flags already. This code has no business
! 287: * trying to override administrative status of the interface.
! 288: * The only call path to here which doesn't originate from
! 289: * kernel event is irdp - what on earth is it trying to do?
! 290: *
! 291: * further RUNNING is not a settable flag on any system
! 292: * I (paulj) am aware of.
! 293: */
! 294: if_set_flags (ifp, IFF_UP | IFF_RUNNING);
! 295: if_refresh (ifp);
! 296: }
! 297:
! 298: ret = if_set_prefix (ifp, ifc);
! 299: if (ret < 0)
! 300: {
! 301: zlog_warn ("Can't set interface's address: %s",
! 302: safe_strerror(errno));
! 303: continue;
! 304: }
! 305:
! 306: /* Add to subnet chain list. */
! 307: if_subnet_add (ifp, ifc);
! 308:
! 309: SET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
! 310:
! 311: zebra_interface_address_add_update (ifp, ifc);
! 312:
! 313: if (if_is_operative(ifp))
! 314: connected_up_ipv4 (ifp, ifc);
! 315: }
! 316: #ifdef HAVE_IPV6
! 317: if (p->family == AF_INET6)
! 318: {
! 319: if (! if_is_up (ifp))
! 320: {
! 321: /* XXX: See long comment above */
! 322: if_set_flags (ifp, IFF_UP | IFF_RUNNING);
! 323: if_refresh (ifp);
! 324: }
! 325:
! 326: ret = if_prefix_add_ipv6 (ifp, ifc);
! 327: if (ret < 0)
! 328: {
! 329: zlog_warn ("Can't set interface's address: %s",
! 330: safe_strerror(errno));
! 331: continue;
! 332: }
! 333: SET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
! 334:
! 335: zebra_interface_address_add_update (ifp, ifc);
! 336:
! 337: if (if_is_operative(ifp))
! 338: connected_up_ipv6 (ifp, ifc);
! 339: }
! 340: #endif /* HAVE_IPV6 */
! 341: }
! 342: }
! 343: }
! 344:
! 345: /* Handle interface addition */
! 346: void
! 347: if_add_update (struct interface *ifp)
! 348: {
! 349: struct zebra_if *if_data;
! 350:
! 351: if_data = ifp->info;
! 352: if (if_data->multicast == IF_ZEBRA_MULTICAST_ON)
! 353: if_set_flags (ifp, IFF_MULTICAST);
! 354: else if (if_data->multicast == IF_ZEBRA_MULTICAST_OFF)
! 355: if_unset_flags (ifp, IFF_MULTICAST);
! 356:
! 357: zebra_interface_add_update (ifp);
! 358:
! 359: if (! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 360: {
! 361: SET_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE);
! 362:
! 363: if_addr_wakeup (ifp);
! 364:
! 365: if (IS_ZEBRA_DEBUG_KERNEL)
! 366: zlog_debug ("interface %s index %d becomes active.",
! 367: ifp->name, ifp->ifindex);
! 368: }
! 369: else
! 370: {
! 371: if (IS_ZEBRA_DEBUG_KERNEL)
! 372: zlog_debug ("interface %s index %d is added.", ifp->name, ifp->ifindex);
! 373: }
! 374: }
! 375:
! 376: /* Handle an interface delete event */
! 377: void
! 378: if_delete_update (struct interface *ifp)
! 379: {
! 380: struct connected *ifc;
! 381: struct prefix *p;
! 382: struct route_node *rn;
! 383: struct zebra_if *zebra_if;
! 384:
! 385: zebra_if = ifp->info;
! 386:
! 387: if (if_is_up(ifp))
! 388: {
! 389: zlog_err ("interface %s index %d is still up while being deleted.",
! 390: ifp->name, ifp->ifindex);
! 391: return;
! 392: }
! 393:
! 394: /* Mark interface as inactive */
! 395: UNSET_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE);
! 396:
! 397: if (IS_ZEBRA_DEBUG_KERNEL)
! 398: zlog_debug ("interface %s index %d is now inactive.",
! 399: ifp->name, ifp->ifindex);
! 400:
! 401: /* Delete connected routes from the kernel. */
! 402: if (ifp->connected)
! 403: {
! 404: struct listnode *node;
! 405: struct listnode *last = NULL;
! 406:
! 407: while ((node = (last ? last->next : listhead (ifp->connected))))
! 408: {
! 409: ifc = listgetdata (node);
! 410: p = ifc->address;
! 411:
! 412: if (p->family == AF_INET
! 413: && (rn = route_node_lookup (zebra_if->ipv4_subnets, p)))
! 414: {
! 415: struct listnode *anode;
! 416: struct listnode *next;
! 417: struct listnode *first;
! 418: struct list *addr_list;
! 419:
! 420: route_unlock_node (rn);
! 421: addr_list = (struct list *) rn->info;
! 422:
! 423: /* Remove addresses, secondaries first. */
! 424: first = listhead (addr_list);
! 425: for (anode = first->next; anode || first; anode = next)
! 426: {
! 427: if (!anode)
! 428: {
! 429: anode = first;
! 430: first = NULL;
! 431: }
! 432: next = anode->next;
! 433:
! 434: ifc = listgetdata (anode);
! 435: p = ifc->address;
! 436:
! 437: connected_down_ipv4 (ifp, ifc);
! 438:
! 439: zebra_interface_address_delete_update (ifp, ifc);
! 440:
! 441: UNSET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
! 442:
! 443: /* Remove from subnet chain. */
! 444: list_delete_node (addr_list, anode);
! 445: route_unlock_node (rn);
! 446:
! 447: /* Remove from interface address list (unconditionally). */
! 448: if (!CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 449: {
! 450: listnode_delete (ifp->connected, ifc);
! 451: connected_free (ifc);
! 452: }
! 453: else
! 454: last = node;
! 455: }
! 456:
! 457: /* Free chain list and respective route node. */
! 458: list_delete (addr_list);
! 459: rn->info = NULL;
! 460: route_unlock_node (rn);
! 461: }
! 462: #ifdef HAVE_IPV6
! 463: else if (p->family == AF_INET6)
! 464: {
! 465: connected_down_ipv6 (ifp, ifc);
! 466:
! 467: zebra_interface_address_delete_update (ifp, ifc);
! 468:
! 469: UNSET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
! 470:
! 471: if (CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 472: last = node;
! 473: else
! 474: {
! 475: listnode_delete (ifp->connected, ifc);
! 476: connected_free (ifc);
! 477: }
! 478: }
! 479: #endif /* HAVE_IPV6 */
! 480: else
! 481: {
! 482: last = node;
! 483: }
! 484: }
! 485: }
! 486: zebra_interface_delete_update (ifp);
! 487:
! 488: /* Update ifindex after distributing the delete message. This is in
! 489: case any client needs to have the old value of ifindex available
! 490: while processing the deletion. Each client daemon is responsible
! 491: for setting ifindex to IFINDEX_INTERNAL after processing the
! 492: interface deletion message. */
! 493: ifp->ifindex = IFINDEX_INTERNAL;
! 494: }
! 495:
! 496: /* Interface is up. */
! 497: void
! 498: if_up (struct interface *ifp)
! 499: {
! 500: struct listnode *node;
! 501: struct listnode *next;
! 502: struct connected *ifc;
! 503: struct prefix *p;
! 504:
! 505: /* Notify the protocol daemons. */
! 506: zebra_interface_up_update (ifp);
! 507:
! 508: /* Install connected routes to the kernel. */
! 509: if (ifp->connected)
! 510: {
! 511: for (ALL_LIST_ELEMENTS (ifp->connected, node, next, ifc))
! 512: {
! 513: p = ifc->address;
! 514:
! 515: if (p->family == AF_INET)
! 516: connected_up_ipv4 (ifp, ifc);
! 517: #ifdef HAVE_IPV6
! 518: else if (p->family == AF_INET6)
! 519: connected_up_ipv6 (ifp, ifc);
! 520: #endif /* HAVE_IPV6 */
! 521: }
! 522: }
! 523:
! 524: /* Examine all static routes. */
! 525: rib_update ();
! 526: }
! 527:
! 528: /* Interface goes down. We have to manage different behavior of based
! 529: OS. */
! 530: void
! 531: if_down (struct interface *ifp)
! 532: {
! 533: struct listnode *node;
! 534: struct listnode *next;
! 535: struct connected *ifc;
! 536: struct prefix *p;
! 537:
! 538: /* Notify to the protocol daemons. */
! 539: zebra_interface_down_update (ifp);
! 540:
! 541: /* Delete connected routes from the kernel. */
! 542: if (ifp->connected)
! 543: {
! 544: for (ALL_LIST_ELEMENTS (ifp->connected, node, next, ifc))
! 545: {
! 546: p = ifc->address;
! 547:
! 548: if (p->family == AF_INET)
! 549: connected_down_ipv4 (ifp, ifc);
! 550: #ifdef HAVE_IPV6
! 551: else if (p->family == AF_INET6)
! 552: connected_down_ipv6 (ifp, ifc);
! 553: #endif /* HAVE_IPV6 */
! 554: }
! 555: }
! 556:
! 557: /* Examine all static routes which direct to the interface. */
! 558: rib_update ();
! 559: }
! 560:
! 561: void
! 562: if_refresh (struct interface *ifp)
! 563: {
! 564: if_get_flags (ifp);
! 565: }
! 566:
! 567: /* Output prefix string to vty. */
! 568: static int
! 569: prefix_vty_out (struct vty *vty, struct prefix *p)
! 570: {
! 571: char str[INET6_ADDRSTRLEN];
! 572:
! 573: inet_ntop (p->family, &p->u.prefix, str, sizeof (str));
! 574: vty_out (vty, "%s", str);
! 575: return strlen (str);
! 576: }
! 577:
! 578: /* Dump if address information to vty. */
! 579: static void
! 580: connected_dump_vty (struct vty *vty, struct connected *connected)
! 581: {
! 582: struct prefix *p;
! 583:
! 584: /* Print interface address. */
! 585: p = connected->address;
! 586: vty_out (vty, " %s ", prefix_family_str (p));
! 587: prefix_vty_out (vty, p);
! 588: vty_out (vty, "/%d", p->prefixlen);
! 589:
! 590: /* If there is destination address, print it. */
! 591: if (connected->destination)
! 592: {
! 593: vty_out (vty, (CONNECTED_PEER(connected) ? " peer " : " broadcast "));
! 594: prefix_vty_out (vty, connected->destination);
! 595: }
! 596:
! 597: if (CHECK_FLAG (connected->flags, ZEBRA_IFA_SECONDARY))
! 598: vty_out (vty, " secondary");
! 599:
! 600: if (connected->label)
! 601: vty_out (vty, " %s", connected->label);
! 602:
! 603: vty_out (vty, "%s", VTY_NEWLINE);
! 604: }
! 605:
! 606: #ifdef RTADV
! 607: /* Dump interface ND information to vty. */
! 608: static void
! 609: nd_dump_vty (struct vty *vty, struct interface *ifp)
! 610: {
! 611: struct zebra_if *zif;
! 612: struct rtadvconf *rtadv;
! 613: int interval;
! 614:
! 615: zif = (struct zebra_if *) ifp->info;
! 616: rtadv = &zif->rtadv;
! 617:
! 618: if (rtadv->AdvSendAdvertisements)
! 619: {
! 620: vty_out (vty, " ND advertised reachable time is %d milliseconds%s",
! 621: rtadv->AdvReachableTime, VTY_NEWLINE);
! 622: vty_out (vty, " ND advertised retransmit interval is %d milliseconds%s",
! 623: rtadv->AdvRetransTimer, VTY_NEWLINE);
! 624: interval = rtadv->MaxRtrAdvInterval;
! 625: if (interval % 1000)
! 626: vty_out (vty, " ND router advertisements are sent every "
! 627: "%d milliseconds%s", interval,
! 628: VTY_NEWLINE);
! 629: else
! 630: vty_out (vty, " ND router advertisements are sent every "
! 631: "%d seconds%s", interval / 1000,
! 632: VTY_NEWLINE);
! 633: vty_out (vty, " ND router advertisements live for %d seconds%s",
! 634: rtadv->AdvDefaultLifetime, VTY_NEWLINE);
! 635: vty_out (vty, " ND router advertisement default router preference is "
! 636: "%s%s", rtadv_pref_strs[rtadv->DefaultPreference],
! 637: VTY_NEWLINE);
! 638: if (rtadv->AdvManagedFlag)
! 639: vty_out (vty, " Hosts use DHCP to obtain routable addresses.%s",
! 640: VTY_NEWLINE);
! 641: else
! 642: vty_out (vty, " Hosts use stateless autoconfig for addresses.%s",
! 643: VTY_NEWLINE);
! 644: if (rtadv->AdvHomeAgentFlag)
! 645: vty_out (vty, " ND router advertisements with "
! 646: "Home Agent flag bit set.%s",
! 647: VTY_NEWLINE);
! 648: if (rtadv->AdvIntervalOption)
! 649: vty_out (vty, " ND router advertisements with Adv. Interval option.%s",
! 650: VTY_NEWLINE);
! 651: }
! 652: }
! 653: #endif /* RTADV */
! 654:
! 655: /* Interface's information print out to vty interface. */
! 656: static void
! 657: if_dump_vty (struct vty *vty, struct interface *ifp)
! 658: {
! 659: #ifdef HAVE_STRUCT_SOCKADDR_DL
! 660: struct sockaddr_dl *sdl;
! 661: #endif /* HAVE_STRUCT_SOCKADDR_DL */
! 662: struct connected *connected;
! 663: struct listnode *node;
! 664: struct route_node *rn;
! 665: struct zebra_if *zebra_if;
! 666:
! 667: zebra_if = ifp->info;
! 668:
! 669: vty_out (vty, "Interface %s is ", ifp->name);
! 670: if (if_is_up(ifp)) {
! 671: vty_out (vty, "up, line protocol ");
! 672:
! 673: if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)) {
! 674: if (if_is_running(ifp))
! 675: vty_out (vty, "is up%s", VTY_NEWLINE);
! 676: else
! 677: vty_out (vty, "is down%s", VTY_NEWLINE);
! 678: } else {
! 679: vty_out (vty, "detection is disabled%s", VTY_NEWLINE);
! 680: }
! 681: } else {
! 682: vty_out (vty, "down%s", VTY_NEWLINE);
! 683: }
! 684:
! 685: if (ifp->desc)
! 686: vty_out (vty, " Description: %s%s", ifp->desc,
! 687: VTY_NEWLINE);
! 688: if (ifp->ifindex == IFINDEX_INTERNAL)
! 689: {
! 690: vty_out(vty, " pseudo interface%s", VTY_NEWLINE);
! 691: return;
! 692: }
! 693: else if (! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 694: {
! 695: vty_out(vty, " index %d inactive interface%s",
! 696: ifp->ifindex,
! 697: VTY_NEWLINE);
! 698: return;
! 699: }
! 700:
! 701: vty_out (vty, " index %d metric %d mtu %d ",
! 702: ifp->ifindex, ifp->metric, ifp->mtu);
! 703: #ifdef HAVE_IPV6
! 704: if (ifp->mtu6 != ifp->mtu)
! 705: vty_out (vty, "mtu6 %d ", ifp->mtu6);
! 706: #endif
! 707: vty_out (vty, "%s flags: %s%s", VTY_NEWLINE,
! 708: if_flag_dump (ifp->flags), VTY_NEWLINE);
! 709:
! 710: /* Hardware address. */
! 711: #ifdef HAVE_STRUCT_SOCKADDR_DL
! 712: sdl = &ifp->sdl;
! 713: if (sdl != NULL && sdl->sdl_alen != 0)
! 714: {
! 715: int i;
! 716: u_char *ptr;
! 717:
! 718: vty_out (vty, " HWaddr: ");
! 719: for (i = 0, ptr = (u_char *)LLADDR (sdl); i < sdl->sdl_alen; i++, ptr++)
! 720: vty_out (vty, "%s%02x", i == 0 ? "" : ":", *ptr);
! 721: vty_out (vty, "%s", VTY_NEWLINE);
! 722: }
! 723: #else
! 724: if (ifp->hw_addr_len != 0)
! 725: {
! 726: int i;
! 727:
! 728: vty_out (vty, " HWaddr: ");
! 729: for (i = 0; i < ifp->hw_addr_len; i++)
! 730: vty_out (vty, "%s%02x", i == 0 ? "" : ":", ifp->hw_addr[i]);
! 731: vty_out (vty, "%s", VTY_NEWLINE);
! 732: }
! 733: #endif /* HAVE_STRUCT_SOCKADDR_DL */
! 734:
! 735: /* Bandwidth in kbps */
! 736: if (ifp->bandwidth != 0)
! 737: {
! 738: vty_out(vty, " bandwidth %u kbps", ifp->bandwidth);
! 739: vty_out(vty, "%s", VTY_NEWLINE);
! 740: }
! 741:
! 742: for (rn = route_top (zebra_if->ipv4_subnets); rn; rn = route_next (rn))
! 743: {
! 744: if (! rn->info)
! 745: continue;
! 746:
! 747: for (ALL_LIST_ELEMENTS_RO ((struct list *)rn->info, node, connected))
! 748: connected_dump_vty (vty, connected);
! 749: }
! 750:
! 751: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, connected))
! 752: {
! 753: if (CHECK_FLAG (connected->conf, ZEBRA_IFC_REAL) &&
! 754: (connected->address->family == AF_INET6))
! 755: connected_dump_vty (vty, connected);
! 756: }
! 757:
! 758: #ifdef RTADV
! 759: nd_dump_vty (vty, ifp);
! 760: #endif /* RTADV */
! 761:
! 762: #ifdef HAVE_PROC_NET_DEV
! 763: /* Statistics print out using proc file system. */
! 764: vty_out (vty, " %lu input packets (%lu multicast), %lu bytes, "
! 765: "%lu dropped%s",
! 766: ifp->stats.rx_packets, ifp->stats.rx_multicast,
! 767: ifp->stats.rx_bytes, ifp->stats.rx_dropped, VTY_NEWLINE);
! 768:
! 769: vty_out (vty, " %lu input errors, %lu length, %lu overrun,"
! 770: " %lu CRC, %lu frame%s",
! 771: ifp->stats.rx_errors, ifp->stats.rx_length_errors,
! 772: ifp->stats.rx_over_errors, ifp->stats.rx_crc_errors,
! 773: ifp->stats.rx_frame_errors, VTY_NEWLINE);
! 774:
! 775: vty_out (vty, " %lu fifo, %lu missed%s", ifp->stats.rx_fifo_errors,
! 776: ifp->stats.rx_missed_errors, VTY_NEWLINE);
! 777:
! 778: vty_out (vty, " %lu output packets, %lu bytes, %lu dropped%s",
! 779: ifp->stats.tx_packets, ifp->stats.tx_bytes,
! 780: ifp->stats.tx_dropped, VTY_NEWLINE);
! 781:
! 782: vty_out (vty, " %lu output errors, %lu aborted, %lu carrier,"
! 783: " %lu fifo, %lu heartbeat%s",
! 784: ifp->stats.tx_errors, ifp->stats.tx_aborted_errors,
! 785: ifp->stats.tx_carrier_errors, ifp->stats.tx_fifo_errors,
! 786: ifp->stats.tx_heartbeat_errors, VTY_NEWLINE);
! 787:
! 788: vty_out (vty, " %lu window, %lu collisions%s",
! 789: ifp->stats.tx_window_errors, ifp->stats.collisions, VTY_NEWLINE);
! 790: #endif /* HAVE_PROC_NET_DEV */
! 791:
! 792: #ifdef HAVE_NET_RT_IFLIST
! 793: #if defined (__bsdi__) || defined (__NetBSD__)
! 794: /* Statistics print out using sysctl (). */
! 795: vty_out (vty, " input packets %qu, bytes %qu, dropped %qu,"
! 796: " multicast packets %qu%s",
! 797: ifp->stats.ifi_ipackets, ifp->stats.ifi_ibytes,
! 798: ifp->stats.ifi_iqdrops, ifp->stats.ifi_imcasts,
! 799: VTY_NEWLINE);
! 800:
! 801: vty_out (vty, " input errors %qu%s",
! 802: ifp->stats.ifi_ierrors, VTY_NEWLINE);
! 803:
! 804: vty_out (vty, " output packets %qu, bytes %qu, multicast packets %qu%s",
! 805: ifp->stats.ifi_opackets, ifp->stats.ifi_obytes,
! 806: ifp->stats.ifi_omcasts, VTY_NEWLINE);
! 807:
! 808: vty_out (vty, " output errors %qu%s",
! 809: ifp->stats.ifi_oerrors, VTY_NEWLINE);
! 810:
! 811: vty_out (vty, " collisions %qu%s",
! 812: ifp->stats.ifi_collisions, VTY_NEWLINE);
! 813: #else
! 814: /* Statistics print out using sysctl (). */
! 815: vty_out (vty, " input packets %lu, bytes %lu, dropped %lu,"
! 816: " multicast packets %lu%s",
! 817: ifp->stats.ifi_ipackets, ifp->stats.ifi_ibytes,
! 818: ifp->stats.ifi_iqdrops, ifp->stats.ifi_imcasts,
! 819: VTY_NEWLINE);
! 820:
! 821: vty_out (vty, " input errors %lu%s",
! 822: ifp->stats.ifi_ierrors, VTY_NEWLINE);
! 823:
! 824: vty_out (vty, " output packets %lu, bytes %lu, multicast packets %lu%s",
! 825: ifp->stats.ifi_opackets, ifp->stats.ifi_obytes,
! 826: ifp->stats.ifi_omcasts, VTY_NEWLINE);
! 827:
! 828: vty_out (vty, " output errors %lu%s",
! 829: ifp->stats.ifi_oerrors, VTY_NEWLINE);
! 830:
! 831: vty_out (vty, " collisions %lu%s",
! 832: ifp->stats.ifi_collisions, VTY_NEWLINE);
! 833: #endif /* __bsdi__ || __NetBSD__ */
! 834: #endif /* HAVE_NET_RT_IFLIST */
! 835: }
! 836:
! 837: /* Wrapper hook point for zebra daemon so that ifindex can be set
! 838: * DEFUN macro not used as extract.pl HAS to ignore this
! 839: * See also interface_cmd in lib/if.c
! 840: */
! 841: DEFUN_NOSH (zebra_interface,
! 842: zebra_interface_cmd,
! 843: "interface IFNAME",
! 844: "Select an interface to configure\n"
! 845: "Interface's name\n")
! 846: {
! 847: int ret;
! 848: struct interface * ifp;
! 849:
! 850: /* Call lib interface() */
! 851: if ((ret = interface_cmd.func (self, vty, argc, argv)) != CMD_SUCCESS)
! 852: return ret;
! 853:
! 854: ifp = vty->index;
! 855:
! 856: if (ifp->ifindex == IFINDEX_INTERNAL)
! 857: /* Is this really necessary? Shouldn't status be initialized to 0
! 858: in that case? */
! 859: UNSET_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE);
! 860:
! 861: return ret;
! 862: }
! 863:
! 864: struct cmd_node interface_node =
! 865: {
! 866: INTERFACE_NODE,
! 867: "%s(config-if)# ",
! 868: 1
! 869: };
! 870:
! 871: /* Show all or specified interface to vty. */
! 872: DEFUN (show_interface, show_interface_cmd,
! 873: "show interface [IFNAME]",
! 874: SHOW_STR
! 875: "Interface status and configuration\n"
! 876: "Inteface name\n")
! 877: {
! 878: struct listnode *node;
! 879: struct interface *ifp;
! 880:
! 881: #ifdef HAVE_PROC_NET_DEV
! 882: /* If system has interface statistics via proc file system, update
! 883: statistics. */
! 884: ifstat_update_proc ();
! 885: #endif /* HAVE_PROC_NET_DEV */
! 886: #ifdef HAVE_NET_RT_IFLIST
! 887: ifstat_update_sysctl ();
! 888: #endif /* HAVE_NET_RT_IFLIST */
! 889:
! 890: /* Specified interface print. */
! 891: if (argc != 0)
! 892: {
! 893: ifp = if_lookup_by_name (argv[0]);
! 894: if (ifp == NULL)
! 895: {
! 896: vty_out (vty, "%% Can't find interface %s%s", argv[0],
! 897: VTY_NEWLINE);
! 898: return CMD_WARNING;
! 899: }
! 900: if_dump_vty (vty, ifp);
! 901: return CMD_SUCCESS;
! 902: }
! 903:
! 904: /* All interface print. */
! 905: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 906: if_dump_vty (vty, ifp);
! 907:
! 908: return CMD_SUCCESS;
! 909: }
! 910:
! 911: DEFUN (show_interface_desc,
! 912: show_interface_desc_cmd,
! 913: "show interface description",
! 914: SHOW_STR
! 915: "Interface status and configuration\n"
! 916: "Interface description\n")
! 917: {
! 918: struct listnode *node;
! 919: struct interface *ifp;
! 920:
! 921: vty_out (vty, "Interface Status Protocol Description%s", VTY_NEWLINE);
! 922: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 923: {
! 924: int len;
! 925:
! 926: len = vty_out (vty, "%s", ifp->name);
! 927: vty_out (vty, "%*s", (16 - len), " ");
! 928:
! 929: if (if_is_up(ifp))
! 930: {
! 931: vty_out (vty, "up ");
! 932: if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION))
! 933: {
! 934: if (if_is_running(ifp))
! 935: vty_out (vty, "up ");
! 936: else
! 937: vty_out (vty, "down ");
! 938: }
! 939: else
! 940: {
! 941: vty_out (vty, "unknown ");
! 942: }
! 943: }
! 944: else
! 945: {
! 946: vty_out (vty, "down down ");
! 947: }
! 948:
! 949: if (ifp->desc)
! 950: vty_out (vty, "%s", ifp->desc);
! 951: vty_out (vty, "%s", VTY_NEWLINE);
! 952: }
! 953: return CMD_SUCCESS;
! 954: }
! 955:
! 956: DEFUN (multicast,
! 957: multicast_cmd,
! 958: "multicast",
! 959: "Set multicast flag to interface\n")
! 960: {
! 961: int ret;
! 962: struct interface *ifp;
! 963: struct zebra_if *if_data;
! 964:
! 965: ifp = (struct interface *) vty->index;
! 966: if (CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 967: {
! 968: ret = if_set_flags (ifp, IFF_MULTICAST);
! 969: if (ret < 0)
! 970: {
! 971: vty_out (vty, "Can't set multicast flag%s", VTY_NEWLINE);
! 972: return CMD_WARNING;
! 973: }
! 974: if_refresh (ifp);
! 975: }
! 976: if_data = ifp->info;
! 977: if_data->multicast = IF_ZEBRA_MULTICAST_ON;
! 978:
! 979: return CMD_SUCCESS;
! 980: }
! 981:
! 982: DEFUN (no_multicast,
! 983: no_multicast_cmd,
! 984: "no multicast",
! 985: NO_STR
! 986: "Unset multicast flag to interface\n")
! 987: {
! 988: int ret;
! 989: struct interface *ifp;
! 990: struct zebra_if *if_data;
! 991:
! 992: ifp = (struct interface *) vty->index;
! 993: if (CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 994: {
! 995: ret = if_unset_flags (ifp, IFF_MULTICAST);
! 996: if (ret < 0)
! 997: {
! 998: vty_out (vty, "Can't unset multicast flag%s", VTY_NEWLINE);
! 999: return CMD_WARNING;
! 1000: }
! 1001: if_refresh (ifp);
! 1002: }
! 1003: if_data = ifp->info;
! 1004: if_data->multicast = IF_ZEBRA_MULTICAST_OFF;
! 1005:
! 1006: return CMD_SUCCESS;
! 1007: }
! 1008:
! 1009: DEFUN (linkdetect,
! 1010: linkdetect_cmd,
! 1011: "link-detect",
! 1012: "Enable link detection on interface\n")
! 1013: {
! 1014: struct interface *ifp;
! 1015: int if_was_operative;
! 1016:
! 1017: ifp = (struct interface *) vty->index;
! 1018: if_was_operative = if_is_operative(ifp);
! 1019: SET_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION);
! 1020:
! 1021: /* When linkdetection is enabled, if might come down */
! 1022: if (!if_is_operative(ifp) && if_was_operative) if_down(ifp);
! 1023:
! 1024: /* FIXME: Will defer status change forwarding if interface
! 1025: does not come down! */
! 1026:
! 1027: return CMD_SUCCESS;
! 1028: }
! 1029:
! 1030:
! 1031: DEFUN (no_linkdetect,
! 1032: no_linkdetect_cmd,
! 1033: "no link-detect",
! 1034: NO_STR
! 1035: "Disable link detection on interface\n")
! 1036: {
! 1037: struct interface *ifp;
! 1038: int if_was_operative;
! 1039:
! 1040: ifp = (struct interface *) vty->index;
! 1041: if_was_operative = if_is_operative(ifp);
! 1042: UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION);
! 1043:
! 1044: /* Interface may come up after disabling link detection */
! 1045: if (if_is_operative(ifp) && !if_was_operative) if_up(ifp);
! 1046:
! 1047: /* FIXME: see linkdetect_cmd */
! 1048:
! 1049: return CMD_SUCCESS;
! 1050: }
! 1051:
! 1052: DEFUN (shutdown_if,
! 1053: shutdown_if_cmd,
! 1054: "shutdown",
! 1055: "Shutdown the selected interface\n")
! 1056: {
! 1057: int ret;
! 1058: struct interface *ifp;
! 1059: struct zebra_if *if_data;
! 1060:
! 1061: ifp = (struct interface *) vty->index;
! 1062: ret = if_unset_flags (ifp, IFF_UP);
! 1063: if (ret < 0)
! 1064: {
! 1065: vty_out (vty, "Can't shutdown interface%s", VTY_NEWLINE);
! 1066: return CMD_WARNING;
! 1067: }
! 1068: if_refresh (ifp);
! 1069: if_data = ifp->info;
! 1070: if_data->shutdown = IF_ZEBRA_SHUTDOWN_ON;
! 1071:
! 1072: return CMD_SUCCESS;
! 1073: }
! 1074:
! 1075: DEFUN (no_shutdown_if,
! 1076: no_shutdown_if_cmd,
! 1077: "no shutdown",
! 1078: NO_STR
! 1079: "Shutdown the selected interface\n")
! 1080: {
! 1081: int ret;
! 1082: struct interface *ifp;
! 1083: struct zebra_if *if_data;
! 1084:
! 1085: ifp = (struct interface *) vty->index;
! 1086: ret = if_set_flags (ifp, IFF_UP | IFF_RUNNING);
! 1087: if (ret < 0)
! 1088: {
! 1089: vty_out (vty, "Can't up interface%s", VTY_NEWLINE);
! 1090: return CMD_WARNING;
! 1091: }
! 1092: if_refresh (ifp);
! 1093: if_data = ifp->info;
! 1094: if_data->shutdown = IF_ZEBRA_SHUTDOWN_OFF;
! 1095:
! 1096: return CMD_SUCCESS;
! 1097: }
! 1098:
! 1099: DEFUN (bandwidth_if,
! 1100: bandwidth_if_cmd,
! 1101: "bandwidth <1-10000000>",
! 1102: "Set bandwidth informational parameter\n"
! 1103: "Bandwidth in kilobits\n")
! 1104: {
! 1105: struct interface *ifp;
! 1106: unsigned int bandwidth;
! 1107:
! 1108: ifp = (struct interface *) vty->index;
! 1109: bandwidth = strtol(argv[0], NULL, 10);
! 1110:
! 1111: /* bandwidth range is <1-10000000> */
! 1112: if (bandwidth < 1 || bandwidth > 10000000)
! 1113: {
! 1114: vty_out (vty, "Bandwidth is invalid%s", VTY_NEWLINE);
! 1115: return CMD_WARNING;
! 1116: }
! 1117:
! 1118: ifp->bandwidth = bandwidth;
! 1119:
! 1120: /* force protocols to recalculate routes due to cost change */
! 1121: if (if_is_operative (ifp))
! 1122: zebra_interface_up_update (ifp);
! 1123:
! 1124: return CMD_SUCCESS;
! 1125: }
! 1126:
! 1127: DEFUN (no_bandwidth_if,
! 1128: no_bandwidth_if_cmd,
! 1129: "no bandwidth",
! 1130: NO_STR
! 1131: "Set bandwidth informational parameter\n")
! 1132: {
! 1133: struct interface *ifp;
! 1134:
! 1135: ifp = (struct interface *) vty->index;
! 1136:
! 1137: ifp->bandwidth = 0;
! 1138:
! 1139: /* force protocols to recalculate routes due to cost change */
! 1140: if (if_is_operative (ifp))
! 1141: zebra_interface_up_update (ifp);
! 1142:
! 1143: return CMD_SUCCESS;
! 1144: }
! 1145:
! 1146: ALIAS (no_bandwidth_if,
! 1147: no_bandwidth_if_val_cmd,
! 1148: "no bandwidth <1-10000000>",
! 1149: NO_STR
! 1150: "Set bandwidth informational parameter\n"
! 1151: "Bandwidth in kilobits\n")
! 1152:
! 1153: static int
! 1154: ip_address_install (struct vty *vty, struct interface *ifp,
! 1155: const char *addr_str, const char *peer_str,
! 1156: const char *label)
! 1157: {
! 1158: struct prefix_ipv4 cp;
! 1159: struct connected *ifc;
! 1160: struct prefix_ipv4 *p;
! 1161: int ret;
! 1162:
! 1163: ret = str2prefix_ipv4 (addr_str, &cp);
! 1164: if (ret <= 0)
! 1165: {
! 1166: vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
! 1167: return CMD_WARNING;
! 1168: }
! 1169:
! 1170: ifc = connected_check (ifp, (struct prefix *) &cp);
! 1171: if (! ifc)
! 1172: {
! 1173: ifc = connected_new ();
! 1174: ifc->ifp = ifp;
! 1175:
! 1176: /* Address. */
! 1177: p = prefix_ipv4_new ();
! 1178: *p = cp;
! 1179: ifc->address = (struct prefix *) p;
! 1180:
! 1181: /* Broadcast. */
! 1182: if (p->prefixlen <= IPV4_MAX_PREFIXLEN-2)
! 1183: {
! 1184: p = prefix_ipv4_new ();
! 1185: *p = cp;
! 1186: p->prefix.s_addr = ipv4_broadcast_addr(p->prefix.s_addr,p->prefixlen);
! 1187: ifc->destination = (struct prefix *) p;
! 1188: }
! 1189:
! 1190: /* Label. */
! 1191: if (label)
! 1192: ifc->label = XSTRDUP (MTYPE_CONNECTED_LABEL, label);
! 1193:
! 1194: /* Add to linked list. */
! 1195: listnode_add (ifp->connected, ifc);
! 1196: }
! 1197:
! 1198: /* This address is configured from zebra. */
! 1199: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 1200: SET_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED);
! 1201:
! 1202: /* In case of this route need to install kernel. */
! 1203: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL)
! 1204: && CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 1205: {
! 1206: /* Some system need to up the interface to set IP address. */
! 1207: if (! if_is_up (ifp))
! 1208: {
! 1209: if_set_flags (ifp, IFF_UP | IFF_RUNNING);
! 1210: if_refresh (ifp);
! 1211: }
! 1212:
! 1213: ret = if_set_prefix (ifp, ifc);
! 1214: if (ret < 0)
! 1215: {
! 1216: vty_out (vty, "%% Can't set interface IP address: %s.%s",
! 1217: safe_strerror(errno), VTY_NEWLINE);
! 1218: return CMD_WARNING;
! 1219: }
! 1220:
! 1221: /* Add to subnet chain list (while marking secondary attribute). */
! 1222: if_subnet_add (ifp, ifc);
! 1223:
! 1224: /* IP address propery set. */
! 1225: SET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
! 1226:
! 1227: /* Update interface address information to protocol daemon. */
! 1228: zebra_interface_address_add_update (ifp, ifc);
! 1229:
! 1230: /* If interface is up register connected route. */
! 1231: if (if_is_operative(ifp))
! 1232: connected_up_ipv4 (ifp, ifc);
! 1233: }
! 1234:
! 1235: return CMD_SUCCESS;
! 1236: }
! 1237:
! 1238: static int
! 1239: ip_address_uninstall (struct vty *vty, struct interface *ifp,
! 1240: const char *addr_str, const char *peer_str,
! 1241: const char *label)
! 1242: {
! 1243: struct prefix_ipv4 cp;
! 1244: struct connected *ifc;
! 1245: int ret;
! 1246:
! 1247: /* Convert to prefix structure. */
! 1248: ret = str2prefix_ipv4 (addr_str, &cp);
! 1249: if (ret <= 0)
! 1250: {
! 1251: vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
! 1252: return CMD_WARNING;
! 1253: }
! 1254:
! 1255: /* Check current interface address. */
! 1256: ifc = connected_check (ifp, (struct prefix *) &cp);
! 1257: if (! ifc)
! 1258: {
! 1259: vty_out (vty, "%% Can't find address%s", VTY_NEWLINE);
! 1260: return CMD_WARNING;
! 1261: }
! 1262:
! 1263: /* This is not configured address. */
! 1264: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 1265: return CMD_WARNING;
! 1266:
! 1267: UNSET_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED);
! 1268:
! 1269: /* This is not real address or interface is not active. */
! 1270: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL)
! 1271: || ! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 1272: {
! 1273: listnode_delete (ifp->connected, ifc);
! 1274: connected_free (ifc);
! 1275: return CMD_WARNING;
! 1276: }
! 1277:
! 1278: /* This is real route. */
! 1279: ret = if_unset_prefix (ifp, ifc);
! 1280: if (ret < 0)
! 1281: {
! 1282: vty_out (vty, "%% Can't unset interface IP address: %s.%s",
! 1283: safe_strerror(errno), VTY_NEWLINE);
! 1284: return CMD_WARNING;
! 1285: }
! 1286:
! 1287: #if 0
! 1288: /* Redistribute this information. */
! 1289: zebra_interface_address_delete_update (ifp, ifc);
! 1290:
! 1291: /* Remove connected route. */
! 1292: connected_down_ipv4 (ifp, ifc);
! 1293:
! 1294: /* Free address information. */
! 1295: listnode_delete (ifp->connected, ifc);
! 1296: connected_free (ifc);
! 1297: #endif
! 1298:
! 1299: return CMD_SUCCESS;
! 1300: }
! 1301:
! 1302: DEFUN (ip_address,
! 1303: ip_address_cmd,
! 1304: "ip address A.B.C.D/M",
! 1305: "Interface Internet Protocol config commands\n"
! 1306: "Set the IP address of an interface\n"
! 1307: "IP address (e.g. 10.0.0.1/8)\n")
! 1308: {
! 1309: return ip_address_install (vty, vty->index, argv[0], NULL, NULL);
! 1310: }
! 1311:
! 1312: DEFUN (no_ip_address,
! 1313: no_ip_address_cmd,
! 1314: "no ip address A.B.C.D/M",
! 1315: NO_STR
! 1316: "Interface Internet Protocol config commands\n"
! 1317: "Set the IP address of an interface\n"
! 1318: "IP Address (e.g. 10.0.0.1/8)")
! 1319: {
! 1320: return ip_address_uninstall (vty, vty->index, argv[0], NULL, NULL);
! 1321: }
! 1322:
! 1323: #ifdef HAVE_NETLINK
! 1324: DEFUN (ip_address_label,
! 1325: ip_address_label_cmd,
! 1326: "ip address A.B.C.D/M label LINE",
! 1327: "Interface Internet Protocol config commands\n"
! 1328: "Set the IP address of an interface\n"
! 1329: "IP address (e.g. 10.0.0.1/8)\n"
! 1330: "Label of this address\n"
! 1331: "Label\n")
! 1332: {
! 1333: return ip_address_install (vty, vty->index, argv[0], NULL, argv[1]);
! 1334: }
! 1335:
! 1336: DEFUN (no_ip_address_label,
! 1337: no_ip_address_label_cmd,
! 1338: "no ip address A.B.C.D/M label LINE",
! 1339: NO_STR
! 1340: "Interface Internet Protocol config commands\n"
! 1341: "Set the IP address of an interface\n"
! 1342: "IP address (e.g. 10.0.0.1/8)\n"
! 1343: "Label of this address\n"
! 1344: "Label\n")
! 1345: {
! 1346: return ip_address_uninstall (vty, vty->index, argv[0], NULL, argv[1]);
! 1347: }
! 1348: #endif /* HAVE_NETLINK */
! 1349:
! 1350: #ifdef HAVE_IPV6
! 1351: static int
! 1352: ipv6_address_install (struct vty *vty, struct interface *ifp,
! 1353: const char *addr_str, const char *peer_str,
! 1354: const char *label, int secondary)
! 1355: {
! 1356: struct prefix_ipv6 cp;
! 1357: struct connected *ifc;
! 1358: struct prefix_ipv6 *p;
! 1359: int ret;
! 1360:
! 1361: ret = str2prefix_ipv6 (addr_str, &cp);
! 1362: if (ret <= 0)
! 1363: {
! 1364: vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
! 1365: return CMD_WARNING;
! 1366: }
! 1367:
! 1368: ifc = connected_check (ifp, (struct prefix *) &cp);
! 1369: if (! ifc)
! 1370: {
! 1371: ifc = connected_new ();
! 1372: ifc->ifp = ifp;
! 1373:
! 1374: /* Address. */
! 1375: p = prefix_ipv6_new ();
! 1376: *p = cp;
! 1377: ifc->address = (struct prefix *) p;
! 1378:
! 1379: /* Secondary. */
! 1380: if (secondary)
! 1381: SET_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY);
! 1382:
! 1383: /* Label. */
! 1384: if (label)
! 1385: ifc->label = XSTRDUP (MTYPE_CONNECTED_LABEL, label);
! 1386:
! 1387: /* Add to linked list. */
! 1388: listnode_add (ifp->connected, ifc);
! 1389: }
! 1390:
! 1391: /* This address is configured from zebra. */
! 1392: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 1393: SET_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED);
! 1394:
! 1395: /* In case of this route need to install kernel. */
! 1396: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL)
! 1397: && CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 1398: {
! 1399: /* Some system need to up the interface to set IP address. */
! 1400: if (! if_is_up (ifp))
! 1401: {
! 1402: if_set_flags (ifp, IFF_UP | IFF_RUNNING);
! 1403: if_refresh (ifp);
! 1404: }
! 1405:
! 1406: ret = if_prefix_add_ipv6 (ifp, ifc);
! 1407:
! 1408: if (ret < 0)
! 1409: {
! 1410: vty_out (vty, "%% Can't set interface IP address: %s.%s",
! 1411: safe_strerror(errno), VTY_NEWLINE);
! 1412: return CMD_WARNING;
! 1413: }
! 1414:
! 1415: /* IP address propery set. */
! 1416: SET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
! 1417:
! 1418: /* Update interface address information to protocol daemon. */
! 1419: zebra_interface_address_add_update (ifp, ifc);
! 1420:
! 1421: /* If interface is up register connected route. */
! 1422: if (if_is_operative(ifp))
! 1423: connected_up_ipv6 (ifp, ifc);
! 1424: }
! 1425:
! 1426: return CMD_SUCCESS;
! 1427: }
! 1428:
! 1429: static int
! 1430: ipv6_address_uninstall (struct vty *vty, struct interface *ifp,
! 1431: const char *addr_str, const char *peer_str,
! 1432: const char *label, int secondry)
! 1433: {
! 1434: struct prefix_ipv6 cp;
! 1435: struct connected *ifc;
! 1436: int ret;
! 1437:
! 1438: /* Convert to prefix structure. */
! 1439: ret = str2prefix_ipv6 (addr_str, &cp);
! 1440: if (ret <= 0)
! 1441: {
! 1442: vty_out (vty, "%% Malformed address %s", VTY_NEWLINE);
! 1443: return CMD_WARNING;
! 1444: }
! 1445:
! 1446: /* Check current interface address. */
! 1447: ifc = connected_check (ifp, (struct prefix *) &cp);
! 1448: if (! ifc)
! 1449: {
! 1450: vty_out (vty, "%% Can't find address%s", VTY_NEWLINE);
! 1451: return CMD_WARNING;
! 1452: }
! 1453:
! 1454: /* This is not configured address. */
! 1455: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 1456: return CMD_WARNING;
! 1457:
! 1458: /* This is not real address or interface is not active. */
! 1459: if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL)
! 1460: || ! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
! 1461: {
! 1462: listnode_delete (ifp->connected, ifc);
! 1463: connected_free (ifc);
! 1464: return CMD_WARNING;
! 1465: }
! 1466:
! 1467: /* This is real route. */
! 1468: ret = if_prefix_delete_ipv6 (ifp, ifc);
! 1469: if (ret < 0)
! 1470: {
! 1471: vty_out (vty, "%% Can't unset interface IP address: %s.%s",
! 1472: safe_strerror(errno), VTY_NEWLINE);
! 1473: return CMD_WARNING;
! 1474: }
! 1475:
! 1476: /* Redistribute this information. */
! 1477: zebra_interface_address_delete_update (ifp, ifc);
! 1478:
! 1479: /* Remove connected route. */
! 1480: connected_down_ipv6 (ifp, ifc);
! 1481:
! 1482: /* Free address information. */
! 1483: listnode_delete (ifp->connected, ifc);
! 1484: connected_free (ifc);
! 1485:
! 1486: return CMD_SUCCESS;
! 1487: }
! 1488:
! 1489: DEFUN (ipv6_address,
! 1490: ipv6_address_cmd,
! 1491: "ipv6 address X:X::X:X/M",
! 1492: "Interface IPv6 config commands\n"
! 1493: "Set the IP address of an interface\n"
! 1494: "IPv6 address (e.g. 3ffe:506::1/48)\n")
! 1495: {
! 1496: return ipv6_address_install (vty, vty->index, argv[0], NULL, NULL, 0);
! 1497: }
! 1498:
! 1499: DEFUN (no_ipv6_address,
! 1500: no_ipv6_address_cmd,
! 1501: "no ipv6 address X:X::X:X/M",
! 1502: NO_STR
! 1503: "Interface IPv6 config commands\n"
! 1504: "Set the IP address of an interface\n"
! 1505: "IPv6 address (e.g. 3ffe:506::1/48)\n")
! 1506: {
! 1507: return ipv6_address_uninstall (vty, vty->index, argv[0], NULL, NULL, 0);
! 1508: }
! 1509: #endif /* HAVE_IPV6 */
! 1510:
! 1511: static int
! 1512: if_config_write (struct vty *vty)
! 1513: {
! 1514: struct listnode *node;
! 1515: struct interface *ifp;
! 1516:
! 1517: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 1518: {
! 1519: struct zebra_if *if_data;
! 1520: struct listnode *addrnode;
! 1521: struct connected *ifc;
! 1522: struct prefix *p;
! 1523:
! 1524: if_data = ifp->info;
! 1525:
! 1526: vty_out (vty, "interface %s%s", ifp->name,
! 1527: VTY_NEWLINE);
! 1528:
! 1529: if (ifp->desc)
! 1530: vty_out (vty, " description %s%s", ifp->desc,
! 1531: VTY_NEWLINE);
! 1532:
! 1533: /* Assign bandwidth here to avoid unnecessary interface flap
! 1534: while processing config script */
! 1535: if (ifp->bandwidth != 0)
! 1536: vty_out(vty, " bandwidth %u%s", ifp->bandwidth, VTY_NEWLINE);
! 1537:
! 1538: if (CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION))
! 1539: vty_out(vty, " link-detect%s", VTY_NEWLINE);
! 1540:
! 1541: for (ALL_LIST_ELEMENTS_RO (ifp->connected, addrnode, ifc))
! 1542: {
! 1543: if (CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
! 1544: {
! 1545: char buf[INET6_ADDRSTRLEN];
! 1546: p = ifc->address;
! 1547: vty_out (vty, " ip%s address %s/%d",
! 1548: p->family == AF_INET ? "" : "v6",
! 1549: inet_ntop (p->family, &p->u.prefix, buf, sizeof(buf)),
! 1550: p->prefixlen);
! 1551:
! 1552: if (ifc->label)
! 1553: vty_out (vty, " label %s", ifc->label);
! 1554:
! 1555: vty_out (vty, "%s", VTY_NEWLINE);
! 1556: }
! 1557: }
! 1558:
! 1559: if (if_data)
! 1560: {
! 1561: if (if_data->shutdown == IF_ZEBRA_SHUTDOWN_ON)
! 1562: vty_out (vty, " shutdown%s", VTY_NEWLINE);
! 1563:
! 1564: if (if_data->multicast != IF_ZEBRA_MULTICAST_UNSPEC)
! 1565: vty_out (vty, " %smulticast%s",
! 1566: if_data->multicast == IF_ZEBRA_MULTICAST_ON ? "" : "no ",
! 1567: VTY_NEWLINE);
! 1568: }
! 1569:
! 1570: #ifdef RTADV
! 1571: rtadv_config_write (vty, ifp);
! 1572: #endif /* RTADV */
! 1573:
! 1574: #ifdef HAVE_IRDP
! 1575: irdp_config_write (vty, ifp);
! 1576: #endif /* IRDP */
! 1577:
! 1578: vty_out (vty, "!%s", VTY_NEWLINE);
! 1579: }
! 1580: return 0;
! 1581: }
! 1582:
! 1583: /* Allocate and initialize interface vector. */
! 1584: void
! 1585: zebra_if_init (void)
! 1586: {
! 1587: /* Initialize interface and new hook. */
! 1588: if_init ();
! 1589: if_add_hook (IF_NEW_HOOK, if_zebra_new_hook);
! 1590: if_add_hook (IF_DELETE_HOOK, if_zebra_delete_hook);
! 1591:
! 1592: /* Install configuration write function. */
! 1593: install_node (&interface_node, if_config_write);
! 1594:
! 1595: install_element (VIEW_NODE, &show_interface_cmd);
! 1596: install_element (ENABLE_NODE, &show_interface_cmd);
! 1597: install_element (ENABLE_NODE, &show_interface_desc_cmd);
! 1598: install_element (CONFIG_NODE, &zebra_interface_cmd);
! 1599: install_element (CONFIG_NODE, &no_interface_cmd);
! 1600: install_default (INTERFACE_NODE);
! 1601: install_element (INTERFACE_NODE, &interface_desc_cmd);
! 1602: install_element (INTERFACE_NODE, &no_interface_desc_cmd);
! 1603: install_element (INTERFACE_NODE, &multicast_cmd);
! 1604: install_element (INTERFACE_NODE, &no_multicast_cmd);
! 1605: install_element (INTERFACE_NODE, &linkdetect_cmd);
! 1606: install_element (INTERFACE_NODE, &no_linkdetect_cmd);
! 1607: install_element (INTERFACE_NODE, &shutdown_if_cmd);
! 1608: install_element (INTERFACE_NODE, &no_shutdown_if_cmd);
! 1609: install_element (INTERFACE_NODE, &bandwidth_if_cmd);
! 1610: install_element (INTERFACE_NODE, &no_bandwidth_if_cmd);
! 1611: install_element (INTERFACE_NODE, &no_bandwidth_if_val_cmd);
! 1612: install_element (INTERFACE_NODE, &ip_address_cmd);
! 1613: install_element (INTERFACE_NODE, &no_ip_address_cmd);
! 1614: #ifdef HAVE_IPV6
! 1615: install_element (INTERFACE_NODE, &ipv6_address_cmd);
! 1616: install_element (INTERFACE_NODE, &no_ipv6_address_cmd);
! 1617: #endif /* HAVE_IPV6 */
! 1618: #ifdef HAVE_NETLINK
! 1619: install_element (INTERFACE_NODE, &ip_address_label_cmd);
! 1620: install_element (INTERFACE_NODE, &no_ip_address_label_cmd);
! 1621: #endif /* HAVE_NETLINK */
! 1622: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to interface.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra