]> git.proxmox.com Git - mirror_frr.git/blob - isisd/isis_adjacency.c
*: remove null check before XFREE
[mirror_frr.git] / isisd / isis_adjacency.c
1 /*
2 * IS-IS Rout(e)ing protocol - isis_adjacency.c
3 * handling of IS-IS adjacencies
4 *
5 * Copyright (C) 2001,2002 Sampo Saaristo
6 * Tampere University of Technology
7 * Institute of Communications Engineering
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 "log.h"
27 #include "memory.h"
28 #include "hash.h"
29 #include "vty.h"
30 #include "linklist.h"
31 #include "thread.h"
32 #include "if.h"
33 #include "stream.h"
34
35 #include "isisd/dict.h"
36 #include "isisd/isis_constants.h"
37 #include "isisd/isis_common.h"
38 #include "isisd/isis_flags.h"
39 #include "isisd/isisd.h"
40 #include "isisd/isis_circuit.h"
41 #include "isisd/isis_adjacency.h"
42 #include "isisd/isis_misc.h"
43 #include "isisd/isis_dr.h"
44 #include "isisd/isis_dynhn.h"
45 #include "isisd/isis_pdu.h"
46 #include "isisd/isis_lsp.h"
47 #include "isisd/isis_spf.h"
48 #include "isisd/isis_events.h"
49 #include "isisd/isis_mt.h"
50 #include "isisd/isis_tlvs.h"
51 #include "isisd/fabricd.h"
52
53 extern struct isis *isis;
54
55 static struct isis_adjacency *adj_alloc(const uint8_t *id)
56 {
57 struct isis_adjacency *adj;
58
59 adj = XCALLOC(MTYPE_ISIS_ADJACENCY, sizeof(struct isis_adjacency));
60 memcpy(adj->sysid, id, ISIS_SYS_ID_LEN);
61
62 return adj;
63 }
64
65 struct isis_adjacency *isis_new_adj(const uint8_t *id, const uint8_t *snpa,
66 int level, struct isis_circuit *circuit)
67 {
68 struct isis_adjacency *adj;
69 int i;
70
71 adj = adj_alloc(id); /* P2P kludge */
72
73 if (snpa) {
74 memcpy(adj->snpa, snpa, ETH_ALEN);
75 } else {
76 memset(adj->snpa, ' ', ETH_ALEN);
77 }
78
79 adj->circuit = circuit;
80 adj->level = level;
81 adj->flaps = 0;
82 adj->last_flap = time(NULL);
83 adj->threeway_state = ISIS_THREEWAY_DOWN;
84 if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
85 listnode_add(circuit->u.bc.adjdb[level - 1], adj);
86 adj->dischanges[level - 1] = 0;
87 for (i = 0; i < DIS_RECORDS;
88 i++) /* clear N DIS state change records */
89 {
90 adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis =
91 ISIS_UNKNOWN_DIS;
92 adj->dis_record[(i * ISIS_LEVELS) + level - 1]
93 .last_dis_change = time(NULL);
94 }
95 }
96
97 return adj;
98 }
99
100 struct isis_adjacency *isis_adj_lookup(const uint8_t *sysid, struct list *adjdb)
101 {
102 struct isis_adjacency *adj;
103 struct listnode *node;
104
105 for (ALL_LIST_ELEMENTS_RO(adjdb, node, adj))
106 if (memcmp(adj->sysid, sysid, ISIS_SYS_ID_LEN) == 0)
107 return adj;
108
109 return NULL;
110 }
111
112 struct isis_adjacency *isis_adj_lookup_snpa(const uint8_t *ssnpa,
113 struct list *adjdb)
114 {
115 struct listnode *node;
116 struct isis_adjacency *adj;
117
118 for (ALL_LIST_ELEMENTS_RO(adjdb, node, adj))
119 if (memcmp(adj->snpa, ssnpa, ETH_ALEN) == 0)
120 return adj;
121
122 return NULL;
123 }
124
125 DEFINE_HOOK(isis_adj_state_change_hook, (struct isis_adjacency *adj), (adj))
126
127 void isis_delete_adj(void *arg)
128 {
129 struct isis_adjacency *adj = arg;
130
131 if (!adj)
132 return;
133
134 THREAD_TIMER_OFF(adj->t_expire);
135 if (adj->adj_state != ISIS_ADJ_DOWN) {
136 adj->adj_state = ISIS_ADJ_DOWN;
137 hook_call(isis_adj_state_change_hook, adj);
138 }
139
140 /* remove from SPF trees */
141 spftree_area_adj_del(adj->circuit->area, adj);
142
143 XFREE(MTYPE_ISIS_ADJACENCY_INFO, adj->area_addresses);
144 XFREE(MTYPE_ISIS_ADJACENCY_INFO, adj->ipv4_addresses);
145 XFREE(MTYPE_ISIS_ADJACENCY_INFO, adj->ipv6_addresses);
146
147 adj_mt_finish(adj);
148
149 XFREE(MTYPE_ISIS_ADJACENCY, adj);
150 return;
151 }
152
153 static const char *adj_state2string(int state)
154 {
155
156 switch (state) {
157 case ISIS_ADJ_INITIALIZING:
158 return "Initializing";
159 case ISIS_ADJ_UP:
160 return "Up";
161 case ISIS_ADJ_DOWN:
162 return "Down";
163 default:
164 return "Unknown";
165 }
166
167 return NULL; /* not reached */
168 }
169
170 void isis_adj_process_threeway(struct isis_adjacency *adj,
171 struct isis_threeway_adj *tw_adj,
172 enum isis_adj_usage adj_usage)
173 {
174 enum isis_threeway_state next_tw_state = ISIS_THREEWAY_DOWN;
175
176 if (tw_adj && !adj->circuit->disable_threeway_adj) {
177 if (tw_adj->state == ISIS_THREEWAY_DOWN) {
178 next_tw_state = ISIS_THREEWAY_INITIALIZING;
179 } else if (tw_adj->state == ISIS_THREEWAY_INITIALIZING) {
180 next_tw_state = ISIS_THREEWAY_UP;
181 } else if (tw_adj->state == ISIS_THREEWAY_UP) {
182 if (adj->threeway_state == ISIS_THREEWAY_DOWN)
183 next_tw_state = ISIS_THREEWAY_DOWN;
184 else
185 next_tw_state = ISIS_THREEWAY_UP;
186 }
187 } else {
188 next_tw_state = ISIS_THREEWAY_UP;
189 }
190
191 if (next_tw_state != adj->threeway_state) {
192 if (isis->debugs & DEBUG_ADJ_PACKETS) {
193 zlog_info("ISIS-Adj (%s): Threeway state change %s to %s",
194 adj->circuit->area->area_tag,
195 isis_threeway_state_name(adj->threeway_state),
196 isis_threeway_state_name(next_tw_state));
197 }
198 }
199
200 if (next_tw_state != ISIS_THREEWAY_DOWN)
201 fabricd_initial_sync_hello(adj->circuit);
202
203 if (next_tw_state == ISIS_THREEWAY_DOWN) {
204 isis_adj_state_change(adj, ISIS_ADJ_DOWN, "Neighbor restarted");
205 return;
206 }
207
208 if (next_tw_state == ISIS_THREEWAY_UP) {
209 if (adj->adj_state != ISIS_ADJ_UP) {
210 isis_adj_state_change(adj, ISIS_ADJ_UP, NULL);
211 adj->adj_usage = adj_usage;
212 }
213 }
214
215 if (adj->threeway_state != next_tw_state) {
216 send_hello_sched(adj->circuit, 0, TRIGGERED_IIH_DELAY);
217 }
218
219 adj->threeway_state = next_tw_state;
220 }
221
222 void isis_adj_state_change(struct isis_adjacency *adj,
223 enum isis_adj_state new_state, const char *reason)
224 {
225 enum isis_adj_state old_state = adj->adj_state;
226 struct isis_circuit *circuit = adj->circuit;
227 bool del;
228
229 adj->adj_state = new_state;
230 if (new_state != old_state) {
231 send_hello_sched(circuit, adj->level, TRIGGERED_IIH_DELAY);
232 }
233
234 if (isis->debugs & DEBUG_ADJ_PACKETS) {
235 zlog_debug("ISIS-Adj (%s): Adjacency state change %d->%d: %s",
236 circuit->area->area_tag, old_state, new_state,
237 reason ? reason : "unspecified");
238 }
239
240 if (circuit->area->log_adj_changes) {
241 const char *adj_name;
242 struct isis_dynhn *dyn;
243
244 dyn = dynhn_find_by_id(adj->sysid);
245 if (dyn)
246 adj_name = dyn->hostname;
247 else
248 adj_name = sysid_print(adj->sysid);
249
250 zlog_info(
251 "%%ADJCHANGE: Adjacency to %s (%s) changed from %s to %s, %s",
252 adj_name, adj->circuit->interface->name,
253 adj_state2string(old_state),
254 adj_state2string(new_state),
255 reason ? reason : "unspecified");
256 }
257
258 #ifndef FABRICD
259 /* send northbound notification */
260 isis_notif_adj_state_change(adj, new_state, reason);
261 #endif /* ifndef FABRICD */
262
263 if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
264 del = false;
265 for (int level = IS_LEVEL_1; level <= IS_LEVEL_2; level++) {
266 if ((adj->level & level) == 0)
267 continue;
268 if (new_state == ISIS_ADJ_UP) {
269 circuit->upadjcount[level - 1]++;
270 hook_call(isis_adj_state_change_hook, adj);
271 /* update counter & timers for debugging
272 * purposes */
273 adj->last_flap = time(NULL);
274 adj->flaps++;
275 } else if (new_state == ISIS_ADJ_DOWN) {
276 listnode_delete(circuit->u.bc.adjdb[level - 1],
277 adj);
278
279 circuit->upadjcount[level - 1]--;
280 if (circuit->upadjcount[level - 1] == 0)
281 isis_tx_queue_clean(circuit->tx_queue);
282
283 hook_call(isis_adj_state_change_hook, adj);
284 del = true;
285 }
286
287 if (circuit->u.bc.lan_neighs[level - 1]) {
288 list_delete_all_node(
289 circuit->u.bc.lan_neighs[level - 1]);
290 isis_adj_build_neigh_list(
291 circuit->u.bc.adjdb[level - 1],
292 circuit->u.bc.lan_neighs[level - 1]);
293 }
294
295 /* On adjacency state change send new pseudo LSP if we
296 * are the DR */
297 if (circuit->u.bc.is_dr[level - 1])
298 lsp_regenerate_schedule_pseudo(circuit, level);
299 }
300
301 if (del)
302 isis_delete_adj(adj);
303
304 } else if (circuit->circ_type == CIRCUIT_T_P2P) {
305 del = false;
306 for (int level = IS_LEVEL_1; level <= IS_LEVEL_2; level++) {
307 if ((adj->level & level) == 0)
308 continue;
309 if (new_state == ISIS_ADJ_UP) {
310 circuit->upadjcount[level - 1]++;
311 hook_call(isis_adj_state_change_hook, adj);
312
313 /* update counter & timers for debugging
314 * purposes */
315 adj->last_flap = time(NULL);
316 adj->flaps++;
317
318 if (level == IS_LEVEL_1) {
319 thread_add_timer(master, send_l1_csnp,
320 circuit, 0,
321 &circuit->t_send_csnp[0]);
322 } else {
323 thread_add_timer(master, send_l2_csnp,
324 circuit, 0,
325 &circuit->t_send_csnp[1]);
326 }
327 } else if (new_state == ISIS_ADJ_DOWN) {
328 if (adj->circuit->u.p2p.neighbor == adj)
329 adj->circuit->u.p2p.neighbor = NULL;
330 circuit->upadjcount[level - 1]--;
331 if (circuit->upadjcount[level - 1] == 0)
332 isis_tx_queue_clean(circuit->tx_queue);
333
334 hook_call(isis_adj_state_change_hook, adj);
335 del = true;
336 }
337 }
338
339 if (del)
340 isis_delete_adj(adj);
341 }
342 }
343
344
345 void isis_adj_print(struct isis_adjacency *adj)
346 {
347 struct isis_dynhn *dyn;
348
349 if (!adj)
350 return;
351 dyn = dynhn_find_by_id(adj->sysid);
352 if (dyn)
353 zlog_debug("%s", dyn->hostname);
354
355 zlog_debug("SystemId %20s SNPA %s, level %d\nHolding Time %d",
356 sysid_print(adj->sysid), snpa_print(adj->snpa), adj->level,
357 adj->hold_time);
358 if (adj->ipv4_address_count) {
359 zlog_debug("IPv4 Address(es):");
360 for (unsigned int i = 0; i < adj->ipv4_address_count; i++)
361 zlog_debug("%s", inet_ntoa(adj->ipv4_addresses[i]));
362 }
363
364 if (adj->ipv6_address_count) {
365 zlog_debug("IPv6 Address(es):");
366 for (unsigned int i = 0; i < adj->ipv6_address_count; i++) {
367 char buf[INET6_ADDRSTRLEN];
368 inet_ntop(AF_INET6, &adj->ipv6_addresses[i], buf,
369 sizeof(buf));
370 zlog_debug("%s", buf);
371 }
372 }
373 zlog_debug("Speaks: %s", nlpid2string(&adj->nlpids));
374
375 return;
376 }
377
378 int isis_adj_expire(struct thread *thread)
379 {
380 struct isis_adjacency *adj;
381
382 /*
383 * Get the adjacency
384 */
385 adj = THREAD_ARG(thread);
386 assert(adj);
387 adj->t_expire = NULL;
388
389 /* trigger the adj expire event */
390 isis_adj_state_change(adj, ISIS_ADJ_DOWN, "holding time expired");
391
392 return 0;
393 }
394
395 /*
396 * show isis neighbor [detail]
397 */
398 void isis_adj_print_vty(struct isis_adjacency *adj, struct vty *vty,
399 char detail)
400 {
401 time_t now;
402 struct isis_dynhn *dyn;
403 int level;
404
405 dyn = dynhn_find_by_id(adj->sysid);
406 if (dyn)
407 vty_out(vty, " %-20s", dyn->hostname);
408 else
409 vty_out(vty, " %-20s", sysid_print(adj->sysid));
410
411 if (detail == ISIS_UI_LEVEL_BRIEF) {
412 if (adj->circuit)
413 vty_out(vty, "%-12s", adj->circuit->interface->name);
414 else
415 vty_out(vty, "NULL circuit!");
416 vty_out(vty, "%-3u", adj->level); /* level */
417 vty_out(vty, "%-13s", adj_state2string(adj->adj_state));
418 now = time(NULL);
419 if (adj->last_upd)
420 vty_out(vty, "%-9llu",
421 (unsigned long long)adj->last_upd
422 + adj->hold_time - now);
423 else
424 vty_out(vty, "- ");
425 vty_out(vty, "%-10s", snpa_print(adj->snpa));
426 vty_out(vty, "\n");
427 }
428
429 if (detail == ISIS_UI_LEVEL_DETAIL) {
430 level = adj->level;
431 vty_out(vty, "\n");
432 if (adj->circuit)
433 vty_out(vty, " Interface: %s",
434 adj->circuit->interface->name);
435 else
436 vty_out(vty, " Interface: NULL circuit");
437 vty_out(vty, ", Level: %u", adj->level); /* level */
438 vty_out(vty, ", State: %s", adj_state2string(adj->adj_state));
439 now = time(NULL);
440 if (adj->last_upd)
441 vty_out(vty, ", Expires in %s",
442 time2string(adj->last_upd + adj->hold_time
443 - now));
444 else
445 vty_out(vty, ", Expires in %s",
446 time2string(adj->hold_time));
447 vty_out(vty, "\n");
448 vty_out(vty, " Adjacency flaps: %u", adj->flaps);
449 vty_out(vty, ", Last: %s ago",
450 time2string(now - adj->last_flap));
451 vty_out(vty, "\n");
452 vty_out(vty, " Circuit type: %s",
453 circuit_t2string(adj->circuit_t));
454 vty_out(vty, ", Speaks: %s", nlpid2string(&adj->nlpids));
455 vty_out(vty, "\n");
456 if (adj->mt_count != 1
457 || adj->mt_set[0] != ISIS_MT_IPV4_UNICAST) {
458 vty_out(vty, " Topologies:\n");
459 for (unsigned int i = 0; i < adj->mt_count; i++)
460 vty_out(vty, " %s\n",
461 isis_mtid2str(adj->mt_set[i]));
462 }
463 vty_out(vty, " SNPA: %s", snpa_print(adj->snpa));
464 if (adj->circuit
465 && (adj->circuit->circ_type == CIRCUIT_T_BROADCAST)) {
466 dyn = dynhn_find_by_id(adj->lanid);
467 if (dyn)
468 vty_out(vty, ", LAN id: %s.%02x", dyn->hostname,
469 adj->lanid[ISIS_SYS_ID_LEN]);
470 else
471 vty_out(vty, ", LAN id: %s.%02x",
472 sysid_print(adj->lanid),
473 adj->lanid[ISIS_SYS_ID_LEN]);
474
475 vty_out(vty, "\n");
476 vty_out(vty, " LAN Priority: %u",
477 adj->prio[adj->level - 1]);
478
479 vty_out(vty, ", %s, DIS flaps: %u, Last: %s ago",
480 isis_disflag2string(
481 adj->dis_record[ISIS_LEVELS + level - 1]
482 .dis),
483 adj->dischanges[level - 1],
484 time2string(now - (adj->dis_record[ISIS_LEVELS
485 + level - 1]
486 .last_dis_change)));
487 }
488 vty_out(vty, "\n");
489
490 if (adj->area_address_count) {
491 vty_out(vty, " Area Address(es):\n");
492 for (unsigned int i = 0; i < adj->area_address_count;
493 i++) {
494 vty_out(vty, " %s\n",
495 isonet_print(adj->area_addresses[i]
496 .area_addr,
497 adj->area_addresses[i]
498 .addr_len));
499 }
500 }
501 if (adj->ipv4_address_count) {
502 vty_out(vty, " IPv4 Address(es):\n");
503 for (unsigned int i = 0; i < adj->ipv4_address_count;
504 i++)
505 vty_out(vty, " %s\n",
506 inet_ntoa(adj->ipv4_addresses[i]));
507 }
508 if (adj->ipv6_address_count) {
509 vty_out(vty, " IPv6 Address(es):\n");
510 for (unsigned int i = 0; i < adj->ipv6_address_count;
511 i++) {
512 char buf[INET6_ADDRSTRLEN];
513 inet_ntop(AF_INET6, &adj->ipv6_addresses[i],
514 buf, sizeof(buf));
515 vty_out(vty, " %s\n", buf);
516 }
517 }
518 vty_out(vty, "\n");
519 }
520 return;
521 }
522
523 void isis_adj_build_neigh_list(struct list *adjdb, struct list *list)
524 {
525 struct isis_adjacency *adj;
526 struct listnode *node;
527
528 if (!list) {
529 zlog_warn("isis_adj_build_neigh_list(): NULL list");
530 return;
531 }
532
533 for (ALL_LIST_ELEMENTS_RO(adjdb, node, adj)) {
534 if (!adj) {
535 zlog_warn("isis_adj_build_neigh_list(): NULL adj");
536 return;
537 }
538
539 if ((adj->adj_state == ISIS_ADJ_UP
540 || adj->adj_state == ISIS_ADJ_INITIALIZING))
541 listnode_add(list, adj->snpa);
542 }
543 return;
544 }
545
546 void isis_adj_build_up_list(struct list *adjdb, struct list *list)
547 {
548 struct isis_adjacency *adj;
549 struct listnode *node;
550
551 if (adjdb == NULL) {
552 zlog_warn("isis_adj_build_up_list(): adjacency DB is empty");
553 return;
554 }
555
556 if (!list) {
557 zlog_warn("isis_adj_build_up_list(): NULL list");
558 return;
559 }
560
561 for (ALL_LIST_ELEMENTS_RO(adjdb, node, adj)) {
562 if (!adj) {
563 zlog_warn("isis_adj_build_up_list(): NULL adj");
564 return;
565 }
566
567 if (adj->adj_state == ISIS_ADJ_UP)
568 listnode_add(list, adj);
569 }
570
571 return;
572 }
573
574 int isis_adj_usage2levels(enum isis_adj_usage usage)
575 {
576 switch (usage) {
577 case ISIS_ADJ_LEVEL1:
578 return IS_LEVEL_1;
579 case ISIS_ADJ_LEVEL2:
580 return IS_LEVEL_2;
581 case ISIS_ADJ_LEVEL1AND2:
582 return IS_LEVEL_1 | IS_LEVEL_2;
583 default:
584 break;
585 }
586 return 0;
587 }