isisd/isis_circuit.c

   1 /*
   2  * IS-IS Rout(e)ing protocol - isis_circuit.h
   3  *
   4  * Copyright (C) 2001,2002   Sampo Saaristo
   5  *                           Tampere University of Technology
   6  *                           Institute of Communications Engineering
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public Licenseas published by the Free
  10  * Software Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include <zebra.h>
  23 #ifdef GNU_LINUX
  24 #include <net/ethernet.h>
  25 #else
  26 #include <netinet/if_ether.h>
  27 #endif
  28
  29 #include "log.h"
  30 #include "memory.h"
  31 #include "vrf.h"
  32 #include "if.h"
  33 #include "linklist.h"
  34 #include "command.h"
  35 #include "thread.h"
  36 #include "vty.h"
  37 #include "hash.h"
  38 #include "prefix.h"
  39 #include "stream.h"
  40 #include "qobj.h"
  41
  42 #include "isisd/dict.h"
  43 #include "isisd/isis_constants.h"
  44 #include "isisd/isis_common.h"
  45 #include "isisd/isis_flags.h"
  46 #include "isisd/isis_circuit.h"
  47 #include "isisd/isis_lsp.h"
  48 #include "isisd/isis_pdu.h"
  49 #include "isisd/isis_network.h"
  50 #include "isisd/isis_misc.h"
  51 #include "isisd/isis_constants.h"
  52 #include "isisd/isis_adjacency.h"
  53 #include "isisd/isis_dr.h"
  54 #include "isisd/isisd.h"
  55 #include "isisd/isis_csm.h"
  56 #include "isisd/isis_events.h"
  57 #include "isisd/isis_te.h"
  58 #include "isisd/isis_mt.h"
  59 #include "isisd/isis_errors.h"
  60 #include "isisd/isis_tx_queue.h"
  61
  62 DEFINE_QOBJ_TYPE(isis_circuit)
  63
  64 /*
  65  * Prototypes.
  66  */
  67 int isis_interface_config_write(struct vty *);
  68 int isis_if_new_hook(struct interface *);
  69 int isis_if_delete_hook(struct interface *);
  70
  71 struct isis_circuit *isis_circuit_new()
  72 {
  73         struct isis_circuit *circuit;
  74         int i;
  75
  76         circuit = XCALLOC(MTYPE_ISIS_CIRCUIT, sizeof(struct isis_circuit));
  77
  78         /*
  79          * Default values
  80          */
  81         circuit->is_type = IS_LEVEL_1_AND_2;
  82         circuit->flags = 0;
  83         circuit->pad_hellos = 1;
  84         for (i = 0; i < 2; i++) {
  85                 circuit->hello_interval[i] = DEFAULT_HELLO_INTERVAL;
  86                 circuit->hello_multiplier[i] = DEFAULT_HELLO_MULTIPLIER;
  87                 circuit->csnp_interval[i] = DEFAULT_CSNP_INTERVAL;
  88                 circuit->psnp_interval[i] = DEFAULT_PSNP_INTERVAL;
  89                 circuit->priority[i] = DEFAULT_PRIORITY;
  90                 circuit->metric[i] = DEFAULT_CIRCUIT_METRIC;
  91                 circuit->te_metric[i] = DEFAULT_CIRCUIT_METRIC;
  92                 circuit->level_arg[i].level = i + 1;
  93                 circuit->level_arg[i].circuit = circuit;
  94         }
  95
  96         circuit->mtc = mpls_te_circuit_new();
  97
  98         circuit_mt_init(circuit);
  99
 100         QOBJ_REG(circuit, isis_circuit);
 101
 102         return circuit;
 103 }
 104
 105 void isis_circuit_del(struct isis_circuit *circuit)
 106 {
 107         if (!circuit)
 108                 return;
 109
 110         QOBJ_UNREG(circuit);
 111
 112         isis_circuit_if_unbind(circuit, circuit->interface);
 113
 114         circuit_mt_finish(circuit);
 115
 116         /* and lastly the circuit itself */
 117         XFREE(MTYPE_ISIS_CIRCUIT, circuit);
 118
 119         return;
 120 }
 121
 122 void isis_circuit_configure(struct isis_circuit *circuit,
 123                             struct isis_area *area)
 124 {
 125         assert(area);
 126         circuit->area = area;
 127
 128         /*
 129          * Whenever the is-type of an area is changed, the is-type of each
 130          * circuit
 131          * in that area is updated to a non-empty subset of the area is-type.
 132          * Inversely, when configuring a new circuit, this property should be
 133          * ensured as well.
 134          */
 135         if (area->is_type != IS_LEVEL_1_AND_2)
 136                 circuit->is_type = area->is_type;
 137
 138         /*
 139          * Add the circuit into area
 140          */
 141         listnode_add(area->circuit_list, circuit);
 142
 143         circuit->idx = flags_get_index(&area->flags);
 144
 145         return;
 146 }
 147
 148 void isis_circuit_deconfigure(struct isis_circuit *circuit,
 149                               struct isis_area *area)
 150 {
 151         /* Free the index of SRM and SSN flags */
 152         flags_free_index(&area->flags, circuit->idx);
 153         circuit->idx = 0;
 154         /* Remove circuit from area */
 155         assert(circuit->area == area);
 156         listnode_delete(area->circuit_list, circuit);
 157         circuit->area = NULL;
 158
 159         return;
 160 }
 161
 162 struct isis_circuit *circuit_lookup_by_ifp(struct interface *ifp,
 163                                            struct list *list)
 164 {
 165         struct isis_circuit *circuit = NULL;
 166         struct listnode *node;
 167
 168         if (!list)
 169                 return NULL;
 170
 171         for (ALL_LIST_ELEMENTS_RO(list, node, circuit))
 172                 if (circuit->interface == ifp) {
 173                         assert(ifp->info == circuit);
 174                         return circuit;
 175                 }
 176
 177         return NULL;
 178 }
 179
 180 struct isis_circuit *circuit_scan_by_ifp(struct interface *ifp)
 181 {
 182         struct isis_area *area;
 183         struct listnode *node;
 184         struct isis_circuit *circuit;
 185
 186         if (ifp->info)
 187                 return (struct isis_circuit *)ifp->info;
 188
 189         if (isis->area_list) {
 190                 for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area)) {
 191                         circuit =
 192                                 circuit_lookup_by_ifp(ifp, area->circuit_list);
 193                         if (circuit)
 194                                 return circuit;
 195                 }
 196         }
 197         return circuit_lookup_by_ifp(ifp, isis->init_circ_list);
 198 }
 199
 200 void isis_circuit_add_addr(struct isis_circuit *circuit,
 201                            struct connected *connected)
 202 {
 203         struct listnode *node;
 204         struct prefix_ipv4 *ipv4;
 205 #if defined(EXTREME_DEBUG)
 206         char buf[PREFIX2STR_BUFFER];
 207 #endif
 208         struct prefix_ipv6 *ipv6;
 209
 210         if (connected->address->family == AF_INET) {
 211                 uint32_t addr = connected->address->u.prefix4.s_addr;
 212                 addr = ntohl(addr);
 213                 if (IPV4_NET0(addr) || IPV4_NET127(addr) || IN_CLASSD(addr)
 214                     || IPV4_LINKLOCAL(addr))
 215                         return;
 216
 217                 for (ALL_LIST_ELEMENTS_RO(circuit->ip_addrs, node, ipv4))
 218                         if (prefix_same((struct prefix *)ipv4,
 219                                         connected->address))
 220                                 return;
 221
 222                 ipv4 = prefix_ipv4_new();
 223                 ipv4->prefixlen = connected->address->prefixlen;
 224                 ipv4->prefix = connected->address->u.prefix4;
 225                 listnode_add(circuit->ip_addrs, ipv4);
 226
 227                 /* Update MPLS TE Local IP address parameter */
 228                 set_circuitparams_local_ipaddr(circuit->mtc, ipv4->prefix);
 229
 230                 if (circuit->area)
 231                         lsp_regenerate_schedule(circuit->area, circuit->is_type,
 232                                                 0);
 233
 234 #ifdef EXTREME_DEBUG
 235                 prefix2str(connected->address, buf, sizeof(buf));
 236                 zlog_debug("Added IP address %s to circuit %s", buf,
 237                            circuit->interface->name);
 238 #endif /* EXTREME_DEBUG */
 239         }
 240         if (connected->address->family == AF_INET6) {
 241                 if (IN6_IS_ADDR_LOOPBACK(&connected->address->u.prefix6))
 242                         return;
 243
 244                 for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_link, node, ipv6))
 245                         if (prefix_same((struct prefix *)ipv6,
 246                                         connected->address))
 247                                 return;
 248                 for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_non_link, node, ipv6))
 249                         if (prefix_same((struct prefix *)ipv6,
 250                                         connected->address))
 251                                 return;
 252
 253                 ipv6 = prefix_ipv6_new();
 254                 ipv6->prefixlen = connected->address->prefixlen;
 255                 ipv6->prefix = connected->address->u.prefix6;
 256
 257                 if (IN6_IS_ADDR_LINKLOCAL(&ipv6->prefix))
 258                         listnode_add(circuit->ipv6_link, ipv6);
 259                 else
 260                         listnode_add(circuit->ipv6_non_link, ipv6);
 261                 if (circuit->area)
 262                         lsp_regenerate_schedule(circuit->area, circuit->is_type,
 263                                                 0);
 264
 265 #ifdef EXTREME_DEBUG
 266                 prefix2str(connected->address, buf, sizeof(buf));
 267                 zlog_debug("Added IPv6 address %s to circuit %s", buf,
 268                            circuit->interface->name);
 269 #endif /* EXTREME_DEBUG */
 270         }
 271         return;
 272 }
 273
 274 void isis_circuit_del_addr(struct isis_circuit *circuit,
 275                            struct connected *connected)
 276 {
 277         struct prefix_ipv4 *ipv4, *ip = NULL;
 278         struct listnode *node;
 279         char buf[PREFIX2STR_BUFFER];
 280         struct prefix_ipv6 *ipv6, *ip6 = NULL;
 281         int found = 0;
 282
 283         if (connected->address->family == AF_INET) {
 284                 ipv4 = prefix_ipv4_new();
 285                 ipv4->prefixlen = connected->address->prefixlen;
 286                 ipv4->prefix = connected->address->u.prefix4;
 287
 288                 for (ALL_LIST_ELEMENTS_RO(circuit->ip_addrs, node, ip))
 289                         if (prefix_same((struct prefix *)ip,
 290                                         (struct prefix *)ipv4))
 291                                 break;
 292
 293                 if (ip) {
 294                         listnode_delete(circuit->ip_addrs, ip);
 295                         prefix_ipv4_free(ip);
 296                         if (circuit->area)
 297                                 lsp_regenerate_schedule(circuit->area,
 298                                                         circuit->is_type, 0);
 299                 } else {
 300                         prefix2str(connected->address, buf, sizeof(buf));
 301                         zlog_warn(
 302                                 "Nonexistent ip address %s removal attempt from \
 303                       circuit %s",
 304                                 buf, circuit->interface->name);
 305                         zlog_warn("Current ip addresses on %s:",
 306                                   circuit->interface->name);
 307                         for (ALL_LIST_ELEMENTS_RO(circuit->ip_addrs, node,
 308                                                   ip)) {
 309                                 prefix2str(ip, buf, sizeof(buf));
 310                                 zlog_warn("  %s", buf);
 311                         }
 312                         zlog_warn("End of addresses");
 313                 }
 314
 315                 prefix_ipv4_free(ipv4);
 316         }
 317         if (connected->address->family == AF_INET6) {
 318                 ipv6 = prefix_ipv6_new();
 319                 ipv6->prefixlen = connected->address->prefixlen;
 320                 ipv6->prefix = connected->address->u.prefix6;
 321
 322                 if (IN6_IS_ADDR_LINKLOCAL(&ipv6->prefix)) {
 323                         for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_link, node,
 324                                                   ip6)) {
 325                                 if (prefix_same((struct prefix *)ip6,
 326                                                 (struct prefix *)ipv6))
 327                                         break;
 328                         }
 329                         if (ip6) {
 330                                 listnode_delete(circuit->ipv6_link, ip6);
 331                                 prefix_ipv6_free(ip6);
 332                                 found = 1;
 333                         }
 334                 } else {
 335                         for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_non_link, node,
 336                                                   ip6)) {
 337                                 if (prefix_same((struct prefix *)ip6,
 338                                                 (struct prefix *)ipv6))
 339                                         break;
 340                         }
 341                         if (ip6) {
 342                                 listnode_delete(circuit->ipv6_non_link, ip6);
 343                                 prefix_ipv6_free(ip6);
 344                                 found = 1;
 345                         }
 346                 }
 347
 348                 if (!found) {
 349                         prefix2str(connected->address, buf, sizeof(buf));
 350                         zlog_warn(
 351                                 "Nonexistent ip address %s removal attempt from \
 352                       circuit %s",
 353                                 buf, circuit->interface->name);
 354                         zlog_warn("Current ip addresses on %s:",
 355                                   circuit->interface->name);
 356                         for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_link, node,
 357                                                   ip6)) {
 358                                 prefix2str((struct prefix *)ip6, (char *)buf,
 359                                            sizeof(buf));
 360                                 zlog_warn("  %s", buf);
 361                         }
 362                         zlog_warn(" -----");
 363                         for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_non_link, node,
 364                                                   ip6)) {
 365                                 prefix2str((struct prefix *)ip6, (char *)buf,
 366                                            sizeof(buf));
 367                                 zlog_warn("  %s", buf);
 368                         }
 369                         zlog_warn("End of addresses");
 370                 } else if (circuit->area)
 371                         lsp_regenerate_schedule(circuit->area, circuit->is_type,
 372                                                 0);
 373
 374                 prefix_ipv6_free(ipv6);
 375         }
 376         return;
 377 }
 378
 379 static uint8_t isis_circuit_id_gen(struct isis *isis, struct interface *ifp)
 380 {
 381         /* Circuit ids MUST be unique for any broadcast circuits. Otherwise,
 382          * Pseudo-Node LSPs cannot be generated correctly.
 383          *
 384          * Currently, allocate one circuit ID for any circuit, limiting the total
 385          * numer of circuits IS-IS can run on to 255.
 386          *
 387          * We should revisit this when implementing 3-way adjacencies for p2p, since
 388          * we then have extended interface IDs available.
 389          */
 390         uint8_t id = ifp->ifindex;
 391         unsigned int i;
 392
 393         for (i = 0; i < 256; i++) {
 394                 if (id && !_ISIS_CHECK_FLAG(isis->circuit_ids_used, id))
 395                         break;
 396                 id++;
 397         }
 398
 399         if (i == 256) {
 400                 zlog_warn("Could not allocate a circuit id for '%s'",
 401                           ifp->name);
 402                 return 0;
 403         }
 404
 405         _ISIS_SET_FLAG(isis->circuit_ids_used, id);
 406         return id;
 407 }
 408
 409 void isis_circuit_if_add(struct isis_circuit *circuit, struct interface *ifp)
 410 {
 411         struct listnode *node, *nnode;
 412         struct connected *conn;
 413
 414         isis_circuit_if_bind(circuit, ifp);
 415
 416         if (if_is_broadcast(ifp)) {
 417                 if (fabricd || circuit->circ_type_config == CIRCUIT_T_P2P)
 418                         circuit->circ_type = CIRCUIT_T_P2P;
 419                 else
 420                         circuit->circ_type = CIRCUIT_T_BROADCAST;
 421         } else if (if_is_pointopoint(ifp)) {
 422                 circuit->circ_type = CIRCUIT_T_P2P;
 423         } else if (if_is_loopback(ifp)) {
 424                 circuit->circ_type = CIRCUIT_T_LOOPBACK;
 425                 circuit->is_passive = 1;
 426         } else {
 427                 /* It's normal in case of loopback etc. */
 428                 if (isis->debugs & DEBUG_EVENTS)
 429                         zlog_debug("isis_circuit_if_add: unsupported media");
 430                 circuit->circ_type = CIRCUIT_T_UNKNOWN;
 431         }
 432
 433         circuit->ip_addrs = list_new();
 434         circuit->ipv6_link = list_new();
 435         circuit->ipv6_non_link = list_new();
 436
 437         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, conn))
 438                 isis_circuit_add_addr(circuit, conn);
 439 }
 440
 441 void isis_circuit_if_del(struct isis_circuit *circuit, struct interface *ifp)
 442 {
 443         struct listnode *node, *nnode;
 444         struct connected *conn;
 445
 446         assert(circuit->interface == ifp);
 447
 448         /* destroy addresses */
 449         for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, conn))
 450                 isis_circuit_del_addr(circuit, conn);
 451
 452         if (circuit->ip_addrs) {
 453                 assert(listcount(circuit->ip_addrs) == 0);
 454                 list_delete(&circuit->ip_addrs);
 455         }
 456
 457         if (circuit->ipv6_link) {
 458                 assert(listcount(circuit->ipv6_link) == 0);
 459                 list_delete(&circuit->ipv6_link);
 460         }
 461
 462         if (circuit->ipv6_non_link) {
 463                 assert(listcount(circuit->ipv6_non_link) == 0);
 464                 list_delete(&circuit->ipv6_non_link);
 465         }
 466
 467         circuit->circ_type = CIRCUIT_T_UNKNOWN;
 468 }
 469
 470 void isis_circuit_if_bind(struct isis_circuit *circuit, struct interface *ifp)
 471 {
 472         assert(circuit != NULL);
 473         assert(ifp != NULL);
 474         if (circuit->interface)
 475                 assert(circuit->interface == ifp);
 476         else
 477                 circuit->interface = ifp;
 478         if (ifp->info)
 479                 assert(ifp->info == circuit);
 480         else
 481                 ifp->info = circuit;
 482         isis_link_params_update(circuit, ifp);
 483 }
 484
 485 void isis_circuit_if_unbind(struct isis_circuit *circuit, struct interface *ifp)
 486 {
 487         assert(circuit != NULL);
 488         assert(ifp != NULL);
 489         assert(circuit->interface == ifp);
 490         assert(ifp->info == circuit);
 491         circuit->interface = NULL;
 492         ifp->info = NULL;
 493 }
 494
 495 static void isis_circuit_update_all_srmflags(struct isis_circuit *circuit,
 496                                              int is_set)
 497 {
 498         struct isis_area *area;
 499         struct isis_lsp *lsp;
 500         dnode_t *dnode;
 501         int level;
 502
 503         assert(circuit);
 504         area = circuit->area;
 505         assert(area);
 506         for (level = ISIS_LEVEL1; level <= ISIS_LEVEL2; level++) {
 507                 if (!(level & circuit->is_type))
 508                         continue;
 509
 510                 if (!area->lspdb[level - 1]
 511                     || !dict_count(area->lspdb[level - 1]))
 512                         continue;
 513
 514                 for (dnode = dict_first(area->lspdb[level - 1]);
 515                      dnode != NULL;
 516                      dnode = dict_next(area->lspdb[level - 1], dnode)) {
 517                         lsp = dnode_get(dnode);
 518                         if (is_set) {
 519                                 isis_tx_queue_add(circuit->tx_queue, lsp,
 520                                                   TX_LSP_NORMAL);
 521                         } else {
 522                                 isis_tx_queue_del(circuit->tx_queue, lsp);
 523                         }
 524                 }
 525         }
 526 }
 527
 528 size_t isis_circuit_pdu_size(struct isis_circuit *circuit)
 529 {
 530         return ISO_MTU(circuit);
 531 }
 532
 533 void isis_circuit_stream(struct isis_circuit *circuit, struct stream **stream)
 534 {
 535         size_t stream_size = isis_circuit_pdu_size(circuit);
 536
 537         if (!*stream) {
 538                 *stream = stream_new(stream_size);
 539         } else {
 540                 if (STREAM_SIZE(*stream) != stream_size)
 541                         stream_resize_inplace(stream, stream_size);
 542                 stream_reset(*stream);
 543         }
 544 }
 545
 546 void isis_circuit_prepare(struct isis_circuit *circuit)
 547 {
 548 #if ISIS_METHOD != ISIS_METHOD_DLPI
 549         thread_add_read(master, isis_receive, circuit, circuit->fd,
 550                         &circuit->t_read);
 551 #else
 552         thread_add_timer_msec(master, isis_receive, circuit,
 553                               listcount(circuit->area->circuit_list) * 100,
 554                               &circuit->t_read);
 555 #endif
 556 }
 557
 558 int isis_circuit_up(struct isis_circuit *circuit)
 559 {
 560         int retv;
 561
 562         /* Set the flags for all the lsps of the circuit. */
 563         isis_circuit_update_all_srmflags(circuit, 1);
 564
 565         if (circuit->state == C_STATE_UP)
 566                 return ISIS_OK;
 567
 568         if (circuit->is_passive)
 569                 return ISIS_OK;
 570
 571         if (circuit->area->lsp_mtu > isis_circuit_pdu_size(circuit)) {
 572                 flog_err(
 573                         EC_ISIS_CONFIG,
 574                         "Interface MTU %zu on %s is too low to support area lsp mtu %u!",
 575                         isis_circuit_pdu_size(circuit),
 576                         circuit->interface->name, circuit->area->lsp_mtu);
 577                 isis_circuit_update_all_srmflags(circuit, 0);
 578                 return ISIS_ERROR;
 579         }
 580
 581         if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
 582                 circuit->circuit_id = isis_circuit_id_gen(isis, circuit->interface);
 583                 if (!circuit->circuit_id) {
 584                         flog_err(
 585                                 EC_ISIS_CONFIG,
 586                                 "There are already 255 broadcast circuits active!");
 587                         return ISIS_ERROR;
 588                 }
 589
 590                 /*
 591                  * Get the Hardware Address
 592                  */
 593                 if (circuit->interface->hw_addr_len != ETH_ALEN) {
 594                         zlog_warn("unsupported link layer");
 595                 } else {
 596                         memcpy(circuit->u.bc.snpa, circuit->interface->hw_addr,
 597                                ETH_ALEN);
 598                 }
 599 #ifdef EXTREME_DEGUG
 600                 zlog_debug("isis_circuit_if_add: if_id %d, isomtu %d snpa %s",
 601                            circuit->interface->ifindex, ISO_MTU(circuit),
 602                            snpa_print(circuit->u.bc.snpa));
 603 #endif /* EXTREME_DEBUG */
 604
 605                 circuit->u.bc.adjdb[0] = list_new();
 606                 circuit->u.bc.adjdb[1] = list_new();
 607
 608                 /*
 609                  * ISO 10589 - 8.4.1 Enabling of broadcast circuits
 610                  */
 611
 612                 /* initilizing the hello sending threads
 613                  * for a broadcast IF
 614                  */
 615
 616                 /* 8.4.1 a) commence sending of IIH PDUs */
 617
 618                 for (int level = ISIS_LEVEL1; level <= ISIS_LEVEL2; level++) {
 619                         if (!(circuit->is_type & level))
 620                                 continue;
 621
 622                         send_hello_sched(circuit, level, TRIGGERED_IIH_DELAY);
 623                         circuit->u.bc.lan_neighs[level - 1] = list_new();
 624
 625                         thread_add_timer(master, isis_run_dr,
 626                                          &circuit->level_arg[level - 1],
 627                                          2 * circuit->hello_interval[level - 1],
 628                                          &circuit->u.bc.t_run_dr[level - 1]);
 629                 }
 630
 631                 /* 8.4.1 b) FIXME: solicit ES - 8.4.6 */
 632                 /* 8.4.1 c) FIXME: listen for ESH PDUs */
 633         } else if (circuit->circ_type == CIRCUIT_T_P2P) {
 634                 /* initializing the hello send threads
 635                  * for a ptp IF
 636                  */
 637                 circuit->u.p2p.neighbor = NULL;
 638                 send_hello_sched(circuit, 0, TRIGGERED_IIH_DELAY);
 639         }
 640
 641         /* initializing PSNP timers */
 642         if (circuit->is_type & IS_LEVEL_1)
 643                 thread_add_timer(
 644                         master, send_l1_psnp, circuit,
 645                         isis_jitter(circuit->psnp_interval[0], PSNP_JITTER),
 646                         &circuit->t_send_psnp[0]);
 647
 648         if (circuit->is_type & IS_LEVEL_2)
 649                 thread_add_timer(
 650                         master, send_l2_psnp, circuit,
 651                         isis_jitter(circuit->psnp_interval[1], PSNP_JITTER),
 652                         &circuit->t_send_psnp[1]);
 653
 654         /* unified init for circuits; ignore warnings below this level */
 655         retv = isis_sock_init(circuit);
 656         if (retv != ISIS_OK) {
 657                 isis_circuit_down(circuit);
 658                 return retv;
 659         }
 660
 661         /* initialize the circuit streams after opening connection */
 662         isis_circuit_stream(circuit, &circuit->rcv_stream);
 663         isis_circuit_stream(circuit, &circuit->snd_stream);
 664
 665         isis_circuit_prepare(circuit);
 666
 667         circuit->tx_queue = isis_tx_queue_new(circuit, send_lsp);
 668
 669         return ISIS_OK;
 670 }
 671
 672 void isis_circuit_down(struct isis_circuit *circuit)
 673 {
 674         /* Clear the flags for all the lsps of the circuit. */
 675         isis_circuit_update_all_srmflags(circuit, 0);
 676
 677         if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
 678                 /* destroy neighbour lists */
 679                 if (circuit->u.bc.lan_neighs[0]) {
 680                         list_delete(&circuit->u.bc.lan_neighs[0]);
 681                         circuit->u.bc.lan_neighs[0] = NULL;
 682                 }
 683                 if (circuit->u.bc.lan_neighs[1]) {
 684                         list_delete(&circuit->u.bc.lan_neighs[1]);
 685                         circuit->u.bc.lan_neighs[1] = NULL;
 686                 }
 687                 /* destroy adjacency databases */
 688                 if (circuit->u.bc.adjdb[0]) {
 689                         circuit->u.bc.adjdb[0]->del = isis_delete_adj;
 690                         list_delete(&circuit->u.bc.adjdb[0]);
 691                         circuit->u.bc.adjdb[0] = NULL;
 692                 }
 693                 if (circuit->u.bc.adjdb[1]) {
 694                         circuit->u.bc.adjdb[1]->del = isis_delete_adj;
 695                         list_delete(&circuit->u.bc.adjdb[1]);
 696                         circuit->u.bc.adjdb[1] = NULL;
 697                 }
 698                 if (circuit->u.bc.is_dr[0]) {
 699                         isis_dr_resign(circuit, 1);
 700                         circuit->u.bc.is_dr[0] = 0;
 701                 }
 702                 memset(circuit->u.bc.l1_desig_is, 0, ISIS_SYS_ID_LEN + 1);
 703                 if (circuit->u.bc.is_dr[1]) {
 704                         isis_dr_resign(circuit, 2);
 705                         circuit->u.bc.is_dr[1] = 0;
 706                 }
 707                 memset(circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
 708                 memset(circuit->u.bc.snpa, 0, ETH_ALEN);
 709
 710                 THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[0]);
 711                 THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[1]);
 712                 THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[0]);
 713                 THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[1]);
 714                 THREAD_TIMER_OFF(circuit->u.bc.t_refresh_pseudo_lsp[0]);
 715                 THREAD_TIMER_OFF(circuit->u.bc.t_refresh_pseudo_lsp[1]);
 716                 circuit->lsp_regenerate_pending[0] = 0;
 717                 circuit->lsp_regenerate_pending[1] = 0;
 718
 719                 _ISIS_CLEAR_FLAG(isis->circuit_ids_used, circuit->circuit_id);
 720                 circuit->circuit_id = 0;
 721         } else if (circuit->circ_type == CIRCUIT_T_P2P) {
 722                 isis_delete_adj(circuit->u.p2p.neighbor);
 723                 circuit->u.p2p.neighbor = NULL;
 724                 THREAD_TIMER_OFF(circuit->u.p2p.t_send_p2p_hello);
 725         }
 726
 727         /* Cancel all active threads */
 728         THREAD_TIMER_OFF(circuit->t_send_csnp[0]);
 729         THREAD_TIMER_OFF(circuit->t_send_csnp[1]);
 730         THREAD_TIMER_OFF(circuit->t_send_psnp[0]);
 731         THREAD_TIMER_OFF(circuit->t_send_psnp[1]);
 732         THREAD_OFF(circuit->t_read);
 733
 734         if (circuit->tx_queue) {
 735                 isis_tx_queue_free(circuit->tx_queue);
 736                 circuit->tx_queue = NULL;
 737         }
 738
 739         /* send one gratuitous hello to spead up convergence */
 740         if (circuit->state == C_STATE_UP) {
 741                 if (circuit->is_type & IS_LEVEL_1)
 742                         send_hello(circuit, IS_LEVEL_1);
 743                 if (circuit->is_type & IS_LEVEL_2)
 744                         send_hello(circuit, IS_LEVEL_2);
 745         }
 746
 747         circuit->upadjcount[0] = 0;
 748         circuit->upadjcount[1] = 0;
 749
 750         /* close the socket */
 751         if (circuit->fd) {
 752                 close(circuit->fd);
 753                 circuit->fd = 0;
 754         }
 755
 756         if (circuit->rcv_stream != NULL) {
 757                 stream_free(circuit->rcv_stream);
 758                 circuit->rcv_stream = NULL;
 759         }
 760
 761         if (circuit->snd_stream != NULL) {
 762                 stream_free(circuit->snd_stream);
 763                 circuit->snd_stream = NULL;
 764         }
 765
 766         thread_cancel_event(master, circuit);
 767
 768         return;
 769 }
 770
 771 void circuit_update_nlpids(struct isis_circuit *circuit)
 772 {
 773         circuit->nlpids.count = 0;
 774
 775         if (circuit->ip_router) {
 776                 circuit->nlpids.nlpids[0] = NLPID_IP;
 777                 circuit->nlpids.count++;
 778         }
 779         if (circuit->ipv6_router) {
 780                 circuit->nlpids.nlpids[circuit->nlpids.count] = NLPID_IPV6;
 781                 circuit->nlpids.count++;
 782         }
 783         return;
 784 }
 785
 786 void isis_circuit_print_vty(struct isis_circuit *circuit, struct vty *vty,
 787                             char detail)
 788 {
 789         if (detail == ISIS_UI_LEVEL_BRIEF) {
 790                 vty_out(vty, "  %-12s", circuit->interface->name);
 791                 vty_out(vty, "0x%-7x", circuit->circuit_id);
 792                 vty_out(vty, "%-9s", circuit_state2string(circuit->state));
 793                 vty_out(vty, "%-9s", circuit_type2string(circuit->circ_type));
 794                 vty_out(vty, "%-9s", circuit_t2string(circuit->is_type));
 795                 vty_out(vty, "\n");
 796         }
 797
 798         if (detail == ISIS_UI_LEVEL_DETAIL) {
 799                 struct listnode *node;
 800                 struct prefix *ip_addr;
 801                 char buf[BUFSIZ];
 802
 803                 vty_out(vty, "  Interface: %s", circuit->interface->name);
 804                 vty_out(vty, ", State: %s",
 805                         circuit_state2string(circuit->state));
 806                 if (circuit->is_passive)
 807                         vty_out(vty, ", Passive");
 808                 else
 809                         vty_out(vty, ", Active");
 810                 vty_out(vty, ", Circuit Id: 0x%x", circuit->circuit_id);
 811                 vty_out(vty, "\n");
 812                 vty_out(vty, "    Type: %s",
 813                         circuit_type2string(circuit->circ_type));
 814                 vty_out(vty, ", Level: %s", circuit_t2string(circuit->is_type));
 815                 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
 816                         vty_out(vty, ", SNPA: %-10s",
 817                                 snpa_print(circuit->u.bc.snpa));
 818                 vty_out(vty, "\n");
 819                 if (circuit->is_type & IS_LEVEL_1) {
 820                         vty_out(vty, "    Level-1 Information:\n");
 821                         if (circuit->area->newmetric)
 822                                 vty_out(vty, "      Metric: %d",
 823                                         circuit->te_metric[0]);
 824                         else
 825                                 vty_out(vty, "      Metric: %d",
 826                                         circuit->metric[0]);
 827                         if (!circuit->is_passive) {
 828                                 vty_out(vty, ", Active neighbors: %u\n",
 829                                         circuit->upadjcount[0]);
 830                                 vty_out(vty,
 831                                         "      Hello interval: %u, "
 832                                         "Holddown count: %u %s\n",
 833                                         circuit->hello_interval[0],
 834                                         circuit->hello_multiplier[0],
 835                                         (circuit->pad_hellos ? "(pad)"
 836                                                              : "(no-pad)"));
 837                                 vty_out(vty,
 838                                         "      CNSP interval: %u, "
 839                                         "PSNP interval: %u\n",
 840                                         circuit->csnp_interval[0],
 841                                         circuit->psnp_interval[0]);
 842                                 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
 843                                         vty_out(vty,
 844                                                 "      LAN Priority: %u, %s\n",
 845                                                 circuit->priority[0],
 846                                                 (circuit->u.bc.is_dr[0]
 847                                                          ? "is DIS"
 848                                                          : "is not DIS"));
 849                         } else {
 850                                 vty_out(vty, "\n");
 851                         }
 852                 }
 853                 if (circuit->is_type & IS_LEVEL_2) {
 854                         vty_out(vty, "    Level-2 Information:\n");
 855                         if (circuit->area->newmetric)
 856                                 vty_out(vty, "      Metric: %d",
 857                                         circuit->te_metric[1]);
 858                         else
 859                                 vty_out(vty, "      Metric: %d",
 860                                         circuit->metric[1]);
 861                         if (!circuit->is_passive) {
 862                                 vty_out(vty, ", Active neighbors: %u\n",
 863                                         circuit->upadjcount[1]);
 864                                 vty_out(vty,
 865                                         "      Hello interval: %u, "
 866                                         "Holddown count: %u %s\n",
 867                                         circuit->hello_interval[1],
 868                                         circuit->hello_multiplier[1],
 869                                         (circuit->pad_hellos ? "(pad)"
 870                                                              : "(no-pad)"));
 871                                 vty_out(vty,
 872                                         "      CNSP interval: %u, "
 873                                         "PSNP interval: %u\n",
 874                                         circuit->csnp_interval[1],
 875                                         circuit->psnp_interval[1]);
 876                                 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
 877                                         vty_out(vty,
 878                                                 "      LAN Priority: %u, %s\n",
 879                                                 circuit->priority[1],
 880                                                 (circuit->u.bc.is_dr[1]
 881                                                          ? "is DIS"
 882                                                          : "is not DIS"));
 883                         } else {
 884                                 vty_out(vty, "\n");
 885                         }
 886                 }
 887                 if (circuit->ip_addrs && listcount(circuit->ip_addrs) > 0) {
 888                         vty_out(vty, "    IP Prefix(es):\n");
 889                         for (ALL_LIST_ELEMENTS_RO(circuit->ip_addrs, node,
 890                                                   ip_addr)) {
 891                                 prefix2str(ip_addr, buf, sizeof(buf));
 892                                 vty_out(vty, "      %s\n", buf);
 893                         }
 894                 }
 895                 if (circuit->ipv6_link && listcount(circuit->ipv6_link) > 0) {
 896                         vty_out(vty, "    IPv6 Link-Locals:\n");
 897                         for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_link, node,
 898                                                   ip_addr)) {
 899                                 prefix2str(ip_addr, (char *)buf, BUFSIZ);
 900                                 vty_out(vty, "      %s\n", buf);
 901                         }
 902                 }
 903                 if (circuit->ipv6_non_link
 904                     && listcount(circuit->ipv6_non_link) > 0) {
 905                         vty_out(vty, "    IPv6 Prefixes:\n");
 906                         for (ALL_LIST_ELEMENTS_RO(circuit->ipv6_non_link, node,
 907                                                   ip_addr)) {
 908                                 prefix2str(ip_addr, (char *)buf, BUFSIZ);
 909                                 vty_out(vty, "      %s\n", buf);
 910                         }
 911                 }
 912
 913                 vty_out(vty, "\n");
 914         }
 915         return;
 916 }
 917
 918 DEFINE_HOOK(isis_circuit_config_write,
 919             (struct isis_circuit *circuit, struct vty *vty),
 920             (circuit, vty))
 921
 922 int isis_interface_config_write(struct vty *vty)
 923 {
 924         struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
 925         int write = 0;
 926         struct listnode *node;
 927         struct interface *ifp;
 928         struct isis_area *area;
 929         struct isis_circuit *circuit;
 930         int i;
 931
 932         FOR_ALL_INTERFACES (vrf, ifp) {
 933                 /* IF name */
 934                 vty_frame(vty, "interface %s\n", ifp->name);
 935                 write++;
 936                 /* IF desc */
 937                 if (ifp->desc) {
 938                         vty_out(vty, " description %s\n", ifp->desc);
 939                         write++;
 940                 }
 941                 /* ISIS Circuit */
 942                 for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area)) {
 943                         circuit =
 944                                 circuit_lookup_by_ifp(ifp, area->circuit_list);
 945                         if (circuit == NULL)
 946                                 continue;
 947                         if (circuit->ip_router) {
 948                                 vty_out(vty, " ip router " PROTO_NAME " %s\n",
 949                                         area->area_tag);
 950                                 write++;
 951                         }
 952                         if (circuit->is_passive) {
 953                                 vty_out(vty, " " PROTO_NAME " passive\n");
 954                                 write++;
 955                         }
 956                         if (circuit->circ_type_config == CIRCUIT_T_P2P) {
 957                                 vty_out(vty, " " PROTO_NAME " network point-to-point\n");
 958                                 write++;
 959                         }
 960                         if (circuit->ipv6_router) {
 961                                 vty_out(vty, " ipv6 router " PROTO_NAME " %s\n",
 962                                         area->area_tag);
 963                                 write++;
 964                         }
 965
 966                         /* ISIS - circuit type */
 967                         if (!fabricd) {
 968                                 if (circuit->is_type == IS_LEVEL_1) {
 969                                         vty_out(vty, " " PROTO_NAME " circuit-type level-1\n");
 970                                         write++;
 971                                 } else {
 972                                         if (circuit->is_type == IS_LEVEL_2) {
 973                                                 vty_out(vty,
 974                                                         " " PROTO_NAME " circuit-type level-2-only\n");
 975                                                 write++;
 976                                         }
 977                                 }
 978                         }
 979
 980                         /* ISIS - CSNP interval */
 981                         if (circuit->csnp_interval[0]
 982                             == circuit->csnp_interval[1]) {
 983                                 if (circuit->csnp_interval[0]
 984                                     != DEFAULT_CSNP_INTERVAL) {
 985                                         vty_out(vty, " " PROTO_NAME " csnp-interval %d\n",
 986                                                 circuit->csnp_interval[0]);
 987                                         write++;
 988                                 }
 989                         } else {
 990                                 for (i = 0; i < 2; i++) {
 991                                         if (circuit->csnp_interval[i]
 992                                             != DEFAULT_CSNP_INTERVAL) {
 993                                                 vty_out(vty,
 994                                                         " " PROTO_NAME " csnp-interval %d level-%d\n",
 995                                                         circuit->csnp_interval
 996                                                                 [i],
 997                                                         i + 1);
 998                                                 write++;
 999                                         }
1000                                 }
1001                         }
1002
1003                         /* ISIS - PSNP interval */
1004                         if (circuit->psnp_interval[0]
1005                             == circuit->psnp_interval[1]) {
1006                                 if (circuit->psnp_interval[0]
1007                                     != DEFAULT_PSNP_INTERVAL) {
1008                                         vty_out(vty, " " PROTO_NAME " psnp-interval %d\n",
1009                                                 circuit->psnp_interval[0]);
1010                                         write++;
1011                                 }
1012                         } else {
1013                                 for (i = 0; i < 2; i++) {
1014                                         if (circuit->psnp_interval[i]
1015                                             != DEFAULT_PSNP_INTERVAL) {
1016                                                 vty_out(vty,
1017                                                         " " PROTO_NAME " psnp-interval %d level-%d\n",
1018                                                         circuit->psnp_interval
1019                                                                 [i],
1020                                                         i + 1);
1021                                                 write++;
1022                                         }
1023                                 }
1024                         }
1025
1026                         /* ISIS - Hello padding - Defaults to true so only
1027                          * display if false */
1028                         if (circuit->pad_hellos == 0) {
1029                                 vty_out(vty, " no " PROTO_NAME " hello padding\n");
1030                                 write++;
1031                         }
1032
1033                         if (circuit->disable_threeway_adj) {
1034                                 vty_out(vty, " no isis three-way-handshake\n");
1035                                 write++;
1036                         }
1037
1038                         /* ISIS - Hello interval */
1039                         if (circuit->hello_interval[0]
1040                             == circuit->hello_interval[1]) {
1041                                 if (circuit->hello_interval[0]
1042                                     != DEFAULT_HELLO_INTERVAL) {
1043                                         vty_out(vty,
1044                                                 " " PROTO_NAME " hello-interval %d\n",
1045                                                 circuit->hello_interval[0]);
1046                                         write++;
1047                                 }
1048                         } else {
1049                                 for (i = 0; i < 2; i++) {
1050                                         if (circuit->hello_interval[i]
1051                                             != DEFAULT_HELLO_INTERVAL) {
1052                                                 vty_out(vty,
1053                                                         " " PROTO_NAME " hello-interval %d level-%d\n",
1054                                                         circuit->hello_interval
1055                                                                 [i],
1056                                                         i + 1);
1057                                                 write++;
1058                                         }
1059                                 }
1060                         }
1061
1062                         /* ISIS - Hello Multiplier */
1063                         if (circuit->hello_multiplier[0]
1064                             == circuit->hello_multiplier[1]) {
1065                                 if (circuit->hello_multiplier[0]
1066                                     != DEFAULT_HELLO_MULTIPLIER) {
1067                                         vty_out(vty,
1068                                                 " " PROTO_NAME " hello-multiplier %d\n",
1069                                                 circuit->hello_multiplier[0]);
1070                                         write++;
1071                                 }
1072                         } else {
1073                                 for (i = 0; i < 2; i++) {
1074                                         if (circuit->hello_multiplier[i]
1075                                             != DEFAULT_HELLO_MULTIPLIER) {
1076                                                 vty_out(vty,
1077                                                         " " PROTO_NAME " hello-multiplier %d level-%d\n",
1078                                                         circuit->hello_multiplier
1079                                                                 [i],
1080                                                         i + 1);
1081                                                 write++;
1082                                         }
1083                                 }
1084                         }
1085
1086                         /* ISIS - Priority */
1087                         if (circuit->priority[0] == circuit->priority[1]) {
1088                                 if (circuit->priority[0] != DEFAULT_PRIORITY) {
1089                                         vty_out(vty, " " PROTO_NAME " priority %d\n",
1090                                                 circuit->priority[0]);
1091                                         write++;
1092                                 }
1093                         } else {
1094                                 for (i = 0; i < 2; i++) {
1095                                         if (circuit->priority[i]
1096                                             != DEFAULT_PRIORITY) {
1097                                                 vty_out(vty,
1098                                                         " " PROTO_NAME " priority %d level-%d\n",
1099                                                         circuit->priority[i],
1100                                                         i + 1);
1101                                                 write++;
1102                                         }
1103                                 }
1104                         }
1105
1106                         /* ISIS - Metric */
1107                         if (circuit->te_metric[0] == circuit->te_metric[1]) {
1108                                 if (circuit->te_metric[0]
1109                                     != DEFAULT_CIRCUIT_METRIC) {
1110                                         vty_out(vty, " " PROTO_NAME " metric %d\n",
1111                                                 circuit->te_metric[0]);
1112                                         write++;
1113                                 }
1114                         } else {
1115                                 for (i = 0; i < 2; i++) {
1116                                         if (circuit->te_metric[i]
1117                                             != DEFAULT_CIRCUIT_METRIC) {
1118                                                 vty_out(vty,
1119                                                         " " PROTO_NAME " metric %d level-%d\n",
1120                                                         circuit->te_metric[i],
1121                                                         i + 1);
1122                                                 write++;
1123                                         }
1124                                 }
1125                         }
1126                         if (circuit->passwd.type == ISIS_PASSWD_TYPE_HMAC_MD5) {
1127                                 vty_out(vty, " " PROTO_NAME " password md5 %s\n",
1128                                         circuit->passwd.passwd);
1129                                 write++;
1130                         } else if (circuit->passwd.type
1131                                    == ISIS_PASSWD_TYPE_CLEARTXT) {
1132                                 vty_out(vty, " " PROTO_NAME " password clear %s\n",
1133                                         circuit->passwd.passwd);
1134                                 write++;
1135                         }
1136                         write += hook_call(isis_circuit_config_write,
1137                                            circuit, vty);
1138                 }
1139                 vty_endframe(vty, "!\n");
1140         }
1141
1142         return write;
1143 }
1144
1145 struct isis_circuit *isis_circuit_create(struct isis_area *area,
1146                                          struct interface *ifp)
1147 {
1148         struct isis_circuit *circuit = circuit_scan_by_ifp(ifp);
1149         if (circuit && circuit->area)
1150                 return NULL;
1151         circuit = isis_csm_state_change(ISIS_ENABLE, circuit, area);
1152         if (circuit->state != C_STATE_CONF && circuit->state != C_STATE_UP)
1153                 return circuit;
1154         isis_circuit_if_bind(circuit, ifp);
1155         return circuit;
1156 }
1157
1158 void isis_circuit_af_set(struct isis_circuit *circuit, bool ip_router,
1159                          bool ipv6_router)
1160 {
1161         struct isis_area *area = circuit->area;
1162         bool change = circuit->ip_router != ip_router
1163                       || circuit->ipv6_router != ipv6_router;
1164
1165         area->ip_circuits += ip_router - circuit->ip_router;
1166         area->ipv6_circuits += ipv6_router - circuit->ipv6_router;
1167         circuit->ip_router = ip_router;
1168         circuit->ipv6_router = ipv6_router;
1169
1170         if (!change)
1171                 return;
1172
1173         circuit_update_nlpids(circuit);
1174
1175         if (!ip_router && !ipv6_router)
1176                 isis_csm_state_change(ISIS_DISABLE, circuit, area);
1177         else
1178                 lsp_regenerate_schedule(circuit->area, circuit->is_type, 0);
1179 }
1180
1181 ferr_r isis_circuit_passive_set(struct isis_circuit *circuit, bool passive)
1182 {
1183         if (circuit->is_passive == passive)
1184                 return ferr_ok();
1185
1186         if (if_is_loopback(circuit->interface) && !passive)
1187                 return ferr_cfg_invalid("loopback is always passive");
1188
1189         if (circuit->state != C_STATE_UP) {
1190                 circuit->is_passive = passive;
1191         } else {
1192                 struct isis_area *area = circuit->area;
1193                 isis_csm_state_change(ISIS_DISABLE, circuit, area);
1194                 circuit->is_passive = passive;
1195                 isis_csm_state_change(ISIS_ENABLE, circuit, area);
1196         }
1197
1198         return ferr_ok();
1199 }
1200
1201 ferr_r isis_circuit_metric_set(struct isis_circuit *circuit, int level,
1202                                int metric)
1203 {
1204         assert(level == IS_LEVEL_1 || level == IS_LEVEL_2);
1205         if (metric > MAX_WIDE_LINK_METRIC)
1206                 return ferr_cfg_invalid("metric %d too large for wide metric",
1207                                         metric);
1208         if (circuit->area && circuit->area->oldmetric
1209             && metric > MAX_NARROW_LINK_METRIC)
1210                 return ferr_cfg_invalid("metric %d too large for narrow metric",
1211                                         metric);
1212
1213         circuit->te_metric[level - 1] = metric;
1214         circuit->metric[level - 1] = metric;
1215
1216         if (circuit->area)
1217                 lsp_regenerate_schedule(circuit->area, level, 0);
1218         return ferr_ok();
1219 }
1220
1221 ferr_r isis_circuit_passwd_unset(struct isis_circuit *circuit)
1222 {
1223         memset(&circuit->passwd, 0, sizeof(circuit->passwd));
1224         return ferr_ok();
1225 }
1226
1227 static int isis_circuit_passwd_set(struct isis_circuit *circuit,
1228                                    uint8_t passwd_type, const char *passwd)
1229 {
1230         int len;
1231
1232         if (!passwd)
1233                 return ferr_code_bug("no circuit password given");
1234
1235         len = strlen(passwd);
1236         if (len > 254)
1237                 return ferr_code_bug(
1238                         "circuit password too long (max 254 chars)");
1239
1240         circuit->passwd.len = len;
1241         strncpy((char *)circuit->passwd.passwd, passwd, 255);
1242         circuit->passwd.type = passwd_type;
1243         return ferr_ok();
1244 }
1245
1246 ferr_r isis_circuit_passwd_cleartext_set(struct isis_circuit *circuit,
1247                                          const char *passwd)
1248 {
1249         return isis_circuit_passwd_set(circuit, ISIS_PASSWD_TYPE_CLEARTXT,
1250                                        passwd);
1251 }
1252
1253 ferr_r isis_circuit_passwd_hmac_md5_set(struct isis_circuit *circuit,
1254                                         const char *passwd)
1255 {
1256         return isis_circuit_passwd_set(circuit, ISIS_PASSWD_TYPE_HMAC_MD5,
1257                                        passwd);
1258 }
1259
1260 struct cmd_node interface_node = {
1261         INTERFACE_NODE, "%s(config-if)# ", 1,
1262 };
1263
1264 void isis_circuit_circ_type_set(struct isis_circuit *circuit, int circ_type)
1265 {
1266         if (circuit->circ_type == circ_type)
1267                 return;
1268
1269         if (circuit->state != C_STATE_UP) {
1270                 circuit->circ_type = circ_type;
1271                 circuit->circ_type_config = circ_type;
1272         } else {
1273                 struct isis_area *area = circuit->area;
1274
1275                 isis_csm_state_change(ISIS_DISABLE, circuit, area);
1276                 circuit->circ_type = circ_type;
1277                 circuit->circ_type_config = circ_type;
1278                 isis_csm_state_change(ISIS_ENABLE, circuit, area);
1279         }
1280 }
1281
1282 int isis_circuit_mt_enabled_set(struct isis_circuit *circuit, uint16_t mtid,
1283                                 bool enabled)
1284 {
1285         struct isis_circuit_mt_setting *setting;
1286
1287         setting = circuit_get_mt_setting(circuit, mtid);
1288         if (setting->enabled != enabled) {
1289                 setting->enabled = enabled;
1290                 lsp_regenerate_schedule(circuit->area, IS_LEVEL_1 | IS_LEVEL_2,
1291                                         0);
1292         }
1293
1294         return CMD_SUCCESS;
1295 }
1296
1297 int isis_if_new_hook(struct interface *ifp)
1298 {
1299         return 0;
1300 }
1301
1302 int isis_if_delete_hook(struct interface *ifp)
1303 {
1304         struct isis_circuit *circuit;
1305         /* Clean up the circuit data */
1306         if (ifp && ifp->info) {
1307                 circuit = ifp->info;
1308                 isis_csm_state_change(IF_DOWN_FROM_Z, circuit, circuit->area);
1309                 isis_csm_state_change(ISIS_DISABLE, circuit, circuit->area);
1310         }
1311
1312         return 0;
1313 }
1314
1315 void isis_circuit_init()
1316 {
1317         /* Initialize Zebra interface data structure */
1318         hook_register_prio(if_add, 0, isis_if_new_hook);
1319         hook_register_prio(if_del, 0, isis_if_delete_hook);
1320
1321         /* Install interface node */
1322         install_node(&interface_node, isis_interface_config_write);
1323         if_cmd_init();
1324 }