isisd/isis_vty.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  * Copyright (C) 2016        David Lamparter, for NetDEF, Inc.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public Licenseas published by the Free
  11  * Software Foundation; either version 2 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17  * more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; see the file COPYING; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include <zebra.h>
  25
  26 #include "command.h"
  27 #include "spf_backoff.h"
  28
  29 #include "isis_circuit.h"
  30 #include "isis_csm.h"
  31 #include "isis_misc.h"
  32 #include "isis_mt.h"
  33 #include "isisd.h"
  34
  35 static struct isis_circuit *isis_circuit_lookup(struct vty *vty)
  36 {
  37         struct interface *ifp = VTY_GET_CONTEXT(interface);
  38         struct isis_circuit *circuit;
  39
  40         if (!ifp) {
  41                 vty_out(vty, "Invalid interface \n");
  42                 return NULL;
  43         }
  44
  45         circuit = circuit_scan_by_ifp(ifp);
  46         if (!circuit) {
  47                 vty_out(vty, "ISIS is not enabled on circuit %s\n", ifp->name);
  48                 return NULL;
  49         }
  50
  51         return circuit;
  52 }
  53
  54 DEFUN (ip_router_isis,
  55        ip_router_isis_cmd,
  56        "ip router isis WORD",
  57        "Interface Internet Protocol config commands\n"
  58        "IP router interface commands\n"
  59        "IS-IS Routing for IP\n"
  60        "Routing process tag\n")
  61 {
  62         int idx_afi = 0;
  63         int idx_word = 3;
  64         VTY_DECLVAR_CONTEXT(interface, ifp);
  65         struct isis_circuit *circuit;
  66         struct isis_area *area;
  67         const char *af = argv[idx_afi]->arg;
  68         const char *area_tag = argv[idx_word]->arg;
  69
  70         /* Prevent more than one area per circuit */
  71         circuit = circuit_scan_by_ifp(ifp);
  72         if (circuit && circuit->area) {
  73                 if (strcmp(circuit->area->area_tag, area_tag)) {
  74                         vty_out(vty, "ISIS circuit is already defined on %s\n",
  75                                 circuit->area->area_tag);
  76                         return CMD_ERR_NOTHING_TODO;
  77                 }
  78         }
  79
  80         area = isis_area_lookup(area_tag);
  81         if (!area)
  82                 area = isis_area_create(area_tag);
  83
  84         if (!circuit || !circuit->area) {
  85                 circuit = isis_circuit_create(area, ifp);
  86
  87                 if (circuit->state != C_STATE_CONF
  88                     && circuit->state != C_STATE_UP) {
  89                         vty_out(vty,
  90                                 "Couldn't bring up interface, please check log.\n");
  91                         return CMD_WARNING_CONFIG_FAILED;
  92                 }
  93         }
  94
  95         bool ip = circuit->ip_router, ipv6 = circuit->ipv6_router;
  96         if (af[2] != '\0')
  97                 ipv6 = true;
  98         else
  99                 ip = true;
 100
 101         isis_circuit_af_set(circuit, ip, ipv6);
 102         return CMD_SUCCESS;
 103 }
 104
 105 DEFUN (ip6_router_isis,
 106        ip6_router_isis_cmd,
 107        "ipv6 router isis WORD",
 108        "Interface Internet Protocol config commands\n"
 109        "IP router interface commands\n"
 110        "IS-IS Routing for IP\n"
 111        "Routing process tag\n")
 112 {
 113         return ip_router_isis(self, vty, argc, argv);
 114 }
 115
 116 DEFUN (no_ip_router_isis,
 117        no_ip_router_isis_cmd,
 118        "no <ip|ipv6> router isis WORD",
 119        NO_STR
 120        "Interface Internet Protocol config commands\n"
 121        "IP router interface commands\n"
 122        "IP router interface commands\n"
 123        "IS-IS Routing for IP\n"
 124        "Routing process tag\n")
 125 {
 126         int idx_afi = 1;
 127         int idx_word = 4;
 128         VTY_DECLVAR_CONTEXT(interface, ifp);
 129         struct isis_area *area;
 130         struct isis_circuit *circuit;
 131         const char *af = argv[idx_afi]->arg;
 132         const char *area_tag = argv[idx_word]->arg;
 133
 134         area = isis_area_lookup(area_tag);
 135         if (!area) {
 136                 vty_out(vty, "Can't find ISIS instance %s\n",
 137                         argv[idx_afi]->arg);
 138                 return CMD_ERR_NO_MATCH;
 139         }
 140
 141         circuit = circuit_lookup_by_ifp(ifp, area->circuit_list);
 142         if (!circuit) {
 143                 vty_out(vty, "ISIS is not enabled on circuit %s\n", ifp->name);
 144                 return CMD_ERR_NO_MATCH;
 145         }
 146
 147         bool ip = circuit->ip_router, ipv6 = circuit->ipv6_router;
 148         if (af[2] != '\0')
 149                 ipv6 = false;
 150         else
 151                 ip = false;
 152
 153         isis_circuit_af_set(circuit, ip, ipv6);
 154         return CMD_SUCCESS;
 155 }
 156
 157 DEFUN (isis_passive,
 158        isis_passive_cmd,
 159        "isis passive",
 160        "IS-IS commands\n"
 161        "Configure the passive mode for interface\n")
 162 {
 163         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 164         if (!circuit)
 165                 return CMD_ERR_NO_MATCH;
 166
 167         CMD_FERR_RETURN(isis_circuit_passive_set(circuit, 1),
 168                         "Cannot set passive: $ERR");
 169         return CMD_SUCCESS;
 170 }
 171
 172 DEFUN (no_isis_passive,
 173        no_isis_passive_cmd,
 174        "no isis passive",
 175        NO_STR
 176        "IS-IS commands\n"
 177        "Configure the passive mode for interface\n")
 178 {
 179         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 180         if (!circuit)
 181                 return CMD_ERR_NO_MATCH;
 182
 183         CMD_FERR_RETURN(isis_circuit_passive_set(circuit, 0),
 184                         "Cannot set no passive: $ERR");
 185         return CMD_SUCCESS;
 186 }
 187
 188 DEFUN (isis_circuit_type,
 189        isis_circuit_type_cmd,
 190        "isis circuit-type <level-1|level-1-2|level-2-only>",
 191        "IS-IS commands\n"
 192        "Configure circuit type for interface\n"
 193        "Level-1 only adjacencies are formed\n"
 194        "Level-1-2 adjacencies are formed\n"
 195        "Level-2 only adjacencies are formed\n")
 196 {
 197         int idx_level = 2;
 198         int is_type;
 199         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 200         if (!circuit)
 201                 return CMD_ERR_NO_MATCH;
 202
 203         is_type = string2circuit_t(argv[idx_level]->arg);
 204         if (!is_type) {
 205                 vty_out(vty, "Unknown circuit-type \n");
 206                 return CMD_WARNING_CONFIG_FAILED;
 207         }
 208
 209         if (circuit->state == C_STATE_UP
 210             && circuit->area->is_type != IS_LEVEL_1_AND_2
 211             && circuit->area->is_type != is_type) {
 212                 vty_out(vty, "Invalid circuit level for area %s.\n",
 213                         circuit->area->area_tag);
 214                 return CMD_WARNING_CONFIG_FAILED;
 215         }
 216         isis_circuit_is_type_set(circuit, is_type);
 217
 218         return CMD_SUCCESS;
 219 }
 220
 221 DEFUN (no_isis_circuit_type,
 222        no_isis_circuit_type_cmd,
 223        "no isis circuit-type <level-1|level-1-2|level-2-only>",
 224        NO_STR
 225        "IS-IS commands\n"
 226        "Configure circuit type for interface\n"
 227        "Level-1 only adjacencies are formed\n"
 228        "Level-1-2 adjacencies are formed\n"
 229        "Level-2 only adjacencies are formed\n")
 230 {
 231         int is_type;
 232         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 233         if (!circuit)
 234                 return CMD_ERR_NO_MATCH;
 235
 236         /*
 237          * Set the circuits level to its default value
 238          */
 239         if (circuit->state == C_STATE_UP)
 240                 is_type = circuit->area->is_type;
 241         else
 242                 is_type = IS_LEVEL_1_AND_2;
 243         isis_circuit_is_type_set(circuit, is_type);
 244
 245         return CMD_SUCCESS;
 246 }
 247
 248 DEFUN (isis_network,
 249        isis_network_cmd,
 250        "isis network point-to-point",
 251        "IS-IS commands\n"
 252        "Set network type\n"
 253        "point-to-point network type\n")
 254 {
 255         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 256         if (!circuit)
 257                 return CMD_ERR_NO_MATCH;
 258
 259         if (isis_circuit_circ_type_set(circuit, CIRCUIT_T_P2P)) {
 260                 vty_out(vty,
 261                         "isis network point-to-point is valid only on broadcast interfaces\n");
 262                 return CMD_WARNING_CONFIG_FAILED;
 263         }
 264
 265         return CMD_SUCCESS;
 266 }
 267
 268 DEFUN (no_isis_network,
 269        no_isis_network_cmd,
 270        "no isis network point-to-point",
 271        NO_STR
 272        "IS-IS commands\n"
 273        "Set network type for circuit\n"
 274        "point-to-point network type\n")
 275 {
 276         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 277         if (!circuit)
 278                 return CMD_ERR_NO_MATCH;
 279
 280         if (isis_circuit_circ_type_set(circuit, CIRCUIT_T_BROADCAST)) {
 281                 vty_out(vty,
 282                         "isis network point-to-point is valid only on broadcast interfaces\n");
 283                 return CMD_WARNING_CONFIG_FAILED;
 284         }
 285
 286         return CMD_SUCCESS;
 287 }
 288
 289 DEFUN (isis_passwd,
 290        isis_passwd_cmd,
 291        "isis password <md5|clear> WORD",
 292        "IS-IS commands\n"
 293        "Configure the authentication password for a circuit\n"
 294        "HMAC-MD5 authentication\n"
 295        "Cleartext password\n"
 296        "Circuit password\n")
 297 {
 298         int idx_encryption = 2;
 299         int idx_word = 3;
 300         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 301         ferr_r rv;
 302
 303         if (!circuit)
 304                 return CMD_ERR_NO_MATCH;
 305
 306         if (argv[idx_encryption]->arg[0] == 'm')
 307                 rv = isis_circuit_passwd_hmac_md5_set(circuit,
 308                                                       argv[idx_word]->arg);
 309         else
 310                 rv = isis_circuit_passwd_cleartext_set(circuit,
 311                                                        argv[idx_word]->arg);
 312
 313         CMD_FERR_RETURN(rv, "Failed to set circuit password: $ERR");
 314         return CMD_SUCCESS;
 315 }
 316
 317 DEFUN (no_isis_passwd,
 318        no_isis_passwd_cmd,
 319        "no isis password [<md5|clear> WORD]",
 320        NO_STR
 321        "IS-IS commands\n"
 322        "Configure the authentication password for a circuit\n"
 323        "HMAC-MD5 authentication\n"
 324        "Cleartext password\n"
 325        "Circuit password\n")
 326 {
 327         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 328         if (!circuit)
 329                 return CMD_ERR_NO_MATCH;
 330
 331         CMD_FERR_RETURN(isis_circuit_passwd_unset(circuit),
 332                         "Failed to unset circuit password: $ERR");
 333         return CMD_SUCCESS;
 334 }
 335
 336
 337 DEFUN (isis_priority,
 338        isis_priority_cmd,
 339        "isis priority (0-127)",
 340        "IS-IS commands\n"
 341        "Set priority for Designated Router election\n"
 342        "Priority value\n")
 343 {
 344         int idx_number = 2;
 345         int prio;
 346         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 347         if (!circuit)
 348                 return CMD_ERR_NO_MATCH;
 349
 350         prio = atoi(argv[idx_number]->arg);
 351         if (prio < MIN_PRIORITY || prio > MAX_PRIORITY) {
 352                 vty_out(vty, "Invalid priority %d - should be <0-127>\n", prio);
 353                 return CMD_WARNING_CONFIG_FAILED;
 354         }
 355
 356         circuit->priority[0] = prio;
 357         circuit->priority[1] = prio;
 358
 359         return CMD_SUCCESS;
 360 }
 361
 362 DEFUN (no_isis_priority,
 363        no_isis_priority_cmd,
 364        "no isis priority [(0-127)]",
 365        NO_STR
 366        "IS-IS commands\n"
 367        "Set priority for Designated Router election\n"
 368        "Priority value\n")
 369 {
 370         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 371         if (!circuit)
 372                 return CMD_ERR_NO_MATCH;
 373
 374         circuit->priority[0] = DEFAULT_PRIORITY;
 375         circuit->priority[1] = DEFAULT_PRIORITY;
 376
 377         return CMD_SUCCESS;
 378 }
 379
 380
 381 DEFUN (isis_priority_l1,
 382        isis_priority_l1_cmd,
 383        "isis priority (0-127) level-1",
 384        "IS-IS commands\n"
 385        "Set priority for Designated Router election\n"
 386        "Priority value\n"
 387        "Specify priority for level-1 routing\n")
 388 {
 389         int idx_number = 2;
 390         int prio;
 391         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 392         if (!circuit)
 393                 return CMD_ERR_NO_MATCH;
 394
 395         prio = atoi(argv[idx_number]->arg);
 396         if (prio < MIN_PRIORITY || prio > MAX_PRIORITY) {
 397                 vty_out(vty, "Invalid priority %d - should be <0-127>\n", prio);
 398                 return CMD_WARNING_CONFIG_FAILED;
 399         }
 400
 401         circuit->priority[0] = prio;
 402
 403         return CMD_SUCCESS;
 404 }
 405
 406 DEFUN (no_isis_priority_l1,
 407        no_isis_priority_l1_cmd,
 408        "no isis priority [(0-127)] level-1",
 409        NO_STR
 410        "IS-IS commands\n"
 411        "Set priority for Designated Router election\n"
 412        "Priority value\n"
 413        "Specify priority for level-1 routing\n")
 414 {
 415         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 416         if (!circuit)
 417                 return CMD_ERR_NO_MATCH;
 418
 419         circuit->priority[0] = DEFAULT_PRIORITY;
 420
 421         return CMD_SUCCESS;
 422 }
 423
 424
 425 DEFUN (isis_priority_l2,
 426        isis_priority_l2_cmd,
 427        "isis priority (0-127) level-2",
 428        "IS-IS commands\n"
 429        "Set priority for Designated Router election\n"
 430        "Priority value\n"
 431        "Specify priority for level-2 routing\n")
 432 {
 433         int idx_number = 2;
 434         int prio;
 435         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 436         if (!circuit)
 437                 return CMD_ERR_NO_MATCH;
 438
 439         prio = atoi(argv[idx_number]->arg);
 440         if (prio < MIN_PRIORITY || prio > MAX_PRIORITY) {
 441                 vty_out(vty, "Invalid priority %d - should be <0-127>\n", prio);
 442                 return CMD_WARNING_CONFIG_FAILED;
 443         }
 444
 445         circuit->priority[1] = prio;
 446
 447         return CMD_SUCCESS;
 448 }
 449
 450 DEFUN (no_isis_priority_l2,
 451        no_isis_priority_l2_cmd,
 452        "no isis priority [(0-127)] level-2",
 453        NO_STR
 454        "IS-IS commands\n"
 455        "Set priority for Designated Router election\n"
 456        "Priority value\n"
 457        "Specify priority for level-2 routing\n")
 458 {
 459         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 460         if (!circuit)
 461                 return CMD_ERR_NO_MATCH;
 462
 463         circuit->priority[1] = DEFAULT_PRIORITY;
 464
 465         return CMD_SUCCESS;
 466 }
 467
 468
 469 /* Metric command */
 470 DEFUN (isis_metric,
 471        isis_metric_cmd,
 472        "isis metric (0-16777215)",
 473        "IS-IS commands\n"
 474        "Set default metric for circuit\n"
 475        "Default metric value\n")
 476 {
 477         int idx_number = 2;
 478         int met;
 479         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 480         if (!circuit)
 481                 return CMD_ERR_NO_MATCH;
 482
 483         met = atoi(argv[idx_number]->arg);
 484
 485         /* RFC3787 section 5.1 */
 486         if (circuit->area && circuit->area->oldmetric == 1
 487             && met > MAX_NARROW_LINK_METRIC) {
 488                 vty_out(vty,
 489                         "Invalid metric %d - should be <0-63> "
 490                         "when narrow metric type enabled\n",
 491                         met);
 492                 return CMD_WARNING_CONFIG_FAILED;
 493         }
 494
 495         /* RFC4444 */
 496         if (circuit->area && circuit->area->newmetric == 1
 497             && met > MAX_WIDE_LINK_METRIC) {
 498                 vty_out(vty,
 499                         "Invalid metric %d - should be <0-16777215> "
 500                         "when wide metric type enabled\n",
 501                         met);
 502                 return CMD_WARNING_CONFIG_FAILED;
 503         }
 504
 505         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_1, met),
 506                         "Failed to set L1 metric: $ERR");
 507         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_2, met),
 508                         "Failed to set L2 metric: $ERR");
 509         return CMD_SUCCESS;
 510 }
 511
 512
 513 DEFUN (no_isis_metric,
 514        no_isis_metric_cmd,
 515        "no isis metric [(0-16777215)]",
 516        NO_STR
 517        "IS-IS commands\n"
 518        "Set default metric for circuit\n"
 519        "Default metric value\n")
 520 {
 521         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 522         if (!circuit)
 523                 return CMD_ERR_NO_MATCH;
 524
 525         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_1,
 526                                                 DEFAULT_CIRCUIT_METRIC),
 527                         "Failed to set L1 metric: $ERR");
 528         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_2,
 529                                                 DEFAULT_CIRCUIT_METRIC),
 530                         "Failed to set L2 metric: $ERR");
 531         return CMD_SUCCESS;
 532 }
 533
 534
 535 DEFUN (isis_metric_l1,
 536        isis_metric_l1_cmd,
 537        "isis metric (0-16777215) level-1",
 538        "IS-IS commands\n"
 539        "Set default metric for circuit\n"
 540        "Default metric value\n"
 541        "Specify metric for level-1 routing\n")
 542 {
 543         int idx_number = 2;
 544         int met;
 545         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 546         if (!circuit)
 547                 return CMD_ERR_NO_MATCH;
 548
 549         met = atoi(argv[idx_number]->arg);
 550         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_1, met),
 551                         "Failed to set L1 metric: $ERR");
 552         return CMD_SUCCESS;
 553 }
 554
 555
 556 DEFUN (no_isis_metric_l1,
 557        no_isis_metric_l1_cmd,
 558        "no isis metric [(0-16777215)] level-1",
 559        NO_STR
 560        "IS-IS commands\n"
 561        "Set default metric for circuit\n"
 562        "Default metric value\n"
 563        "Specify metric for level-1 routing\n")
 564 {
 565         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 566         if (!circuit)
 567                 return CMD_ERR_NO_MATCH;
 568
 569         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_1,
 570                                                 DEFAULT_CIRCUIT_METRIC),
 571                         "Failed to set L1 metric: $ERR");
 572         return CMD_SUCCESS;
 573 }
 574
 575
 576 DEFUN (isis_metric_l2,
 577        isis_metric_l2_cmd,
 578        "isis metric (0-16777215) level-2",
 579        "IS-IS commands\n"
 580        "Set default metric for circuit\n"
 581        "Default metric value\n"
 582        "Specify metric for level-2 routing\n")
 583 {
 584         int idx_number = 2;
 585         int met;
 586         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 587         if (!circuit)
 588                 return CMD_ERR_NO_MATCH;
 589
 590         met = atoi(argv[idx_number]->arg);
 591         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_2, met),
 592                         "Failed to set L2 metric: $ERR");
 593         return CMD_SUCCESS;
 594 }
 595
 596
 597 DEFUN (no_isis_metric_l2,
 598        no_isis_metric_l2_cmd,
 599        "no isis metric [(0-16777215)] level-2",
 600        NO_STR
 601        "IS-IS commands\n"
 602        "Set default metric for circuit\n"
 603        "Default metric value\n"
 604        "Specify metric for level-2 routing\n")
 605 {
 606         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 607         if (!circuit)
 608                 return CMD_ERR_NO_MATCH;
 609
 610         CMD_FERR_RETURN(isis_circuit_metric_set(circuit, IS_LEVEL_2,
 611                                                 DEFAULT_CIRCUIT_METRIC),
 612                         "Failed to set L2 metric: $ERR");
 613         return CMD_SUCCESS;
 614 }
 615
 616 /* end of metrics */
 617
 618 DEFUN (isis_hello_interval,
 619        isis_hello_interval_cmd,
 620        "isis hello-interval (1-600)",
 621        "IS-IS commands\n"
 622        "Set Hello interval\n"
 623        "Holdtime 1 seconds, interval depends on multiplier\n")
 624 {
 625         int idx_number = 2;
 626         int interval;
 627         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 628         if (!circuit)
 629                 return CMD_ERR_NO_MATCH;
 630
 631         interval = atoi(argv[idx_number]->arg);
 632         if (interval < MIN_HELLO_INTERVAL || interval > MAX_HELLO_INTERVAL) {
 633                 vty_out(vty, "Invalid hello-interval %d - should be <1-600>\n",
 634                         interval);
 635                 return CMD_WARNING_CONFIG_FAILED;
 636         }
 637
 638         circuit->hello_interval[0] = (uint16_t)interval;
 639         circuit->hello_interval[1] = (uint16_t)interval;
 640
 641         return CMD_SUCCESS;
 642 }
 643
 644
 645 DEFUN (no_isis_hello_interval,
 646        no_isis_hello_interval_cmd,
 647        "no isis hello-interval [(1-600)]",
 648        NO_STR
 649        "IS-IS commands\n"
 650        "Set Hello interval\n"
 651        "Holdtime 1 second, interval depends on multiplier\n")
 652 {
 653         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 654         if (!circuit)
 655                 return CMD_ERR_NO_MATCH;
 656
 657         circuit->hello_interval[0] = DEFAULT_HELLO_INTERVAL;
 658         circuit->hello_interval[1] = DEFAULT_HELLO_INTERVAL;
 659
 660         return CMD_SUCCESS;
 661 }
 662
 663
 664 DEFUN (isis_hello_interval_l1,
 665        isis_hello_interval_l1_cmd,
 666        "isis hello-interval (1-600) level-1",
 667        "IS-IS commands\n"
 668        "Set Hello interval\n"
 669        "Holdtime 1 second, interval depends on multiplier\n"
 670        "Specify hello-interval for level-1 IIHs\n")
 671 {
 672         int idx_number = 2;
 673         long interval;
 674         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 675         if (!circuit)
 676                 return CMD_ERR_NO_MATCH;
 677
 678         interval = atoi(argv[idx_number]->arg);
 679         if (interval < MIN_HELLO_INTERVAL || interval > MAX_HELLO_INTERVAL) {
 680                 vty_out(vty, "Invalid hello-interval %ld - should be <1-600>\n",
 681                         interval);
 682                 return CMD_WARNING_CONFIG_FAILED;
 683         }
 684
 685         circuit->hello_interval[0] = (uint16_t)interval;
 686
 687         return CMD_SUCCESS;
 688 }
 689
 690
 691 DEFUN (no_isis_hello_interval_l1,
 692        no_isis_hello_interval_l1_cmd,
 693        "no isis hello-interval [(1-600)] level-1",
 694        NO_STR
 695        "IS-IS commands\n"
 696        "Set Hello interval\n"
 697        "Holdtime 1 second, interval depends on multiplier\n"
 698        "Specify hello-interval for level-1 IIHs\n")
 699 {
 700         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 701         if (!circuit)
 702                 return CMD_ERR_NO_MATCH;
 703
 704         circuit->hello_interval[0] = DEFAULT_HELLO_INTERVAL;
 705
 706         return CMD_SUCCESS;
 707 }
 708
 709
 710 DEFUN (isis_hello_interval_l2,
 711        isis_hello_interval_l2_cmd,
 712        "isis hello-interval (1-600) level-2",
 713        "IS-IS commands\n"
 714        "Set Hello interval\n"
 715        "Holdtime 1 second, interval depends on multiplier\n"
 716        "Specify hello-interval for level-2 IIHs\n")
 717 {
 718         int idx_number = 2;
 719         long interval;
 720         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 721         if (!circuit)
 722                 return CMD_ERR_NO_MATCH;
 723
 724         interval = atoi(argv[idx_number]->arg);
 725         if (interval < MIN_HELLO_INTERVAL || interval > MAX_HELLO_INTERVAL) {
 726                 vty_out(vty, "Invalid hello-interval %ld - should be <1-600>\n",
 727                         interval);
 728                 return CMD_WARNING_CONFIG_FAILED;
 729         }
 730
 731         circuit->hello_interval[1] = (uint16_t)interval;
 732
 733         return CMD_SUCCESS;
 734 }
 735
 736
 737 DEFUN (no_isis_hello_interval_l2,
 738        no_isis_hello_interval_l2_cmd,
 739        "no isis hello-interval [(1-600)] level-2",
 740        NO_STR
 741        "IS-IS commands\n"
 742        "Set Hello interval\n"
 743        "Holdtime 1 second, interval depends on multiplier\n"
 744        "Specify hello-interval for level-2 IIHs\n")
 745 {
 746         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 747         if (!circuit)
 748                 return CMD_ERR_NO_MATCH;
 749
 750         circuit->hello_interval[1] = DEFAULT_HELLO_INTERVAL;
 751
 752         return CMD_SUCCESS;
 753 }
 754
 755
 756 DEFUN (isis_hello_multiplier,
 757        isis_hello_multiplier_cmd,
 758        "isis hello-multiplier (2-100)",
 759        "IS-IS commands\n"
 760        "Set multiplier for Hello holding time\n"
 761        "Hello multiplier value\n")
 762 {
 763         int idx_number = 2;
 764         int mult;
 765         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 766         if (!circuit)
 767                 return CMD_ERR_NO_MATCH;
 768
 769         mult = atoi(argv[idx_number]->arg);
 770         if (mult < MIN_HELLO_MULTIPLIER || mult > MAX_HELLO_MULTIPLIER) {
 771                 vty_out(vty,
 772                         "Invalid hello-multiplier %d - should be <2-100>\n",
 773                         mult);
 774                 return CMD_WARNING_CONFIG_FAILED;
 775         }
 776
 777         circuit->hello_multiplier[0] = (uint16_t)mult;
 778         circuit->hello_multiplier[1] = (uint16_t)mult;
 779
 780         return CMD_SUCCESS;
 781 }
 782
 783
 784 DEFUN (no_isis_hello_multiplier,
 785        no_isis_hello_multiplier_cmd,
 786        "no isis hello-multiplier [(2-100)]",
 787        NO_STR
 788        "IS-IS commands\n"
 789        "Set multiplier for Hello holding time\n"
 790        "Hello multiplier value\n")
 791 {
 792         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 793         if (!circuit)
 794                 return CMD_ERR_NO_MATCH;
 795
 796         circuit->hello_multiplier[0] = DEFAULT_HELLO_MULTIPLIER;
 797         circuit->hello_multiplier[1] = DEFAULT_HELLO_MULTIPLIER;
 798
 799         return CMD_SUCCESS;
 800 }
 801
 802
 803 DEFUN (isis_hello_multiplier_l1,
 804        isis_hello_multiplier_l1_cmd,
 805        "isis hello-multiplier (2-100) level-1",
 806        "IS-IS commands\n"
 807        "Set multiplier for Hello holding time\n"
 808        "Hello multiplier value\n"
 809        "Specify hello multiplier for level-1 IIHs\n")
 810 {
 811         int idx_number = 2;
 812         int mult;
 813         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 814         if (!circuit)
 815                 return CMD_ERR_NO_MATCH;
 816
 817         mult = atoi(argv[idx_number]->arg);
 818         if (mult < MIN_HELLO_MULTIPLIER || mult > MAX_HELLO_MULTIPLIER) {
 819                 vty_out(vty,
 820                         "Invalid hello-multiplier %d - should be <2-100>\n",
 821                         mult);
 822                 return CMD_WARNING_CONFIG_FAILED;
 823         }
 824
 825         circuit->hello_multiplier[0] = (uint16_t)mult;
 826
 827         return CMD_SUCCESS;
 828 }
 829
 830
 831 DEFUN (no_isis_hello_multiplier_l1,
 832        no_isis_hello_multiplier_l1_cmd,
 833        "no isis hello-multiplier [(2-100)] level-1",
 834        NO_STR
 835        "IS-IS commands\n"
 836        "Set multiplier for Hello holding time\n"
 837        "Hello multiplier value\n"
 838        "Specify hello multiplier for level-1 IIHs\n")
 839 {
 840         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 841         if (!circuit)
 842                 return CMD_ERR_NO_MATCH;
 843
 844         circuit->hello_multiplier[0] = DEFAULT_HELLO_MULTIPLIER;
 845
 846         return CMD_SUCCESS;
 847 }
 848
 849
 850 DEFUN (isis_hello_multiplier_l2,
 851        isis_hello_multiplier_l2_cmd,
 852        "isis hello-multiplier (2-100) level-2",
 853        "IS-IS commands\n"
 854        "Set multiplier for Hello holding time\n"
 855        "Hello multiplier value\n"
 856        "Specify hello multiplier for level-2 IIHs\n")
 857 {
 858         int idx_number = 2;
 859         int mult;
 860         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 861         if (!circuit)
 862                 return CMD_ERR_NO_MATCH;
 863
 864         mult = atoi(argv[idx_number]->arg);
 865         if (mult < MIN_HELLO_MULTIPLIER || mult > MAX_HELLO_MULTIPLIER) {
 866                 vty_out(vty,
 867                         "Invalid hello-multiplier %d - should be <2-100>\n",
 868                         mult);
 869                 return CMD_WARNING_CONFIG_FAILED;
 870         }
 871
 872         circuit->hello_multiplier[1] = (uint16_t)mult;
 873
 874         return CMD_SUCCESS;
 875 }
 876
 877
 878 DEFUN (no_isis_hello_multiplier_l2,
 879        no_isis_hello_multiplier_l2_cmd,
 880        "no isis hello-multiplier [(2-100)] level-2",
 881        NO_STR
 882        "IS-IS commands\n"
 883        "Set multiplier for Hello holding time\n"
 884        "Hello multiplier value\n"
 885        "Specify hello multiplier for level-2 IIHs\n")
 886 {
 887         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 888         if (!circuit)
 889                 return CMD_ERR_NO_MATCH;
 890
 891         circuit->hello_multiplier[1] = DEFAULT_HELLO_MULTIPLIER;
 892
 893         return CMD_SUCCESS;
 894 }
 895
 896
 897 DEFUN (isis_hello_padding,
 898        isis_hello_padding_cmd,
 899        "isis hello padding",
 900        "IS-IS commands\n"
 901        "Add padding to IS-IS hello packets\n"
 902        "Pad hello packets\n")
 903 {
 904         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 905         if (!circuit)
 906                 return CMD_ERR_NO_MATCH;
 907
 908         circuit->pad_hellos = 1;
 909
 910         return CMD_SUCCESS;
 911 }
 912
 913 DEFUN (no_isis_hello_padding,
 914        no_isis_hello_padding_cmd,
 915        "no isis hello padding",
 916        NO_STR
 917        "IS-IS commands\n"
 918        "Add padding to IS-IS hello packets\n"
 919        "Pad hello packets\n")
 920 {
 921         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 922         if (!circuit)
 923                 return CMD_ERR_NO_MATCH;
 924
 925         circuit->pad_hellos = 0;
 926
 927         return CMD_SUCCESS;
 928 }
 929
 930 DEFUN (isis_threeway_adj,
 931        isis_threeway_adj_cmd,
 932        "[no] isis three-way-handshake",
 933        NO_STR
 934        "IS-IS commands\n"
 935        "Enable/Disable three-way handshake\n")
 936 {
 937         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 938         if (!circuit)
 939                 return CMD_ERR_NO_MATCH;
 940
 941         circuit->disable_threeway_adj = !strcmp(argv[0]->text, "no");
 942         return CMD_SUCCESS;
 943 }
 944
 945 DEFUN (csnp_interval,
 946        csnp_interval_cmd,
 947        "isis csnp-interval (1-600)",
 948        "IS-IS commands\n"
 949        "Set CSNP interval in seconds\n"
 950        "CSNP interval value\n")
 951 {
 952         int idx_number = 2;
 953         unsigned long interval;
 954         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 955         if (!circuit)
 956                 return CMD_ERR_NO_MATCH;
 957
 958         interval = atol(argv[idx_number]->arg);
 959         if (interval < MIN_CSNP_INTERVAL || interval > MAX_CSNP_INTERVAL) {
 960                 vty_out(vty, "Invalid csnp-interval %lu - should be <1-600>\n",
 961                         interval);
 962                 return CMD_WARNING_CONFIG_FAILED;
 963         }
 964
 965         circuit->csnp_interval[0] = (uint16_t)interval;
 966         circuit->csnp_interval[1] = (uint16_t)interval;
 967
 968         return CMD_SUCCESS;
 969 }
 970
 971
 972 DEFUN (no_csnp_interval,
 973        no_csnp_interval_cmd,
 974        "no isis csnp-interval [(1-600)]",
 975        NO_STR
 976        "IS-IS commands\n"
 977        "Set CSNP interval in seconds\n"
 978        "CSNP interval value\n")
 979 {
 980         struct isis_circuit *circuit = isis_circuit_lookup(vty);
 981         if (!circuit)
 982                 return CMD_ERR_NO_MATCH;
 983
 984         circuit->csnp_interval[0] = DEFAULT_CSNP_INTERVAL;
 985         circuit->csnp_interval[1] = DEFAULT_CSNP_INTERVAL;
 986
 987         return CMD_SUCCESS;
 988 }
 989
 990
 991 DEFUN (csnp_interval_l1,
 992        csnp_interval_l1_cmd,
 993        "isis csnp-interval (1-600) level-1",
 994        "IS-IS commands\n"
 995        "Set CSNP interval in seconds\n"
 996        "CSNP interval value\n"
 997        "Specify interval for level-1 CSNPs\n")
 998 {
 999         int idx_number = 2;
1000         unsigned long interval;
1001         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1002         if (!circuit)
1003                 return CMD_ERR_NO_MATCH;
1004
1005         interval = atol(argv[idx_number]->arg);
1006         if (interval < MIN_CSNP_INTERVAL || interval > MAX_CSNP_INTERVAL) {
1007                 vty_out(vty, "Invalid csnp-interval %lu - should be <1-600>\n",
1008                         interval);
1009                 return CMD_WARNING_CONFIG_FAILED;
1010         }
1011
1012         circuit->csnp_interval[0] = (uint16_t)interval;
1013
1014         return CMD_SUCCESS;
1015 }
1016
1017
1018 DEFUN (no_csnp_interval_l1,
1019        no_csnp_interval_l1_cmd,
1020        "no isis csnp-interval [(1-600)] level-1",
1021        NO_STR
1022        "IS-IS commands\n"
1023        "Set CSNP interval in seconds\n"
1024        "CSNP interval value\n"
1025        "Specify interval for level-1 CSNPs\n")
1026 {
1027         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1028         if (!circuit)
1029                 return CMD_ERR_NO_MATCH;
1030
1031         circuit->csnp_interval[0] = DEFAULT_CSNP_INTERVAL;
1032
1033         return CMD_SUCCESS;
1034 }
1035
1036
1037 DEFUN (csnp_interval_l2,
1038        csnp_interval_l2_cmd,
1039        "isis csnp-interval (1-600) level-2",
1040        "IS-IS commands\n"
1041        "Set CSNP interval in seconds\n"
1042        "CSNP interval value\n"
1043        "Specify interval for level-2 CSNPs\n")
1044 {
1045         int idx_number = 2;
1046         unsigned long interval;
1047         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1048         if (!circuit)
1049                 return CMD_ERR_NO_MATCH;
1050
1051         interval = atol(argv[idx_number]->arg);
1052         if (interval < MIN_CSNP_INTERVAL || interval > MAX_CSNP_INTERVAL) {
1053                 vty_out(vty, "Invalid csnp-interval %lu - should be <1-600>\n",
1054                         interval);
1055                 return CMD_WARNING_CONFIG_FAILED;
1056         }
1057
1058         circuit->csnp_interval[1] = (uint16_t)interval;
1059
1060         return CMD_SUCCESS;
1061 }
1062
1063
1064 DEFUN (no_csnp_interval_l2,
1065        no_csnp_interval_l2_cmd,
1066        "no isis csnp-interval [(1-600)] level-2",
1067        NO_STR
1068        "IS-IS commands\n"
1069        "Set CSNP interval in seconds\n"
1070        "CSNP interval value\n"
1071        "Specify interval for level-2 CSNPs\n")
1072 {
1073         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1074         if (!circuit)
1075                 return CMD_ERR_NO_MATCH;
1076
1077         circuit->csnp_interval[1] = DEFAULT_CSNP_INTERVAL;
1078
1079         return CMD_SUCCESS;
1080 }
1081
1082
1083 DEFUN (psnp_interval,
1084        psnp_interval_cmd,
1085        "isis psnp-interval (1-120)",
1086        "IS-IS commands\n"
1087        "Set PSNP interval in seconds\n"
1088        "PSNP interval value\n")
1089 {
1090         int idx_number = 2;
1091         unsigned long interval;
1092         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1093         if (!circuit)
1094                 return CMD_ERR_NO_MATCH;
1095
1096         interval = atol(argv[idx_number]->arg);
1097         if (interval < MIN_PSNP_INTERVAL || interval > MAX_PSNP_INTERVAL) {
1098                 vty_out(vty, "Invalid psnp-interval %lu - should be <1-120>\n",
1099                         interval);
1100                 return CMD_WARNING_CONFIG_FAILED;
1101         }
1102
1103         circuit->psnp_interval[0] = (uint16_t)interval;
1104         circuit->psnp_interval[1] = (uint16_t)interval;
1105
1106         return CMD_SUCCESS;
1107 }
1108
1109
1110 DEFUN (no_psnp_interval,
1111        no_psnp_interval_cmd,
1112        "no isis psnp-interval [(1-120)]",
1113        NO_STR
1114        "IS-IS commands\n"
1115        "Set PSNP interval in seconds\n"
1116        "PSNP interval value\n")
1117 {
1118         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1119         if (!circuit)
1120                 return CMD_ERR_NO_MATCH;
1121
1122         circuit->psnp_interval[0] = DEFAULT_PSNP_INTERVAL;
1123         circuit->psnp_interval[1] = DEFAULT_PSNP_INTERVAL;
1124
1125         return CMD_SUCCESS;
1126 }
1127
1128
1129 DEFUN (psnp_interval_l1,
1130        psnp_interval_l1_cmd,
1131        "isis psnp-interval (1-120) level-1",
1132        "IS-IS commands\n"
1133        "Set PSNP interval in seconds\n"
1134        "PSNP interval value\n"
1135        "Specify interval for level-1 PSNPs\n")
1136 {
1137         int idx_number = 2;
1138         unsigned long interval;
1139         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1140         if (!circuit)
1141                 return CMD_ERR_NO_MATCH;
1142
1143         interval = atol(argv[idx_number]->arg);
1144         if (interval < MIN_PSNP_INTERVAL || interval > MAX_PSNP_INTERVAL) {
1145                 vty_out(vty, "Invalid psnp-interval %lu - should be <1-120>\n",
1146                         interval);
1147                 return CMD_WARNING_CONFIG_FAILED;
1148         }
1149
1150         circuit->psnp_interval[0] = (uint16_t)interval;
1151
1152         return CMD_SUCCESS;
1153 }
1154
1155
1156 DEFUN (no_psnp_interval_l1,
1157        no_psnp_interval_l1_cmd,
1158        "no isis psnp-interval [(1-120)] level-1",
1159        NO_STR
1160        "IS-IS commands\n"
1161        "Set PSNP interval in seconds\n"
1162        "PSNP interval value\n"
1163        "Specify interval for level-1 PSNPs\n")
1164 {
1165         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1166         if (!circuit)
1167                 return CMD_ERR_NO_MATCH;
1168
1169         circuit->psnp_interval[0] = DEFAULT_PSNP_INTERVAL;
1170
1171         return CMD_SUCCESS;
1172 }
1173
1174
1175 DEFUN (psnp_interval_l2,
1176        psnp_interval_l2_cmd,
1177        "isis psnp-interval (1-120) level-2",
1178        "IS-IS commands\n"
1179        "Set PSNP interval in seconds\n"
1180        "PSNP interval value\n"
1181        "Specify interval for level-2 PSNPs\n")
1182 {
1183         int idx_number = 2;
1184         unsigned long interval;
1185         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1186         if (!circuit)
1187                 return CMD_ERR_NO_MATCH;
1188
1189         interval = atol(argv[idx_number]->arg);
1190         if (interval < MIN_PSNP_INTERVAL || interval > MAX_PSNP_INTERVAL) {
1191                 vty_out(vty, "Invalid psnp-interval %lu - should be <1-120>\n",
1192                         interval);
1193                 return CMD_WARNING_CONFIG_FAILED;
1194         }
1195
1196         circuit->psnp_interval[1] = (uint16_t)interval;
1197
1198         return CMD_SUCCESS;
1199 }
1200
1201
1202 DEFUN (no_psnp_interval_l2,
1203        no_psnp_interval_l2_cmd,
1204        "no isis psnp-interval [(1-120)] level-2",
1205        NO_STR
1206        "IS-IS commands\n"
1207        "Set PSNP interval in seconds\n"
1208        "PSNP interval value\n"
1209        "Specify interval for level-2 PSNPs\n")
1210 {
1211         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1212         if (!circuit)
1213                 return CMD_ERR_NO_MATCH;
1214
1215         circuit->psnp_interval[1] = DEFAULT_PSNP_INTERVAL;
1216
1217         return CMD_SUCCESS;
1218 }
1219
1220 DEFUN (circuit_topology,
1221        circuit_topology_cmd,
1222        "isis topology " ISIS_MT_NAMES,
1223        "IS-IS commands\n"
1224        "Configure interface IS-IS topologies\n"
1225        ISIS_MT_DESCRIPTIONS)
1226 {
1227         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1228         if (!circuit)
1229                 return CMD_ERR_NO_MATCH;
1230         const char *arg = argv[2]->arg;
1231         uint16_t mtid = isis_str2mtid(arg);
1232
1233         if (circuit->area && circuit->area->oldmetric) {
1234                 vty_out(vty,
1235                         "Multi topology IS-IS can only be used with wide metrics\n");
1236                 return CMD_WARNING_CONFIG_FAILED;
1237         }
1238
1239         if (mtid == (uint16_t)-1) {
1240                 vty_out(vty, "Don't know topology '%s'\n", arg);
1241                 return CMD_WARNING_CONFIG_FAILED;
1242         }
1243
1244         return isis_circuit_mt_enabled_set(circuit, mtid, true);
1245 }
1246
1247 DEFUN (no_circuit_topology,
1248        no_circuit_topology_cmd,
1249        "no isis topology " ISIS_MT_NAMES,
1250        NO_STR
1251        "IS-IS commands\n"
1252        "Configure interface IS-IS topologies\n"
1253        ISIS_MT_DESCRIPTIONS)
1254 {
1255         struct isis_circuit *circuit = isis_circuit_lookup(vty);
1256         if (!circuit)
1257                 return CMD_ERR_NO_MATCH;
1258         const char *arg = argv[3]->arg;
1259         uint16_t mtid = isis_str2mtid(arg);
1260
1261         if (circuit->area && circuit->area->oldmetric) {
1262                 vty_out(vty,
1263                         "Multi topology IS-IS can only be used with wide metrics\n");
1264                 return CMD_WARNING_CONFIG_FAILED;
1265         }
1266
1267         if (mtid == (uint16_t)-1) {
1268                 vty_out(vty, "Don't know topology '%s'\n", arg);
1269                 return CMD_WARNING_CONFIG_FAILED;
1270         }
1271
1272         return isis_circuit_mt_enabled_set(circuit, mtid, false);
1273 }
1274
1275 static int validate_metric_style_narrow(struct vty *vty, struct isis_area *area)
1276 {
1277         struct isis_circuit *circuit;
1278         struct listnode *node;
1279
1280         if (!vty)
1281                 return CMD_WARNING_CONFIG_FAILED;
1282
1283         if (!area) {
1284                 vty_out(vty, "ISIS area is invalid\n");
1285                 return CMD_WARNING_CONFIG_FAILED;
1286         }
1287
1288         for (ALL_LIST_ELEMENTS_RO(area->circuit_list, node, circuit)) {
1289                 if ((area->is_type & IS_LEVEL_1)
1290                     && (circuit->is_type & IS_LEVEL_1)
1291                     && (circuit->te_metric[0] > MAX_NARROW_LINK_METRIC)) {
1292                         vty_out(vty, "ISIS circuit %s metric is invalid\n",
1293                                 circuit->interface->name);
1294                         return CMD_WARNING_CONFIG_FAILED;
1295                 }
1296                 if ((area->is_type & IS_LEVEL_2)
1297                     && (circuit->is_type & IS_LEVEL_2)
1298                     && (circuit->te_metric[1] > MAX_NARROW_LINK_METRIC)) {
1299                         vty_out(vty, "ISIS circuit %s metric is invalid\n",
1300                                 circuit->interface->name);
1301                         return CMD_WARNING_CONFIG_FAILED;
1302                 }
1303         }
1304
1305         return CMD_SUCCESS;
1306 }
1307
1308 DEFUN (metric_style,
1309        metric_style_cmd,
1310        "metric-style <narrow|transition|wide>",
1311        "Use old-style (ISO 10589) or new-style packet formats\n"
1312        "Use old style of TLVs with narrow metric\n"
1313        "Send and accept both styles of TLVs during transition\n"
1314        "Use new style of TLVs to carry wider metric\n")
1315 {
1316         int idx_metric_style = 1;
1317         VTY_DECLVAR_CONTEXT(isis_area, area);
1318         int ret;
1319
1320         if (strncmp(argv[idx_metric_style]->arg, "w", 1) == 0) {
1321                 isis_area_metricstyle_set(area, false, true);
1322                 return CMD_SUCCESS;
1323         }
1324
1325         if (area_is_mt(area)) {
1326                 vty_out(vty,
1327                         "Narrow metrics cannot be used while multi topology IS-IS is active\n");
1328                 return CMD_WARNING_CONFIG_FAILED;
1329         }
1330
1331         ret = validate_metric_style_narrow(vty, area);
1332         if (ret != CMD_SUCCESS)
1333                 return ret;
1334
1335         if (strncmp(argv[idx_metric_style]->arg, "t", 1) == 0)
1336                 isis_area_metricstyle_set(area, true, true);
1337         else if (strncmp(argv[idx_metric_style]->arg, "n", 1) == 0)
1338                 isis_area_metricstyle_set(area, true, false);
1339         return CMD_SUCCESS;
1340
1341         return CMD_SUCCESS;
1342 }
1343
1344 DEFUN (no_metric_style,
1345        no_metric_style_cmd,
1346        "no metric-style",
1347        NO_STR
1348        "Use old-style (ISO 10589) or new-style packet formats\n")
1349 {
1350         VTY_DECLVAR_CONTEXT(isis_area, area);
1351         int ret;
1352
1353         if (area_is_mt(area)) {
1354                 vty_out(vty,
1355                         "Narrow metrics cannot be used while multi topology IS-IS is active\n");
1356                 return CMD_WARNING_CONFIG_FAILED;
1357         }
1358
1359         ret = validate_metric_style_narrow(vty, area);
1360         if (ret != CMD_SUCCESS)
1361                 return ret;
1362
1363         isis_area_metricstyle_set(area, true, false);
1364         return CMD_SUCCESS;
1365 }
1366
1367 DEFUN (set_overload_bit,
1368        set_overload_bit_cmd,
1369        "set-overload-bit",
1370        "Set overload bit to avoid any transit traffic\n")
1371 {
1372         VTY_DECLVAR_CONTEXT(isis_area, area);
1373
1374         isis_area_overload_bit_set(area, true);
1375         return CMD_SUCCESS;
1376 }
1377
1378 DEFUN (no_set_overload_bit,
1379        no_set_overload_bit_cmd,
1380        "no set-overload-bit",
1381        "Reset overload bit to accept transit traffic\n"
1382        "Reset overload bit\n")
1383 {
1384         VTY_DECLVAR_CONTEXT(isis_area, area);
1385
1386         isis_area_overload_bit_set(area, false);
1387         return CMD_SUCCESS;
1388 }
1389
1390 DEFUN (set_attached_bit,
1391        set_attached_bit_cmd,
1392        "set-attached-bit",
1393        "Set attached bit to identify as L1/L2 router for inter-area traffic\n")
1394 {
1395         VTY_DECLVAR_CONTEXT(isis_area, area);
1396
1397         isis_area_attached_bit_set(area, true);
1398         return CMD_SUCCESS;
1399 }
1400
1401 DEFUN (no_set_attached_bit,
1402        no_set_attached_bit_cmd,
1403        "no set-attached-bit",
1404        NO_STR
1405        "Reset attached bit\n")
1406 {
1407         VTY_DECLVAR_CONTEXT(isis_area, area);
1408
1409         isis_area_attached_bit_set(area, false);
1410         return CMD_SUCCESS;
1411 }
1412
1413 DEFUN (dynamic_hostname,
1414        dynamic_hostname_cmd,
1415        "hostname dynamic",
1416        "Dynamic hostname for IS-IS\n"
1417        "Dynamic hostname\n")
1418 {
1419         VTY_DECLVAR_CONTEXT(isis_area, area);
1420
1421         isis_area_dynhostname_set(area, true);
1422         return CMD_SUCCESS;
1423 }
1424
1425 DEFUN (no_dynamic_hostname,
1426        no_dynamic_hostname_cmd,
1427        "no hostname dynamic",
1428        NO_STR
1429        "Dynamic hostname for IS-IS\n"
1430        "Dynamic hostname\n")
1431 {
1432         VTY_DECLVAR_CONTEXT(isis_area, area);
1433
1434         isis_area_dynhostname_set(area, false);
1435         return CMD_SUCCESS;
1436 }
1437
1438 static int area_lsp_mtu_set(struct vty *vty, unsigned int lsp_mtu)
1439 {
1440         VTY_DECLVAR_CONTEXT(isis_area, area);
1441         struct listnode *node;
1442         struct isis_circuit *circuit;
1443
1444         for (ALL_LIST_ELEMENTS_RO(area->circuit_list, node, circuit)) {
1445                 if (circuit->state != C_STATE_INIT
1446                     && circuit->state != C_STATE_UP)
1447                         continue;
1448                 if (lsp_mtu > isis_circuit_pdu_size(circuit)) {
1449                         vty_out(vty,
1450                                 "ISIS area contains circuit %s, which has a maximum PDU size of %zu.\n",
1451                                 circuit->interface->name,
1452                                 isis_circuit_pdu_size(circuit));
1453                         return CMD_WARNING_CONFIG_FAILED;
1454                 }
1455         }
1456
1457         isis_area_lsp_mtu_set(area, lsp_mtu);
1458         return CMD_SUCCESS;
1459 }
1460
1461 DEFUN (area_lsp_mtu,
1462        area_lsp_mtu_cmd,
1463        "lsp-mtu (128-4352)",
1464        "Configure the maximum size of generated LSPs\n"
1465        "Maximum size of generated LSPs\n")
1466 {
1467         int idx_number = 1;
1468         unsigned int lsp_mtu;
1469
1470         lsp_mtu = strtoul(argv[idx_number]->arg, NULL, 10);
1471
1472         return area_lsp_mtu_set(vty, lsp_mtu);
1473 }
1474
1475
1476 DEFUN (no_area_lsp_mtu,
1477        no_area_lsp_mtu_cmd,
1478        "no lsp-mtu [(128-4352)]",
1479        NO_STR
1480        "Configure the maximum size of generated LSPs\n"
1481        "Maximum size of generated LSPs\n")
1482 {
1483         return area_lsp_mtu_set(vty, DEFAULT_LSP_MTU);
1484 }
1485
1486
1487 DEFUN (is_type,
1488        is_type_cmd,
1489        "is-type <level-1|level-1-2|level-2-only>",
1490        "IS Level for this routing process (OSI only)\n"
1491        "Act as a station router only\n"
1492        "Act as both a station router and an area router\n"
1493        "Act as an area router only\n")
1494 {
1495         int idx_level = 1;
1496         VTY_DECLVAR_CONTEXT(isis_area, area);
1497         int type;
1498
1499         type = string2circuit_t(argv[idx_level]->arg);
1500         if (!type) {
1501                 vty_out(vty, "Unknown IS level \n");
1502                 return CMD_SUCCESS;
1503         }
1504
1505         isis_area_is_type_set(area, type);
1506
1507         return CMD_SUCCESS;
1508 }
1509
1510 DEFUN (no_is_type,
1511        no_is_type_cmd,
1512        "no is-type <level-1|level-1-2|level-2-only>",
1513        NO_STR
1514        "IS Level for this routing process (OSI only)\n"
1515        "Act as a station router only\n"
1516        "Act as both a station router and an area router\n"
1517        "Act as an area router only\n")
1518 {
1519         VTY_DECLVAR_CONTEXT(isis_area, area);
1520         int type;
1521
1522         /*
1523          * Put the is-type back to defaults:
1524          * - level-1-2 on first area
1525          * - level-1 for the rest
1526          */
1527         if (listgetdata(listhead(isis->area_list)) == area)
1528                 type = IS_LEVEL_1_AND_2;
1529         else
1530                 type = IS_LEVEL_1;
1531
1532         isis_area_is_type_set(area, type);
1533
1534         return CMD_SUCCESS;
1535 }
1536
1537 static int set_lsp_gen_interval(struct vty *vty, struct isis_area *area,
1538                                 uint16_t interval, int level)
1539 {
1540         int lvl;
1541
1542         for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl) {
1543                 if (!(lvl & level))
1544                         continue;
1545
1546                 if (interval >= area->lsp_refresh[lvl - 1]) {
1547                         vty_out(vty,
1548                                 "LSP gen interval %us must be less than "
1549                                 "the LSP refresh interval %us\n",
1550                                 interval, area->lsp_refresh[lvl - 1]);
1551                         return CMD_WARNING_CONFIG_FAILED;
1552                 }
1553         }
1554
1555         for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl) {
1556                 if (!(lvl & level))
1557                         continue;
1558                 area->lsp_gen_interval[lvl - 1] = interval;
1559         }
1560
1561         return CMD_SUCCESS;
1562 }
1563
1564 DEFUN (lsp_gen_interval,
1565        lsp_gen_interval_cmd,
1566        "lsp-gen-interval [<level-1|level-2>] (1-120)",
1567        "Minimum interval between regenerating same LSP\n"
1568        "Set interval for level 1 only\n"
1569        "Set interval for level 2 only\n"
1570        "Minimum interval in seconds\n")
1571 {
1572         int idx = 0;
1573         VTY_DECLVAR_CONTEXT(isis_area, area);
1574         uint16_t interval;
1575         int level;
1576
1577         level = 0;
1578         level |= argv_find(argv, argc, "level-1", &idx) ? IS_LEVEL_1 : 0;
1579         level |= argv_find(argv, argc, "level-2", &idx) ? IS_LEVEL_2 : 0;
1580         if (!level)
1581                 level = IS_LEVEL_1 | IS_LEVEL_2;
1582
1583         argv_find(argv, argc, "(1-120)", &idx);
1584
1585         interval = atoi(argv[idx]->arg);
1586         return set_lsp_gen_interval(vty, area, interval, level);
1587 }
1588
1589 DEFUN (no_lsp_gen_interval,
1590        no_lsp_gen_interval_cmd,
1591        "no lsp-gen-interval [<level-1|level-2>] [(1-120)]",
1592        NO_STR
1593        "Minimum interval between regenerating same LSP\n"
1594        "Set interval for level 1 only\n"
1595        "Set interval for level 2 only\n"
1596        "Minimum interval in seconds\n")
1597 {
1598         int idx = 0;
1599         VTY_DECLVAR_CONTEXT(isis_area, area);
1600         uint16_t interval;
1601         int level;
1602
1603         level = 0;
1604         level |= argv_find(argv, argc, "level-1", &idx) ? IS_LEVEL_1 : 0;
1605         level |= argv_find(argv, argc, "level-2", &idx) ? IS_LEVEL_2 : 0;
1606         if (!level)
1607                 level = IS_LEVEL_1 | IS_LEVEL_2;
1608
1609         interval = DEFAULT_MIN_LSP_GEN_INTERVAL;
1610         return set_lsp_gen_interval(vty, area, interval, level);
1611 }
1612
1613 DEFUN (spf_interval,
1614        spf_interval_cmd,
1615        "spf-interval (1-120)",
1616        "Minimum interval between SPF calculations\n"
1617        "Minimum interval between consecutive SPFs in seconds\n")
1618 {
1619         int idx_number = 1;
1620         VTY_DECLVAR_CONTEXT(isis_area, area);
1621         uint16_t interval;
1622
1623         interval = atoi(argv[idx_number]->arg);
1624         area->min_spf_interval[0] = interval;
1625         area->min_spf_interval[1] = interval;
1626
1627         return CMD_SUCCESS;
1628 }
1629
1630
1631 DEFUN (no_spf_interval,
1632        no_spf_interval_cmd,
1633        "no spf-interval [[<level-1|level-2>] (1-120)]",
1634        NO_STR
1635        "Minimum interval between SPF calculations\n"
1636        "Set interval for level 1 only\n"
1637        "Set interval for level 2 only\n"
1638        "Minimum interval between consecutive SPFs in seconds\n")
1639 {
1640         VTY_DECLVAR_CONTEXT(isis_area, area);
1641
1642         area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;
1643         area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;
1644
1645         return CMD_SUCCESS;
1646 }
1647
1648
1649 DEFUN (spf_interval_l1,
1650        spf_interval_l1_cmd,
1651        "spf-interval level-1 (1-120)",
1652        "Minimum interval between SPF calculations\n"
1653        "Set interval for level 1 only\n"
1654        "Minimum interval between consecutive SPFs in seconds\n")
1655 {
1656         int idx_number = 2;
1657         VTY_DECLVAR_CONTEXT(isis_area, area);
1658         uint16_t interval;
1659
1660         interval = atoi(argv[idx_number]->arg);
1661         area->min_spf_interval[0] = interval;
1662
1663         return CMD_SUCCESS;
1664 }
1665
1666 DEFUN (no_spf_interval_l1,
1667        no_spf_interval_l1_cmd,
1668        "no spf-interval level-1",
1669        NO_STR
1670        "Minimum interval between SPF calculations\n"
1671        "Set interval for level 1 only\n")
1672 {
1673         VTY_DECLVAR_CONTEXT(isis_area, area);
1674
1675         area->min_spf_interval[0] = MINIMUM_SPF_INTERVAL;
1676
1677         return CMD_SUCCESS;
1678 }
1679
1680
1681 DEFUN (spf_interval_l2,
1682        spf_interval_l2_cmd,
1683        "spf-interval level-2 (1-120)",
1684        "Minimum interval between SPF calculations\n"
1685        "Set interval for level 2 only\n"
1686        "Minimum interval between consecutive SPFs in seconds\n")
1687 {
1688         int idx_number = 2;
1689         VTY_DECLVAR_CONTEXT(isis_area, area);
1690         uint16_t interval;
1691
1692         interval = atoi(argv[idx_number]->arg);
1693         area->min_spf_interval[1] = interval;
1694
1695         return CMD_SUCCESS;
1696 }
1697
1698 DEFUN (no_spf_interval_l2,
1699        no_spf_interval_l2_cmd,
1700        "no spf-interval level-2",
1701        NO_STR
1702        "Minimum interval between SPF calculations\n"
1703        "Set interval for level 2 only\n")
1704 {
1705         VTY_DECLVAR_CONTEXT(isis_area, area);
1706
1707         area->min_spf_interval[1] = MINIMUM_SPF_INTERVAL;
1708
1709         return CMD_SUCCESS;
1710 }
1711
1712 DEFUN (no_spf_delay_ietf,
1713        no_spf_delay_ietf_cmd,
1714        "no spf-delay-ietf",
1715        NO_STR
1716        "IETF SPF delay algorithm\n")
1717 {
1718         VTY_DECLVAR_CONTEXT(isis_area, area);
1719
1720         spf_backoff_free(area->spf_delay_ietf[0]);
1721         spf_backoff_free(area->spf_delay_ietf[1]);
1722         area->spf_delay_ietf[0] = NULL;
1723         area->spf_delay_ietf[1] = NULL;
1724
1725         return CMD_SUCCESS;
1726 }
1727
1728 DEFUN (spf_delay_ietf,
1729        spf_delay_ietf_cmd,
1730        "spf-delay-ietf init-delay (0-60000) short-delay (0-60000) long-delay (0-60000) holddown (0-60000) time-to-learn (0-60000)",
1731        "IETF SPF delay algorithm\n"
1732        "Delay used while in QUIET state\n"
1733        "Delay used while in QUIET state in milliseconds\n"
1734        "Delay used while in SHORT_WAIT state\n"
1735        "Delay used while in SHORT_WAIT state in milliseconds\n"
1736        "Delay used while in LONG_WAIT\n"
1737        "Delay used while in LONG_WAIT state in milliseconds\n"
1738        "Time with no received IGP events before considering IGP stable\n"
1739        "Time with no received IGP events before considering IGP stable (in milliseconds)\n"
1740        "Maximum duration needed to learn all the events related to a single failure\n"
1741        "Maximum duration needed to learn all the events related to a single failure (in milliseconds)\n")
1742 {
1743         VTY_DECLVAR_CONTEXT(isis_area, area);
1744
1745         long init_delay = atol(argv[2]->arg);
1746         long short_delay = atol(argv[4]->arg);
1747         long long_delay = atol(argv[6]->arg);
1748         long holddown = atol(argv[8]->arg);
1749         long timetolearn = atol(argv[10]->arg);
1750
1751         size_t bufsiz = strlen(area->area_tag) + sizeof("IS-IS  Lx");
1752         char *buf = XCALLOC(MTYPE_TMP, bufsiz);
1753
1754         snprintf(buf, bufsiz, "IS-IS %s L1", area->area_tag);
1755         spf_backoff_free(area->spf_delay_ietf[0]);
1756         area->spf_delay_ietf[0] =
1757                 spf_backoff_new(master, buf, init_delay, short_delay,
1758                                 long_delay, holddown, timetolearn);
1759
1760         snprintf(buf, bufsiz, "IS-IS %s L2", area->area_tag);
1761         spf_backoff_free(area->spf_delay_ietf[1]);
1762         area->spf_delay_ietf[1] =
1763                 spf_backoff_new(master, buf, init_delay, short_delay,
1764                                 long_delay, holddown, timetolearn);
1765
1766         XFREE(MTYPE_TMP, buf);
1767         return CMD_SUCCESS;
1768 }
1769
1770 static int area_max_lsp_lifetime_set(struct vty *vty, int level,
1771                                      uint16_t interval)
1772 {
1773         VTY_DECLVAR_CONTEXT(isis_area, area);
1774         int lvl;
1775         uint16_t refresh_interval = interval - 300;
1776         int set_refresh_interval[ISIS_LEVELS] = {0, 0};
1777
1778         for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; lvl++) {
1779                 if (!(lvl & level))
1780                         continue;
1781
1782                 if (refresh_interval < area->lsp_refresh[lvl - 1]) {
1783                         vty_out(vty,
1784                                 "Level %d Max LSP lifetime %us must be 300s greater than "
1785                                 "the configured LSP refresh interval %us\n",
1786                                 lvl, interval, area->lsp_refresh[lvl - 1]);
1787                         vty_out(vty,
1788                                 "Automatically reducing level %d LSP refresh interval "
1789                                 "to %us\n",
1790                                 lvl, refresh_interval);
1791                         set_refresh_interval[lvl - 1] = 1;
1792
1793                         if (refresh_interval
1794                             <= area->lsp_gen_interval[lvl - 1]) {
1795                                 vty_out(vty,
1796                                         "LSP refresh interval %us must be greater than "
1797                                         "the configured LSP gen interval %us\n",
1798                                         refresh_interval,
1799                                         area->lsp_gen_interval[lvl - 1]);
1800                                 return CMD_WARNING_CONFIG_FAILED;
1801                         }
1802                 }
1803         }
1804
1805         for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; lvl++) {
1806                 if (!(lvl & level))
1807                         continue;
1808                 isis_area_max_lsp_lifetime_set(area, lvl, interval);
1809                 if (set_refresh_interval[lvl - 1])
1810                         isis_area_lsp_refresh_set(area, lvl, refresh_interval);
1811         }
1812
1813         return CMD_SUCCESS;
1814 }
1815
1816 DEFUN (max_lsp_lifetime,
1817        max_lsp_lifetime_cmd,
1818        "max-lsp-lifetime [<level-1|level-2>] (350-65535)",
1819        "Maximum LSP lifetime\n"
1820        "Maximum LSP lifetime for Level 1 only\n"
1821        "Maximum LSP lifetime for Level 2 only\n"
1822        "LSP lifetime in seconds\n")
1823 {
1824         int idx = 0;
1825         unsigned int level = IS_LEVEL_1_AND_2;
1826
1827         if (argv_find(argv, argc, "level-1", &idx))
1828                 level = IS_LEVEL_1;
1829         else if (argv_find(argv, argc, "level-2", &idx))
1830                 level = IS_LEVEL_2;
1831
1832         argv_find(argv, argc, "(350-65535)", &idx);
1833         int lifetime = atoi(argv[idx]->arg);
1834
1835         return area_max_lsp_lifetime_set(vty, level, lifetime);
1836 }
1837
1838
1839 DEFUN (no_max_lsp_lifetime,
1840        no_max_lsp_lifetime_cmd,
1841        "no max-lsp-lifetime [<level-1|level-2>] [(350-65535)]",
1842        NO_STR
1843        "Maximum LSP lifetime\n"
1844        "Maximum LSP lifetime for Level 1 only\n"
1845        "Maximum LSP lifetime for Level 2 only\n"
1846        "LSP lifetime in seconds\n")
1847 {
1848         int idx = 0;
1849         unsigned int level = IS_LEVEL_1_AND_2;
1850
1851         if (argv_find(argv, argc, "level-1", &idx))
1852                 level = IS_LEVEL_1;
1853         else if (argv_find(argv, argc, "level-2", &idx))
1854                 level = IS_LEVEL_2;
1855
1856         return area_max_lsp_lifetime_set(vty, level, DEFAULT_LSP_LIFETIME);
1857 }
1858
1859 static int area_lsp_refresh_interval_set(struct vty *vty, int level,
1860                                          uint16_t interval)
1861 {
1862         VTY_DECLVAR_CONTEXT(isis_area, area);
1863         int lvl;
1864
1865         for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl) {
1866                 if (!(lvl & level))
1867                         continue;
1868                 if (interval <= area->lsp_gen_interval[lvl - 1]) {
1869                         vty_out(vty,
1870                                 "LSP refresh interval %us must be greater than "
1871                                 "the configured LSP gen interval %us\n",
1872                                 interval, area->lsp_gen_interval[lvl - 1]);
1873                         return CMD_WARNING_CONFIG_FAILED;
1874                 }
1875                 if (interval > (area->max_lsp_lifetime[lvl - 1] - 300)) {
1876                         vty_out(vty,
1877                                 "LSP refresh interval %us must be less than "
1878                                 "the configured LSP lifetime %us less 300\n",
1879                                 interval, area->max_lsp_lifetime[lvl - 1]);
1880                         return CMD_WARNING_CONFIG_FAILED;
1881                 }
1882         }
1883
1884         for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; ++lvl) {
1885                 if (!(lvl & level))
1886                         continue;
1887                 isis_area_lsp_refresh_set(area, lvl, interval);
1888         }
1889
1890         return CMD_SUCCESS;
1891 }
1892
1893 DEFUN (lsp_refresh_interval,
1894        lsp_refresh_interval_cmd,
1895        "lsp-refresh-interval [<level-1|level-2>] (1-65235)",
1896        "LSP refresh interval\n"
1897        "LSP refresh interval for Level 1 only\n"
1898        "LSP refresh interval for Level 2 only\n"
1899        "LSP refresh interval in seconds\n")
1900 {
1901         int idx = 0;
1902         unsigned int level = IS_LEVEL_1_AND_2;
1903         unsigned int interval = 0;
1904
1905         if (argv_find(argv, argc, "level-1", &idx))
1906                 level = IS_LEVEL_1;
1907         else if (argv_find(argv, argc, "level-2", &idx))
1908                 level = IS_LEVEL_2;
1909
1910         interval = atoi(argv[argc - 1]->arg);
1911         return area_lsp_refresh_interval_set(vty, level, interval);
1912 }
1913
1914 DEFUN (no_lsp_refresh_interval,
1915        no_lsp_refresh_interval_cmd,
1916        "no lsp-refresh-interval [<level-1|level-2>] [(1-65235)]",
1917        NO_STR
1918        "LSP refresh interval\n"
1919        "LSP refresh interval for Level 1 only\n"
1920        "LSP refresh interval for Level 2 only\n"
1921        "LSP refresh interval in seconds\n")
1922 {
1923         int idx = 0;
1924         unsigned int level = IS_LEVEL_1_AND_2;
1925
1926         if (argv_find(argv, argc, "level-1", &idx))
1927                 level = IS_LEVEL_1;
1928         else if (argv_find(argv, argc, "level-2", &idx))
1929                 level = IS_LEVEL_2;
1930
1931         return area_lsp_refresh_interval_set(vty, level,
1932                                              DEFAULT_MAX_LSP_GEN_INTERVAL);
1933 }
1934
1935 static int area_passwd_set(struct vty *vty, int level,
1936                            int (*type_set)(struct isis_area *area, int level,
1937                                            const char *passwd,
1938                                            uint8_t snp_auth),
1939                            const char *passwd, uint8_t snp_auth)
1940 {
1941         VTY_DECLVAR_CONTEXT(isis_area, area);
1942
1943         if (passwd && strlen(passwd) > 254) {
1944                 vty_out(vty, "Too long area password (>254)\n");
1945                 return CMD_WARNING_CONFIG_FAILED;
1946         }
1947
1948         type_set(area, level, passwd, snp_auth);
1949         return CMD_SUCCESS;
1950 }
1951
1952
1953 DEFUN (area_passwd_md5,
1954        area_passwd_md5_cmd,
1955        "area-password md5 WORD [authenticate snp <send-only|validate>]",
1956        "Configure the authentication password for an area\n"
1957        "Authentication type\n"
1958        "Level-wide password\n"
1959        "Authentication\n"
1960        "SNP PDUs\n"
1961        "Send but do not check PDUs on receiving\n"
1962        "Send and check PDUs on receiving\n")
1963 {
1964         int idx_password = 0;
1965         int idx_word = 2;
1966         int idx_type = 5;
1967         uint8_t snp_auth = 0;
1968         int level = strmatch(argv[idx_password]->text, "domain-password")
1969                             ? IS_LEVEL_2
1970                             : IS_LEVEL_1;
1971
1972         if (argc > 3) {
1973                 snp_auth = SNP_AUTH_SEND;
1974                 if (strmatch(argv[idx_type]->text, "validate"))
1975                         snp_auth |= SNP_AUTH_RECV;
1976         }
1977
1978         return area_passwd_set(vty, level, isis_area_passwd_hmac_md5_set,
1979                                argv[idx_word]->arg, snp_auth);
1980 }
1981
1982 DEFUN (domain_passwd_md5,
1983        domain_passwd_md5_cmd,
1984        "domain-password md5 WORD [authenticate snp <send-only|validate>]",
1985        "Set the authentication password for a routing domain\n"
1986        "Authentication type\n"
1987        "Level-wide password\n"
1988        "Authentication\n"
1989        "SNP PDUs\n"
1990        "Send but do not check PDUs on receiving\n"
1991        "Send and check PDUs on receiving\n")
1992 {
1993         return area_passwd_md5(self, vty, argc, argv);
1994 }
1995
1996 DEFUN (area_passwd_clear,
1997        area_passwd_clear_cmd,
1998        "area-password clear WORD [authenticate snp <send-only|validate>]",
1999        "Configure the authentication password for an area\n"
2000        "Authentication type\n"
2001        "Area password\n"
2002        "Authentication\n"
2003        "SNP PDUs\n"
2004        "Send but do not check PDUs on receiving\n"
2005        "Send and check PDUs on receiving\n")
2006 {
2007         int idx_password = 0;
2008         int idx_word = 2;
2009         int idx_type = 5;
2010         uint8_t snp_auth = 0;
2011         int level = strmatch(argv[idx_password]->text, "domain-password")
2012                             ? IS_LEVEL_2
2013                             : IS_LEVEL_1;
2014
2015         if (argc > 3) {
2016                 snp_auth = SNP_AUTH_SEND;
2017                 if (strmatch(argv[idx_type]->text, "validate"))
2018                         snp_auth |= SNP_AUTH_RECV;
2019         }
2020
2021         return area_passwd_set(vty, level, isis_area_passwd_cleartext_set,
2022                                argv[idx_word]->arg, snp_auth);
2023 }
2024
2025 DEFUN (domain_passwd_clear,
2026        domain_passwd_clear_cmd,
2027        "domain-password clear WORD [authenticate snp <send-only|validate>]",
2028        "Set the authentication password for a routing domain\n"
2029        "Authentication type\n"
2030        "Area password\n"
2031        "Authentication\n"
2032        "SNP PDUs\n"
2033        "Send but do not check PDUs on receiving\n"
2034        "Send and check PDUs on receiving\n")
2035 {
2036         return area_passwd_clear(self, vty, argc, argv);
2037 }
2038
2039 DEFUN (no_area_passwd,
2040        no_area_passwd_cmd,
2041        "no <area-password|domain-password>",
2042        NO_STR
2043        "Configure the authentication password for an area\n"
2044        "Set the authentication password for a routing domain\n")
2045 {
2046         int idx_password = 1;
2047         int level = strmatch(argv[idx_password]->text, "domain-password")
2048                             ? IS_LEVEL_2
2049                             : IS_LEVEL_1;
2050         VTY_DECLVAR_CONTEXT(isis_area, area);
2051
2052         return isis_area_passwd_unset(area, level);
2053 }
2054
2055 void isis_vty_init(void)
2056 {
2057         install_element(INTERFACE_NODE, &ip_router_isis_cmd);
2058         install_element(INTERFACE_NODE, &ip6_router_isis_cmd);
2059         install_element(INTERFACE_NODE, &no_ip_router_isis_cmd);
2060
2061         install_element(INTERFACE_NODE, &isis_passive_cmd);
2062         install_element(INTERFACE_NODE, &no_isis_passive_cmd);
2063
2064         install_element(INTERFACE_NODE, &isis_circuit_type_cmd);
2065         install_element(INTERFACE_NODE, &no_isis_circuit_type_cmd);
2066
2067         install_element(INTERFACE_NODE, &isis_network_cmd);
2068         install_element(INTERFACE_NODE, &no_isis_network_cmd);
2069
2070         install_element(INTERFACE_NODE, &isis_passwd_cmd);
2071         install_element(INTERFACE_NODE, &no_isis_passwd_cmd);
2072
2073         install_element(INTERFACE_NODE, &isis_priority_cmd);
2074         install_element(INTERFACE_NODE, &no_isis_priority_cmd);
2075         install_element(INTERFACE_NODE, &isis_priority_l1_cmd);
2076         install_element(INTERFACE_NODE, &no_isis_priority_l1_cmd);
2077         install_element(INTERFACE_NODE, &isis_priority_l2_cmd);
2078         install_element(INTERFACE_NODE, &no_isis_priority_l2_cmd);
2079
2080         install_element(INTERFACE_NODE, &isis_metric_cmd);
2081         install_element(INTERFACE_NODE, &no_isis_metric_cmd);
2082         install_element(INTERFACE_NODE, &isis_metric_l1_cmd);
2083         install_element(INTERFACE_NODE, &no_isis_metric_l1_cmd);
2084         install_element(INTERFACE_NODE, &isis_metric_l2_cmd);
2085         install_element(INTERFACE_NODE, &no_isis_metric_l2_cmd);
2086
2087         install_element(INTERFACE_NODE, &isis_hello_interval_cmd);
2088         install_element(INTERFACE_NODE, &no_isis_hello_interval_cmd);
2089         install_element(INTERFACE_NODE, &isis_hello_interval_l1_cmd);
2090         install_element(INTERFACE_NODE, &no_isis_hello_interval_l1_cmd);
2091         install_element(INTERFACE_NODE, &isis_hello_interval_l2_cmd);
2092         install_element(INTERFACE_NODE, &no_isis_hello_interval_l2_cmd);
2093
2094         install_element(INTERFACE_NODE, &isis_hello_multiplier_cmd);
2095         install_element(INTERFACE_NODE, &no_isis_hello_multiplier_cmd);
2096         install_element(INTERFACE_NODE, &isis_hello_multiplier_l1_cmd);
2097         install_element(INTERFACE_NODE, &no_isis_hello_multiplier_l1_cmd);
2098         install_element(INTERFACE_NODE, &isis_hello_multiplier_l2_cmd);
2099         install_element(INTERFACE_NODE, &no_isis_hello_multiplier_l2_cmd);
2100
2101         install_element(INTERFACE_NODE, &isis_hello_padding_cmd);
2102         install_element(INTERFACE_NODE, &no_isis_hello_padding_cmd);
2103
2104         install_element(INTERFACE_NODE, &isis_threeway_adj_cmd);
2105
2106         install_element(INTERFACE_NODE, &csnp_interval_cmd);
2107         install_element(INTERFACE_NODE, &no_csnp_interval_cmd);
2108         install_element(INTERFACE_NODE, &csnp_interval_l1_cmd);
2109         install_element(INTERFACE_NODE, &no_csnp_interval_l1_cmd);
2110         install_element(INTERFACE_NODE, &csnp_interval_l2_cmd);
2111         install_element(INTERFACE_NODE, &no_csnp_interval_l2_cmd);
2112
2113         install_element(INTERFACE_NODE, &psnp_interval_cmd);
2114         install_element(INTERFACE_NODE, &no_psnp_interval_cmd);
2115         install_element(INTERFACE_NODE, &psnp_interval_l1_cmd);
2116         install_element(INTERFACE_NODE, &no_psnp_interval_l1_cmd);
2117         install_element(INTERFACE_NODE, &psnp_interval_l2_cmd);
2118         install_element(INTERFACE_NODE, &no_psnp_interval_l2_cmd);
2119
2120         install_element(INTERFACE_NODE, &circuit_topology_cmd);
2121         install_element(INTERFACE_NODE, &no_circuit_topology_cmd);
2122
2123         install_element(ISIS_NODE, &metric_style_cmd);
2124         install_element(ISIS_NODE, &no_metric_style_cmd);
2125
2126         install_element(ISIS_NODE, &set_overload_bit_cmd);
2127         install_element(ISIS_NODE, &no_set_overload_bit_cmd);
2128
2129         install_element(ISIS_NODE, &set_attached_bit_cmd);
2130         install_element(ISIS_NODE, &no_set_attached_bit_cmd);
2131
2132         install_element(ISIS_NODE, &dynamic_hostname_cmd);
2133         install_element(ISIS_NODE, &no_dynamic_hostname_cmd);
2134
2135         install_element(ISIS_NODE, &area_lsp_mtu_cmd);
2136         install_element(ISIS_NODE, &no_area_lsp_mtu_cmd);
2137
2138         install_element(ISIS_NODE, &is_type_cmd);
2139         install_element(ISIS_NODE, &no_is_type_cmd);
2140
2141         install_element(ISIS_NODE, &lsp_gen_interval_cmd);
2142         install_element(ISIS_NODE, &no_lsp_gen_interval_cmd);
2143
2144         install_element(ISIS_NODE, &spf_interval_cmd);
2145         install_element(ISIS_NODE, &no_spf_interval_cmd);
2146         install_element(ISIS_NODE, &spf_interval_l1_cmd);
2147         install_element(ISIS_NODE, &no_spf_interval_l1_cmd);
2148         install_element(ISIS_NODE, &spf_interval_l2_cmd);
2149         install_element(ISIS_NODE, &no_spf_interval_l2_cmd);
2150
2151         install_element(ISIS_NODE, &max_lsp_lifetime_cmd);
2152         install_element(ISIS_NODE, &no_max_lsp_lifetime_cmd);
2153
2154         install_element(ISIS_NODE, &lsp_refresh_interval_cmd);
2155         install_element(ISIS_NODE, &no_lsp_refresh_interval_cmd);
2156
2157         install_element(ISIS_NODE, &area_passwd_md5_cmd);
2158         install_element(ISIS_NODE, &area_passwd_clear_cmd);
2159         install_element(ISIS_NODE, &domain_passwd_md5_cmd);
2160         install_element(ISIS_NODE, &domain_passwd_clear_cmd);
2161         install_element(ISIS_NODE, &no_area_passwd_cmd);
2162
2163         install_element(ISIS_NODE, &spf_delay_ietf_cmd);
2164         install_element(ISIS_NODE, &no_spf_delay_ietf_cmd);
2165 }