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