?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ospfd: Tighten up the connected check for redistribution
[jleu-quagga.git] / isisd / isis_pdu.c
blob4311a9057f2507185b097bc95ab2200bee7599d8
1 /*
2 * IS-IS Rout(e)ing protocol - isis_pdu.c
3 * PDU processing
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; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 */
23
24 #include <zebra.h>
25
26 #include "memory.h"
27 #include "thread.h"
28 #include "linklist.h"
29 #include "log.h"
30 #include "stream.h"
31 #include "vty.h"
32 #include "hash.c"
33 #include "prefix.h"
34 #include "if.h"
35 #include "checksum.h"
36
37 #include "isisd/dict.h"
38 #include "isisd/include-netbsd/iso.h"
39 #include "isisd/isis_constants.h"
40 #include "isisd/isis_common.h"
41 #include "isisd/isis_adjacency.h"
42 #include "isisd/isis_circuit.h"
43 #include "isisd/isis_network.h"
44 #include "isisd/isis_misc.h"
45 #include "isisd/isis_dr.h"
46 #include "isisd/isis_flags.h"
47 #include "isisd/isis_tlv.h"
48 #include "isisd/isisd.h"
49 #include "isisd/isis_dynhn.h"
50 #include "isisd/isis_lsp.h"
51 #include "isisd/isis_pdu.h"
52 #include "isisd/iso_checksum.h"
53 #include "isisd/isis_csm.h"
54 #include "isisd/isis_events.h"
55
56 extern struct thread_master *master;
57 extern struct isis *isis;
58
59 #define ISIS_MINIMUM_FIXED_HDR_LEN 15
60 #define ISIS_MIN_PDU_LEN 13 /* partial seqnum pdu with id_len=2 */
61
62 #ifndef PNBBY
63 #define PNBBY 8
64 #endif /* PNBBY */
65
66 /* Utility mask array. */
67 static u_char maskbit[] = {
68 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff
69 };
70
71 /*
72 * HELPER FUNCS
73 */
74
75 /*
76 * Compares two sets of area addresses
77 */
78 static int
79 area_match (struct list *left, struct list *right)
80 {
81 struct area_addr *addr1, *addr2;
82 struct listnode *node1, *node2;
83
84 for (ALL_LIST_ELEMENTS_RO (left, node1, addr1))
85 {
86 for (ALL_LIST_ELEMENTS_RO (right, node2, addr2))
87 {
88 if (addr1->addr_len == addr2->addr_len &&
89 !memcmp (addr1->area_addr, addr2->area_addr, (int) addr1->addr_len))
90 return 1; /* match */
91 }
92 }
93
94 return 0; /* mismatch */
95 }
96
97 /*
98 * Check if ip2 is in the ip1's network (function like Prefix.h:prefix_match() )
99 * param ip1 the IS interface ip address structure
100 * param ip2 the IIH's ip address
101 * return 0 the IIH's IP is not in the IS's subnetwork
102 * 1 the IIH's IP is in the IS's subnetwork
103 */
104 static int
105 ip_same_subnet (struct prefix_ipv4 *ip1, struct in_addr *ip2)
106 {
107 u_char *addr1, *addr2;
108 int shift, offset, offsetloop;
109 int len;
110
111 addr1 = (u_char *) & ip1->prefix.s_addr;
112 addr2 = (u_char *) & ip2->s_addr;
113 len = ip1->prefixlen;
114
115 shift = len % PNBBY;
116 offsetloop = offset = len / PNBBY;
117
118 while (offsetloop--)
119 if (addr1[offsetloop] != addr2[offsetloop])
120 return 0;
121
122 if (shift)
123 if (maskbit[shift] & (addr1[offset] ^ addr2[offset]))
124 return 0;
125
126 return 1; /* match */
127 }
128
129 /*
130 * Compares two set of ip addresses
131 * param left the local interface's ip addresses
132 * param right the iih interface's ip address
133 * return 0 no match;
134 * 1 match;
135 */
136 static int
137 ip_match (struct list *left, struct list *right)
138 {
139 struct prefix_ipv4 *ip1;
140 struct in_addr *ip2;
141 struct listnode *node1, *node2;
142
143 if ((left == NULL) || (right == NULL))
144 return 0;
145
146 for (ALL_LIST_ELEMENTS_RO (left, node1, ip1))
147 {
148 for (ALL_LIST_ELEMENTS_RO (right, node2, ip2))
149 {
150 if (ip_same_subnet (ip1, ip2))
151 {
152 return 1; /* match */
153 }
154 }
155
156 }
157 return 0;
158 }
159
160 /*
161 * Checks whether we should accept a PDU of given level
162 */
163 static int
164 accept_level (int level, int circuit_t)
165 {
166 int retval = ((circuit_t & level) == level); /* simple approach */
167
168 return retval;
169 }
170
171 int
172 authentication_check (struct isis_passwd *one, struct isis_passwd *theother)
173 {
174 if (one->type != theother->type)
175 {
176 zlog_warn ("Unsupported authentication type %d", theother->type);
177 return 1; /* Auth fail (different authentication types) */
178 }
179 switch (one->type)
180 {
181 case ISIS_PASSWD_TYPE_CLEARTXT:
182 if (one->len != theother->len)
183 return 1; /* Auth fail () - passwd len mismatch */
184 return memcmp (one->passwd, theother->passwd, one->len);
185 break;
186 default:
187 zlog_warn ("Unsupported authentication type");
188 break;
189 }
190 return 0; /* Auth pass */
191 }
192
193 /*
194 * Processing helper functions
195 */
196 static void
197 tlvs_to_adj_nlpids (struct tlvs *tlvs, struct isis_adjacency *adj)
198 {
199 int i;
200 struct nlpids *tlv_nlpids;
201
202 if (tlvs->nlpids)
203 {
204
205 tlv_nlpids = tlvs->nlpids;
206
207 adj->nlpids.count = tlv_nlpids->count;
208
209 for (i = 0; i < tlv_nlpids->count; i++)
210 {
211 adj->nlpids.nlpids[i] = tlv_nlpids->nlpids[i];
212 }
213 }
214 }
215
216 static void
217 del_ip_addr (void *val)
218 {
219 XFREE (MTYPE_ISIS_TMP, val);
220 }
221
222 static void
223 tlvs_to_adj_ipv4_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
224 {
225 struct listnode *node;
226 struct in_addr *ipv4_addr, *malloced;
227
228 if (adj->ipv4_addrs)
229 {
230 adj->ipv4_addrs->del = del_ip_addr;
231 list_delete (adj->ipv4_addrs);
232 }
233 adj->ipv4_addrs = list_new ();
234 if (tlvs->ipv4_addrs)
235 {
236 for (ALL_LIST_ELEMENTS_RO (tlvs->ipv4_addrs, node, ipv4_addr))
237 {
238 malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in_addr));
239 memcpy (malloced, ipv4_addr, sizeof (struct in_addr));
240 listnode_add (adj->ipv4_addrs, malloced);
241 }
242 }
243 }
244
245 #ifdef HAVE_IPV6
246 static void
247 tlvs_to_adj_ipv6_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
248 {
249 struct listnode *node;
250 struct in6_addr *ipv6_addr, *malloced;
251
252 if (adj->ipv6_addrs)
253 {
254 adj->ipv6_addrs->del = del_ip_addr;
255 list_delete (adj->ipv6_addrs);
256 }
257 adj->ipv6_addrs = list_new ();
258 if (tlvs->ipv6_addrs)
259 {
260 for (ALL_LIST_ELEMENTS_RO (tlvs->ipv6_addrs, node, ipv6_addr))
261 {
262 malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in6_addr));
263 memcpy (malloced, ipv6_addr, sizeof (struct in6_addr));
264 listnode_add (adj->ipv6_addrs, malloced);
265 }
266 }
267
268 }
269 #endif /* HAVE_IPV6 */
270
271 /*
272 * RECEIVE SIDE
273 */
274
275 /*
276 * Process P2P IIH
277 * ISO - 10589
278 * Section 8.2.5 - Receiving point-to-point IIH PDUs
279 *
280 */
281 static int
282 process_p2p_hello (struct isis_circuit *circuit)
283 {
284 int retval = ISIS_OK;
285 struct isis_p2p_hello_hdr *hdr;
286 struct isis_adjacency *adj;
287 u_int32_t expected = 0, found;
288 struct tlvs tlvs;
289
290 if ((stream_get_endp (circuit->rcv_stream) -
291 stream_get_getp (circuit->rcv_stream)) < ISIS_P2PHELLO_HDRLEN)
292 {
293 zlog_warn ("Packet too short");
294 return ISIS_WARNING;
295 }
296
297 /* 8.2.5.1 PDU acceptance tests */
298
299 /* 8.2.5.1 a) external domain untrue */
300 /* FIXME: not useful at all? */
301
302 /* 8.2.5.1 b) ID Length mismatch */
303 /* checked at the handle_pdu */
304
305 /* 8.2.5.2 IIH PDU Processing */
306
307 /* 8.2.5.2 a) 1) Maximum Area Addresses */
308 /* Already checked, and can also be ommited */
309
310 /*
311 * Get the header
312 */
313 hdr = (struct isis_p2p_hello_hdr *) STREAM_PNT (circuit->rcv_stream);
314 circuit->rcv_stream->getp += ISIS_P2PHELLO_HDRLEN;
315
316 /* hdr.circuit_t = stream_getc (stream);
317 stream_get (hdr.source_id, stream, ISIS_SYS_ID_LEN);
318 hdr.hold_time = stream_getw (stream);
319 hdr.pdu_len = stream_getw (stream);
320 hdr.local_id = stream_getc (stream); */
321
322 /*
323 * My interpertation of the ISO, if no adj exists we will create one for
324 * the circuit
325 */
326
327 if (isis->debugs & DEBUG_ADJ_PACKETS)
328 {
329 zlog_debug ("ISIS-Adj (%s): Rcvd P2P IIH from (%s), cir type %s,"
330 " cir id %02d, length %d",
331 circuit->area->area_tag, circuit->interface->name,
332 circuit_t2string (circuit->circuit_is_type),
333 circuit->circuit_id, ntohs (hdr->pdu_len));
334 }
335
336 adj = circuit->u.p2p.neighbor;
337 if (!adj)
338 {
339 adj = isis_new_adj (hdr->source_id, NULL, 0, circuit);
340 if (adj == NULL)
341 return ISIS_ERROR;
342 circuit->u.p2p.neighbor = adj;
343 isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
344 adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
345 }
346
347 /* 8.2.6 Monitoring point-to-point adjacencies */
348 adj->hold_time = ntohs (hdr->hold_time);
349 adj->last_upd = time (NULL);
350
351 /*
352 * Lets get the TLVS now
353 */
354 expected |= TLVFLAG_AREA_ADDRS;
355 expected |= TLVFLAG_AUTH_INFO;
356 expected |= TLVFLAG_NLPID;
357 expected |= TLVFLAG_IPV4_ADDR;
358 expected |= TLVFLAG_IPV6_ADDR;
359
360 retval = parse_tlvs (circuit->area->area_tag,
361 STREAM_PNT (circuit->rcv_stream),
362 ntohs (hdr->pdu_len) - ISIS_P2PHELLO_HDRLEN
363 - ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs);
364
365 if (retval > ISIS_WARNING)
366 {
367 free_tlvs (&tlvs);
368 return retval;
369 };
370
371 /* 8.2.5.1 c) Authentication */
372 if (circuit->passwd.type)
373 {
374 if (!(found & TLVFLAG_AUTH_INFO) ||
375 authentication_check (&circuit->passwd, &tlvs.auth_info))
376 {
377 isis_event_auth_failure (circuit->area->area_tag,
378 "P2P hello authentication failure",
379 hdr->source_id);
380 return ISIS_OK;
381 }
382 }
383
384 /* we do this now because the adj may not survive till the end... */
385
386 /* we need to copy addresses to the adj */
387 tlvs_to_adj_ipv4_addrs (&tlvs, adj);
388
389 #ifdef HAVE_IPV6
390 tlvs_to_adj_ipv6_addrs (&tlvs, adj);
391 #endif /* HAVE_IPV6 */
392
393 /* lets take care of the expiry */
394 THREAD_TIMER_OFF (adj->t_expire);
395 THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
396 (long) adj->hold_time);
397
398 /* 8.2.5.2 a) a match was detected */
399 if (area_match (circuit->area->area_addrs, tlvs.area_addrs))
400 {
401 /* 8.2.5.2 a) 2) If the system is L1 - table 5 */
402 if (circuit->area->is_type == IS_LEVEL_1)
403 {
404 switch (hdr->circuit_t)
405 {
406 case IS_LEVEL_1:
407 case IS_LEVEL_1_AND_2:
408 if (adj->adj_state != ISIS_ADJ_UP)
409 {
410 /* (4) adj state up */
411 isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
412 /* (5) adj usage level 1 */
413 adj->adj_usage = ISIS_ADJ_LEVEL1;
414 }
415 else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
416 {
417 ; /* accept */
418 }
419 break;
420 case IS_LEVEL_2:
421 if (adj->adj_state != ISIS_ADJ_UP)
422 {
423 /* (7) reject - wrong system type event */
424 zlog_warn ("wrongSystemType");
425 return ISIS_WARNING; /* Reject */
426 }
427 else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
428 {
429 /* (6) down - wrong system */
430 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
431 }
432 break;
433 }
434 }
435
436 /* 8.2.5.2 a) 3) If the system is L1L2 - table 6 */
437 if (circuit->area->is_type == IS_LEVEL_1_AND_2)
438 {
439 switch (hdr->circuit_t)
440 {
441 case IS_LEVEL_1:
442 if (adj->adj_state != ISIS_ADJ_UP)
443 {
444 /* (6) adj state up */
445 isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
446 /* (7) adj usage level 1 */
447 adj->adj_usage = ISIS_ADJ_LEVEL1;
448 }
449 else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
450 {
451 ; /* accept */
452 }
453 else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
454 (adj->adj_usage == ISIS_ADJ_LEVEL2))
455 {
456 /* (8) down - wrong system */
457 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
458 }
459 break;
460 case IS_LEVEL_2:
461 if (adj->adj_state != ISIS_ADJ_UP)
462 {
463 /* (6) adj state up */
464 isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
465 /* (9) adj usage level 2 */
466 adj->adj_usage = ISIS_ADJ_LEVEL2;
467 }
468 else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
469 (adj->adj_usage == ISIS_ADJ_LEVEL1AND2))
470 {
471 /* (8) down - wrong system */
472 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
473 }
474 else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
475 {
476 ; /* Accept */
477 }
478 break;
479 case IS_LEVEL_1_AND_2:
480 if (adj->adj_state != ISIS_ADJ_UP)
481 {
482 /* (6) adj state up */
483 isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
484 /* (10) adj usage level 1 */
485 adj->adj_usage = ISIS_ADJ_LEVEL1AND2;
486 }
487 else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
488 (adj->adj_usage == ISIS_ADJ_LEVEL2))
489 {
490 /* (8) down - wrong system */
491 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
492 }
493 else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
494 {
495 ; /* Accept */
496 }
497 break;
498 }
499 }
500
501 /* 8.2.5.2 a) 4) If the system is L2 - table 7 */
502 if (circuit->area->is_type == IS_LEVEL_2)
503 {
504 switch (hdr->circuit_t)
505 {
506 case IS_LEVEL_1:
507 if (adj->adj_state != ISIS_ADJ_UP)
508 {
509 /* (5) reject - wrong system type event */
510 zlog_warn ("wrongSystemType");
511 return ISIS_WARNING; /* Reject */
512 }
513 else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
514 (adj->adj_usage == ISIS_ADJ_LEVEL2))
515 {
516 /* (6) down - wrong system */
517 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
518 }
519 break;
520 case IS_LEVEL_1_AND_2:
521 case IS_LEVEL_2:
522 if (adj->adj_state != ISIS_ADJ_UP)
523 {
524 /* (7) adj state up */
525 isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
526 /* (8) adj usage level 2 */
527 adj->adj_usage = ISIS_ADJ_LEVEL2;
528 }
529 else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
530 {
531 /* (6) down - wrong system */
532 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
533 }
534 else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
535 {
536 ; /* Accept */
537 }
538 break;
539 }
540 }
541 }
542 /* 8.2.5.2 b) if no match was detected */
543 else
544 {
545 if (circuit->area->is_type == IS_LEVEL_1)
546 {
547 /* 8.2.5.2 b) 1) is_type L1 and adj is not up */
548 if (adj->adj_state != ISIS_ADJ_UP)
549 {
550 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
551 /* 8.2.5.2 b) 2)is_type L1 and adj is up */
552 }
553 else
554 {
555 isis_adj_state_change (adj, ISIS_ADJ_DOWN,
556 "Down - Area Mismatch");
557 }
558 }
559 /* 8.2.5.2 b 3 If the system is L2 or L1L2 - table 8 */
560 else
561 {
562 switch (hdr->circuit_t)
563 {
564 case IS_LEVEL_1:
565 if (adj->adj_state != ISIS_ADJ_UP)
566 {
567 /* (6) reject - Area Mismatch event */
568 zlog_warn ("AreaMismatch");
569 return ISIS_WARNING; /* Reject */
570 }
571 else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
572 {
573 /* (7) down - area mismatch */
574 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
575
576 }
577 else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
578 (adj->adj_usage == ISIS_ADJ_LEVEL2))
579 {
580 /* (7) down - wrong system */
581 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
582 }
583 break;
584 case IS_LEVEL_1_AND_2:
585 case IS_LEVEL_2:
586 if (adj->adj_state != ISIS_ADJ_UP)
587 {
588 /* (8) adj state up */
589 isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
590 /* (9) adj usage level 2 */
591 adj->adj_usage = ISIS_ADJ_LEVEL2;
592 }
593 else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
594 {
595 /* (7) down - wrong system */
596 isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
597 }
598 else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
599 {
600 if (hdr->circuit_t == IS_LEVEL_2)
601 {
602 /* (7) down - wrong system */
603 isis_adj_state_change (adj, ISIS_ADJ_DOWN,
604 "Wrong System");
605 }
606 else
607 {
608 /* (7) down - area mismatch */
609 isis_adj_state_change (adj, ISIS_ADJ_DOWN,
610 "Area Mismatch");
611 }
612 }
613 else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
614 {
615 ; /* Accept */
616 }
617 break;
618 }
619 }
620 }
621 /* 8.2.5.2 c) if the action was up - comparing circuit IDs */
622 /* FIXME - Missing parts */
623
624 /* some of my own understanding of the ISO, why the heck does
625 * it not say what should I change the system_type to...
626 */
627 switch (adj->adj_usage)
628 {
629 case ISIS_ADJ_LEVEL1:
630 adj->sys_type = ISIS_SYSTYPE_L1_IS;
631 break;
632 case ISIS_ADJ_LEVEL2:
633 adj->sys_type = ISIS_SYSTYPE_L2_IS;
634 break;
635 case ISIS_ADJ_LEVEL1AND2:
636 adj->sys_type = ISIS_SYSTYPE_L2_IS;
637 break;
638 case ISIS_ADJ_NONE:
639 adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
640 break;
641 }
642
643 adj->circuit_t = hdr->circuit_t;
644 adj->level = hdr->circuit_t;
645
646 free_tlvs (&tlvs);
647
648 return retval;
649 }
650
651 /*
652 * Process IS-IS LAN Level 1/2 Hello PDU
653 */
654 static int
655 process_lan_hello (int level, struct isis_circuit *circuit, u_char * ssnpa)
656 {
657 int retval = ISIS_OK;
658 struct isis_lan_hello_hdr hdr;
659 struct isis_adjacency *adj;
660 u_int32_t expected = 0, found;
661 struct tlvs tlvs;
662 u_char *snpa;
663 struct listnode *node;
664
665 if ((stream_get_endp (circuit->rcv_stream) -
666 stream_get_getp (circuit->rcv_stream)) < ISIS_LANHELLO_HDRLEN)
667 {
668 zlog_warn ("Packet too short");
669 return ISIS_WARNING;
670 }
671
672 if (circuit->ext_domain)
673 {
674 zlog_debug ("level %d LAN Hello received over circuit with "
675 "externalDomain = true", level);
676 return ISIS_WARNING;
677 }
678
679 if (!accept_level (level, circuit->circuit_is_type))
680 {
681 if (isis->debugs & DEBUG_ADJ_PACKETS)
682 {
683 zlog_debug ("ISIS-Adj (%s): Interface level mismatch, %s",
684 circuit->area->area_tag, circuit->interface->name);
685 }
686 return ISIS_WARNING;
687 }
688
689 #if 0
690 /* Cisco's debug message compatability */
691 if (!accept_level (level, circuit->area->is_type))
692 {
693 if (isis->debugs & DEBUG_ADJ_PACKETS)
694 {
695 zlog_debug ("ISIS-Adj (%s): is type mismatch",
696 circuit->area->area_tag);
697 }
698 return ISIS_WARNING;
699 }
700 #endif
701 /*
702 * Fill the header
703 */
704 hdr.circuit_t = stream_getc (circuit->rcv_stream);
705 stream_get (hdr.source_id, circuit->rcv_stream, ISIS_SYS_ID_LEN);
706 hdr.hold_time = stream_getw (circuit->rcv_stream);
707 hdr.pdu_len = stream_getw (circuit->rcv_stream);
708 hdr.prio = stream_getc (circuit->rcv_stream);
709 stream_get (hdr.lan_id, circuit->rcv_stream, ISIS_SYS_ID_LEN + 1);
710
711 if (hdr.circuit_t != IS_LEVEL_1 && hdr.circuit_t != IS_LEVEL_2 &&
712 hdr.circuit_t != IS_LEVEL_1_AND_2)
713 {
714 zlog_warn ("Level %d LAN Hello with Circuit Type %d", level,
715 hdr.circuit_t);
716 return ISIS_ERROR;
717 }
718 /*
719 * Then get the tlvs
720 */
721 expected |= TLVFLAG_AUTH_INFO;
722 expected |= TLVFLAG_AREA_ADDRS;
723 expected |= TLVFLAG_LAN_NEIGHS;
724 expected |= TLVFLAG_NLPID;
725 expected |= TLVFLAG_IPV4_ADDR;
726 expected |= TLVFLAG_IPV6_ADDR;
727
728 retval = parse_tlvs (circuit->area->area_tag,
729 STREAM_PNT (circuit->rcv_stream),
730 hdr.pdu_len - ISIS_LANHELLO_HDRLEN -
731 ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs);
732
733 if (retval > ISIS_WARNING)
734 {
735 zlog_warn ("parse_tlvs() failed");
736 goto out;
737 }
738
739 if (!(found & TLVFLAG_AREA_ADDRS))
740 {
741 zlog_warn ("No Area addresses TLV in Level %d LAN IS to IS hello",
742 level);
743 retval = ISIS_WARNING;
744 goto out;
745 }
746
747 if (circuit->passwd.type)
748 {
749 if (!(found & TLVFLAG_AUTH_INFO) ||
750 authentication_check (&circuit->passwd, &tlvs.auth_info))
751 {
752 isis_event_auth_failure (circuit->area->area_tag,
753 "LAN hello authentication failure",
754 hdr.source_id);
755 retval = ISIS_WARNING;
756 goto out;
757 }
758 }
759
760 /*
761 * Accept the level 1 adjacency only if a match between local and
762 * remote area addresses is found
763 */
764 if (level == 1 && !area_match (circuit->area->area_addrs, tlvs.area_addrs))
765 {
766 if (isis->debugs & DEBUG_ADJ_PACKETS)
767 {
768 zlog_debug ("ISIS-Adj (%s): Area mismatch, level %d IIH on %s",
769 circuit->area->area_tag, level,
770 circuit->interface->name);
771 }
772 retval = ISIS_OK;
773 goto out;
774 }
775
776 /*
777 * it's own IIH PDU - discard silently
778 */
779 if (!memcmp (circuit->u.bc.snpa, ssnpa, ETH_ALEN))
780 {
781 zlog_debug ("ISIS-Adj (%s): it's own IIH PDU - discarded",
782 circuit->area->area_tag);
783
784 retval = ISIS_OK;
785 goto out;
786 }
787
788 /*
789 * check if it's own interface ip match iih ip addrs
790 */
791 if (!(found & TLVFLAG_IPV4_ADDR)
792 || !ip_match (circuit->ip_addrs, tlvs.ipv4_addrs))
793 {
794 zlog_debug
795 ("ISIS-Adj: No usable IP interface addresses in LAN IIH from %s\n",
796 circuit->interface->name);
797 retval = ISIS_WARNING;
798 goto out;
799 }
800
801 adj = isis_adj_lookup (hdr.source_id, circuit->u.bc.adjdb[level - 1]);
802 if (!adj)
803 {
804 /*
805 * Do as in 8.4.2.5
806 */
807 adj = isis_new_adj (hdr.source_id, ssnpa, level, circuit);
808 if (adj == NULL)
809 {
810 retval = ISIS_ERROR;
811 goto out;
812 }
813
814 adj->level = level;
815 isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
816
817 if (level == 1)
818 {
819 adj->sys_type = ISIS_SYSTYPE_L1_IS;
820 }
821 else
822 {
823 adj->sys_type = ISIS_SYSTYPE_L2_IS;
824 }
825 list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
826 isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
827 circuit->u.bc.lan_neighs[level - 1]);
828 }
829
830 if(adj->dis_record[level-1].dis==ISIS_IS_DIS)
831 switch (level)
832 {
833 case 1:
834 if (memcmp (circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
835 {
836 thread_add_event (master, isis_event_dis_status_change, circuit, 0);
837 memcpy (&circuit->u.bc.l1_desig_is, hdr.lan_id,
838 ISIS_SYS_ID_LEN + 1);
839 }
840 break;
841 case 2:
842 if (memcmp (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
843 {
844 thread_add_event (master, isis_event_dis_status_change, circuit, 0);
845 memcpy (&circuit->u.bc.l2_desig_is, hdr.lan_id,
846 ISIS_SYS_ID_LEN + 1);
847 }
848 break;
849 }
850
851 adj->hold_time = hdr.hold_time;
852 adj->last_upd = time (NULL);
853 adj->prio[level - 1] = hdr.prio;
854
855 memcpy (adj->lanid, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
856
857 /* which protocol are spoken ??? */
858 if (found & TLVFLAG_NLPID)
859 tlvs_to_adj_nlpids (&tlvs, adj);
860
861 /* we need to copy addresses to the adj */
862 if (found & TLVFLAG_IPV4_ADDR)
863 tlvs_to_adj_ipv4_addrs (&tlvs, adj);
864
865 #ifdef HAVE_IPV6
866 if (found & TLVFLAG_IPV6_ADDR)
867 tlvs_to_adj_ipv6_addrs (&tlvs, adj);
868 #endif /* HAVE_IPV6 */
869
870 adj->circuit_t = hdr.circuit_t;
871
872 /* lets take care of the expiry */
873 THREAD_TIMER_OFF (adj->t_expire);
874 THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
875 (long) adj->hold_time);
876
877 /*
878 * If the snpa for this circuit is found from LAN Neighbours TLV
879 * we have two-way communication -> adjacency can be put to state "up"
880 */
881
882 if (found & TLVFLAG_LAN_NEIGHS)
883 {
884 if (adj->adj_state != ISIS_ADJ_UP)
885 {
886 for (ALL_LIST_ELEMENTS_RO (tlvs.lan_neighs, node, snpa))
887 if (!memcmp (snpa, circuit->u.bc.snpa, ETH_ALEN))
888 {
889 isis_adj_state_change (adj, ISIS_ADJ_UP,
890 "own SNPA found in LAN Neighbours TLV");
891 }
892 }
893 }
894
895 out:
896 /* DEBUG_ADJ_PACKETS */
897 if (isis->debugs & DEBUG_ADJ_PACKETS)
898 {
899 /* FIXME: is this place right? fix missing info */
900 zlog_debug ("ISIS-Adj (%s): Rcvd L%d LAN IIH from %s on %s, cirType %s, "
901 "cirID %u, length %ld",
902 circuit->area->area_tag,
903 level, snpa_print (ssnpa), circuit->interface->name,
904 circuit_t2string (circuit->circuit_is_type),
905 circuit->circuit_id,
906 /* FIXME: use %z when we stop supporting old compilers. */
907 (unsigned long) stream_get_endp (circuit->rcv_stream));
908 }
909
910 free_tlvs (&tlvs);
911
912 return retval;
913 }
914
915 /*
916 * Process Level 1/2 Link State
917 * ISO - 10589
918 * Section 7.3.15.1 - Action on receipt of a link state PDU
919 */
920 static int
921 process_lsp (int level, struct isis_circuit *circuit, u_char * ssnpa)
922 {
923 struct isis_link_state_hdr *hdr;
924 struct isis_adjacency *adj = NULL;
925 struct isis_lsp *lsp, *lsp0 = NULL;
926 int retval = ISIS_OK, comp = 0;
927 u_char lspid[ISIS_SYS_ID_LEN + 2];
928 struct isis_passwd *passwd;
929
930 /* Sanity check - FIXME: move to correct place */
931 if ((stream_get_endp (circuit->rcv_stream) -
932 stream_get_getp (circuit->rcv_stream)) < ISIS_LSP_HDR_LEN)
933 {
934 zlog_warn ("Packet too short");
935 return ISIS_WARNING;
936 }
937
938 /* Reference the header */
939 hdr = (struct isis_link_state_hdr *) STREAM_PNT (circuit->rcv_stream);
940
941 if (isis->debugs & DEBUG_UPDATE_PACKETS)
942 {
943 zlog_debug ("ISIS-Upd (%s): Rcvd L%d LSP %s, seq 0x%08x, cksum 0x%04x, "
944 "lifetime %us, len %lu, on %s",
945 circuit->area->area_tag,
946 level,
947 rawlspid_print (hdr->lsp_id),
948 ntohl (hdr->seq_num),
949 ntohs (hdr->checksum),
950 ntohs (hdr->rem_lifetime),
951 /* FIXME: use %z when we stop supporting old compilers. */
952 (unsigned long) stream_get_endp (circuit->rcv_stream),
953 circuit->interface->name);
954 }
955
956 assert (ntohs (hdr->pdu_len) > ISIS_LSP_HDR_LEN);
957
958 /* Checksum sanity check - FIXME: move to correct place */
959 /* 12 = sysid+pdu+remtime */
960 if (iso_csum_verify (STREAM_PNT (circuit->rcv_stream) + 4,
961 ntohs (hdr->pdu_len) - 12, &hdr->checksum))
962 {
963 zlog_debug ("ISIS-Upd (%s): LSP %s invalid LSP checksum 0x%04x",
964 circuit->area->area_tag,
965 rawlspid_print (hdr->lsp_id), ntohs (hdr->checksum));
966
967 return ISIS_WARNING;
968 }
969
970 /* 7.3.15.1 a) 1 - external domain circuit will discard lsps */
971 if (circuit->ext_domain)
972 {
973 zlog_debug
974 ("ISIS-Upd (%s): LSP %s received at level %d over circuit with "
975 "externalDomain = true", circuit->area->area_tag,
976 rawlspid_print (hdr->lsp_id), level);
977
978 return ISIS_WARNING;
979 }
980
981 /* 7.3.15.1 a) 2,3 - manualL2OnlyMode not implemented */
982 if (!accept_level (level, circuit->circuit_is_type))
983 {
984 zlog_debug ("ISIS-Upd (%s): LSP %s received at level %d over circuit of"
985 " type %s",
986 circuit->area->area_tag,
987 rawlspid_print (hdr->lsp_id),
988 level, circuit_t2string (circuit->circuit_is_type));
989
990 return ISIS_WARNING;
991 }
992
993 /* 7.3.15.1 a) 4 - need to make sure IDLength matches */
994
995 /* 7.3.15.1 a) 5 - maximum area match, can be ommited since we only use 3 */
996
997 /* 7.3.15.1 a) 7 - password check */
998 (level == ISIS_LEVEL1) ? (passwd = &circuit->area->area_passwd) :
999 (passwd = &circuit->area->domain_passwd);
1000 if (passwd->type)
1001 {
1002 if (isis_lsp_authinfo_check (circuit->rcv_stream, circuit->area,
1003 ntohs (hdr->pdu_len), passwd))
1004 {
1005 isis_event_auth_failure (circuit->area->area_tag,
1006 "LSP authentication failure", hdr->lsp_id);
1007 return ISIS_WARNING;
1008 }
1009 }
1010 /* Find the LSP in our database and compare it to this Link State header */
1011 lsp = lsp_search (hdr->lsp_id, circuit->area->lspdb[level - 1]);
1012 if (lsp)
1013 comp = lsp_compare (circuit->area->area_tag, lsp, hdr->seq_num,
1014 hdr->checksum, hdr->rem_lifetime);
1015 if (lsp && (lsp->own_lsp
1016 #ifdef TOPOLOGY_GENERATE
1017 || lsp->from_topology
1018 #endif /* TOPOLOGY_GENERATE */
1019 ))
1020 goto dontcheckadj;
1021
1022 /* 7.3.15.1 a) 6 - Must check that we have an adjacency of the same level */
1023 /* for broadcast circuits, snpa should be compared */
1024 /* FIXME : Point To Point */
1025
1026 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
1027 {
1028 adj = isis_adj_lookup_snpa (ssnpa, circuit->u.bc.adjdb[level - 1]);
1029 if (!adj)
1030 {
1031 zlog_debug ("(%s): DS ======= LSP %s, seq 0x%08x, cksum 0x%04x, "
1032 "lifetime %us on %s",
1033 circuit->area->area_tag,
1034 rawlspid_print (hdr->lsp_id),
1035 ntohl (hdr->seq_num),
1036 ntohs (hdr->checksum),
1037 ntohs (hdr->rem_lifetime), circuit->interface->name);
1038 return ISIS_WARNING; /* Silently discard */
1039 }
1040 }
1041
1042 /* for non broadcast, we just need to find same level adj */
1043 else
1044 {
1045 /* If no adj, or no sharing of level */
1046 if (!circuit->u.p2p.neighbor)
1047 {
1048 return ISIS_OK; /* Silently discard */
1049 }
1050 else
1051 {
1052 if (((level == 1) &&
1053 (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL2)) ||
1054 ((level == 2) &&
1055 (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL1)))
1056 return ISIS_WARNING; /* Silently discard */
1057 }
1058 }
1059 dontcheckadj:
1060 /* 7.3.15.1 a) 7 - Passwords for level 1 - not implemented */
1061
1062 /* 7.3.15.1 a) 8 - Passwords for level 2 - not implemented */
1063
1064 /* 7.3.15.1 a) 9 - OriginatingLSPBufferSize - not implemented FIXME: do it */
1065
1066 /* 7.3.15.1 b) - If the remaining life time is 0, we perform 7.3.16.4 */
1067 if (hdr->rem_lifetime == 0)
1068 {
1069 if (!lsp)
1070 {
1071 /* 7.3.16.4 a) 1) No LSP in db -> send an ack, but don't save */
1072 /* only needed on explicit update, eg - p2p */
1073 if (circuit->circ_type == CIRCUIT_T_P2P)
1074 ack_lsp (hdr, circuit, level);
1075 return retval; /* FIXME: do we need a purge? */
1076 }
1077 else
1078 {
1079 if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN))
1080 {
1081 /* LSP by some other system -> do 7.3.16.4 b) */
1082 /* 7.3.16.4 b) 1) */
1083 if (comp == LSP_NEWER)
1084 {
1085 lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area,
1086 level);
1087 /* ii */
1088 ISIS_FLAGS_SET_ALL (lsp->SRMflags);
1089 /* iii */
1090 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
1091 /* v */
1092 ISIS_FLAGS_CLEAR_ALL (lsp->SSNflags); /* FIXME: OTHER than c */
1093 /* iv */
1094 if (circuit->circ_type != CIRCUIT_T_BROADCAST)
1095 ISIS_SET_FLAG (lsp->SSNflags, circuit);
1096
1097 } /* 7.3.16.4 b) 2) */
1098 else if (comp == LSP_EQUAL)
1099 {
1100 /* i */
1101 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
1102 /* ii */
1103 if (circuit->circ_type != CIRCUIT_T_BROADCAST)
1104 ISIS_SET_FLAG (lsp->SSNflags, circuit);
1105 } /* 7.3.16.4 b) 3) */
1106 else
1107 {
1108 ISIS_SET_FLAG (lsp->SRMflags, circuit);
1109 ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
1110 }
1111 }
1112 else
1113 {
1114 /* our own LSP -> 7.3.16.4 c) */
1115 if (LSP_PSEUDO_ID (lsp->lsp_header->lsp_id) !=
1116 circuit->circuit_id
1117 || (LSP_PSEUDO_ID (lsp->lsp_header->lsp_id) ==
1118 circuit->circuit_id
1119 && circuit->u.bc.is_dr[level - 1] == 1))
1120 {
1121 lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
1122 if (isis->debugs & DEBUG_UPDATE_PACKETS)
1123 zlog_debug ("LSP LEN: %d",
1124 ntohs (lsp->lsp_header->pdu_len));
1125 fletcher_checksum (STREAM_DATA (lsp->pdu) + 12,
1126 ntohs (lsp->lsp_header->pdu_len) - 12, 12);
1127 ISIS_FLAGS_SET_ALL (lsp->SRMflags);
1128 if (isis->debugs & DEBUG_UPDATE_PACKETS)
1129 zlog_debug ("ISIS-Upd (%s): (1) re-originating LSP %s new "
1130 "seq 0x%08x", circuit->area->area_tag,
1131 rawlspid_print (hdr->lsp_id),
1132 ntohl (lsp->lsp_header->seq_num));
1133 lsp->lsp_header->rem_lifetime =
1134 htons (isis_jitter
1135 (circuit->area->max_lsp_lifetime[level - 1],
1136 MAX_AGE_JITTER));
1137 }
1138 else
1139 {
1140 /* Got purge for own pseudo-lsp, and we are not DR */
1141 lsp_purge_dr (lsp->lsp_header->lsp_id, circuit, level);
1142 }
1143 }
1144 }
1145 return retval;
1146 }
1147 /* 7.3.15.1 c) - If this is our own lsp and we don't have it initiate a
1148 * purge */
1149 if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN) == 0)
1150 {
1151 if (!lsp)
1152 {
1153 /* 7.3.16.4: initiate a purge */
1154 lsp_purge_non_exist (hdr, circuit->area);
1155 return ISIS_OK;
1156 }
1157 /* 7.3.15.1 d) - If this is our own lsp and we have it */
1158
1159 /* In 7.3.16.1, If an Intermediate system R somewhere in the domain
1160 * has information that the current sequence number for source S is
1161 * "greater" than that held by S, ... */
1162
1163 else if (ntohl (hdr->seq_num) > ntohl (lsp->lsp_header->seq_num))
1164 {
1165 /* 7.3.16.1 */
1166 lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
1167
1168 fletcher_checksum (STREAM_DATA (lsp->pdu) + 12,
1169 ntohs (lsp->lsp_header->pdu_len) - 12, 12);
1170
1171 ISIS_FLAGS_SET_ALL (lsp->SRMflags);
1172 if (isis->debugs & DEBUG_UPDATE_PACKETS)
1173 zlog_debug ("ISIS-Upd (%s): (2) re-originating LSP %s new seq "
1174 "0x%08x", circuit->area->area_tag,
1175 rawlspid_print (hdr->lsp_id),
1176 ntohl (lsp->lsp_header->seq_num));
1177 lsp->lsp_header->rem_lifetime =
1178 htons (isis_jitter
1179 (circuit->area->max_lsp_lifetime[level - 1],
1180 MAX_AGE_JITTER));
1181 }
1182 }
1183 else
1184 {
1185 /* 7.3.15.1 e) - This lsp originated on another system */
1186
1187 /* 7.3.15.1 e) 1) LSP newer than the one in db or no LSP in db */
1188 if ((!lsp || comp == LSP_NEWER))
1189 {
1190 /* i */
1191 if (lsp)
1192 {
1193 #ifdef EXTREME_DEBUG
1194 zlog_debug ("level %d number is - %ld", level,
1195 circuit->area->lspdb[level - 1]->dict_nodecount);
1196 #endif /* EXTREME DEBUG */
1197 lsp_search_and_destroy (hdr->lsp_id,
1198 circuit->area->lspdb[level - 1]);
1199 /* exists, so we overwrite */
1200 #ifdef EXTREME_DEBUG
1201 zlog_debug ("level %d number is - %ld", level,
1202 circuit->area->lspdb[level - 1]->dict_nodecount);
1203 #endif /* EXTREME DEBUG */
1204 }
1205 /*
1206 * If this lsp is a frag, need to see if we have zero lsp present
1207 */
1208 if (LSP_FRAGMENT (hdr->lsp_id) != 0)
1209 {
1210 memcpy (lspid, hdr->lsp_id, ISIS_SYS_ID_LEN + 1);
1211 LSP_FRAGMENT (lspid) = 0;
1212 lsp0 = lsp_search (lspid, circuit->area->lspdb[level - 1]);
1213 if (!lsp0)
1214 {
1215 zlog_debug ("Got lsp frag, while zero lsp not database");
1216 return ISIS_OK;
1217 }
1218 }
1219 lsp =
1220 lsp_new_from_stream_ptr (circuit->rcv_stream,
1221 ntohs (hdr->pdu_len), lsp0,
1222 circuit->area);
1223 lsp->level = level;
1224 lsp->adj = adj;
1225 lsp_insert (lsp, circuit->area->lspdb[level - 1]);
1226 /* ii */
1227 ISIS_FLAGS_SET_ALL (lsp->SRMflags);
1228 /* iii */
1229 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
1230
1231 /* iv */
1232 if (circuit->circ_type != CIRCUIT_T_BROADCAST)
1233 ISIS_SET_FLAG (lsp->SSNflags, circuit);
1234 /* FIXME: v) */
1235 }
1236 /* 7.3.15.1 e) 2) LSP equal to the one in db */
1237 else if (comp == LSP_EQUAL)
1238 {
1239 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
1240 lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area, level);
1241 if (circuit->circ_type != CIRCUIT_T_BROADCAST)
1242 {
1243 ISIS_SET_FLAG (lsp->SSNflags, circuit);
1244 }
1245 }
1246 /* 7.3.15.1 e) 3) LSP older than the one in db */
1247 else
1248 {
1249 ISIS_SET_FLAG (lsp->SRMflags, circuit);
1250 ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
1251 }
1252 }
1253 if (lsp)
1254 lsp->adj = adj;
1255 return retval;
1256 }
1257
1258 /*
1259 * Process Sequence Numbers
1260 * ISO - 10589
1261 * Section 7.3.15.2 - Action on receipt of a sequence numbers PDU
1262 */
1263
1264 static int
1265 process_snp (int snp_type, int level, struct isis_circuit *circuit,
1266 u_char * ssnpa)
1267 {
1268 int retval = ISIS_OK;
1269 int cmp, own_lsp;
1270 char typechar = ' ';
1271 int len;
1272 struct isis_adjacency *adj;
1273 struct isis_complete_seqnum_hdr *chdr = NULL;
1274 struct isis_partial_seqnum_hdr *phdr = NULL;
1275 uint32_t found = 0, expected = 0;
1276 struct isis_lsp *lsp;
1277 struct lsp_entry *entry;
1278 struct listnode *node, *nnode;
1279 struct listnode *node2, *nnode2;
1280 struct tlvs tlvs;
1281 struct list *lsp_list = NULL;
1282 struct isis_passwd *passwd;
1283
1284 if (snp_type == ISIS_SNP_CSNP_FLAG)
1285 {
1286 /* getting the header info */
1287 typechar = 'C';
1288 chdr =
1289 (struct isis_complete_seqnum_hdr *) STREAM_PNT (circuit->rcv_stream);
1290 circuit->rcv_stream->getp += ISIS_CSNP_HDRLEN;
1291 len = ntohs (chdr->pdu_len);
1292 if (len < ISIS_CSNP_HDRLEN)
1293 {
1294 zlog_warn ("Received a CSNP with bogus length!");
1295 return ISIS_OK;
1296 }
1297 }
1298 else
1299 {
1300 typechar = 'P';
1301 phdr =
1302 (struct isis_partial_seqnum_hdr *) STREAM_PNT (circuit->rcv_stream);
1303 circuit->rcv_stream->getp += ISIS_PSNP_HDRLEN;
1304 len = ntohs (phdr->pdu_len);
1305 if (len < ISIS_PSNP_HDRLEN)
1306 {
1307 zlog_warn ("Received a CSNP with bogus length!");
1308 return ISIS_OK;
1309 }
1310 }
1311
1312 /* 7.3.15.2 a) 1 - external domain circuit will discard snp pdu */
1313 if (circuit->ext_domain)
1314 {
1315
1316 zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
1317 "skipping: circuit externalDomain = true",
1318 circuit->area->area_tag,
1319 level, typechar, circuit->interface->name);
1320
1321 return ISIS_OK;
1322 }
1323
1324 /* 7.3.15.2 a) 2,3 - manualL2OnlyMode not implemented */
1325 if (!accept_level (level, circuit->circuit_is_type))
1326 {
1327
1328 zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
1329 "skipping: circuit type %s does not match level %d",
1330 circuit->area->area_tag,
1331 level,
1332 typechar,
1333 circuit->interface->name,
1334 circuit_t2string (circuit->circuit_is_type), level);
1335
1336 return ISIS_OK;
1337 }
1338
1339 /* 7.3.15.2 a) 4 - not applicable for CSNP only PSNPs on broadcast */
1340 if ((snp_type == ISIS_SNP_PSNP_FLAG) &&
1341 (circuit->circ_type == CIRCUIT_T_BROADCAST))
1342 {
1343 if (!circuit->u.bc.is_dr[level - 1])
1344 {
1345
1346 zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s, "
1347 "skipping: we are not the DIS",
1348 circuit->area->area_tag,
1349 level,
1350 typechar, snpa_print (ssnpa), circuit->interface->name);
1351
1352 return ISIS_OK;
1353 }
1354 }
1355
1356 /* 7.3.15.2 a) 5 - need to make sure IDLength matches - already checked */
1357
1358 /* 7.3.15.2 a) 6 - maximum area match, can be ommited since we only use 3
1359 * - already checked */
1360
1361 /* 7.3.15.2 a) 7 - Must check that we have an adjacency of the same level */
1362 /* for broadcast circuits, snpa should be compared */
1363 /* FIXME : Do we need to check SNPA? */
1364 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
1365 {
1366 if (snp_type == ISIS_SNP_CSNP_FLAG)
1367 {
1368 adj =
1369 isis_adj_lookup (chdr->source_id, circuit->u.bc.adjdb[level - 1]);
1370 }
1371 else
1372 {
1373 /* a psnp on a broadcast, how lovely of Juniper :) */
1374 adj =
1375 isis_adj_lookup (phdr->source_id, circuit->u.bc.adjdb[level - 1]);
1376 }
1377 if (!adj)
1378 return ISIS_OK; /* Silently discard */
1379 }
1380 else
1381 {
1382 if (!circuit->u.p2p.neighbor)
1383 return ISIS_OK; /* Silently discard */
1384 }
1385
1386 /* 7.3.15.2 a) 8 - Passwords for level 1 - not implemented */
1387
1388 /* 7.3.15.2 a) 9 - Passwords for level 2 - not implemented */
1389
1390 memset (&tlvs, 0, sizeof (struct tlvs));
1391
1392 /* parse the SNP */
1393 expected |= TLVFLAG_LSP_ENTRIES;
1394 expected |= TLVFLAG_AUTH_INFO;
1395 retval = parse_tlvs (circuit->area->area_tag,
1396 STREAM_PNT (circuit->rcv_stream),
1397 len - circuit->rcv_stream->getp,
1398 &expected, &found, &tlvs);
1399
1400 if (retval > ISIS_WARNING)
1401 {
1402 zlog_warn ("something went very wrong processing SNP");
1403 free_tlvs (&tlvs);
1404 return retval;
1405 }
1406
1407 if (level == 1)
1408 passwd = &circuit->area->area_passwd;
1409 else
1410 passwd = &circuit->area->domain_passwd;
1411
1412 if (CHECK_FLAG(passwd->snp_auth, SNP_AUTH_RECV))
1413 {
1414 if (passwd->type)
1415 {
1416 if (!(found & TLVFLAG_AUTH_INFO) ||
1417 authentication_check (passwd, &tlvs.auth_info))
1418 {
1419 isis_event_auth_failure (circuit->area->area_tag,
1420 "SNP authentication" " failure",
1421 phdr ? phdr->source_id : chdr->source_id);
1422 return ISIS_OK;
1423 }
1424 }
1425 }
1426
1427 /* debug isis snp-packets */
1428 if (isis->debugs & DEBUG_SNP_PACKETS)
1429 {
1430 zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s",
1431 circuit->area->area_tag,
1432 level,
1433 typechar, snpa_print (ssnpa), circuit->interface->name);
1434 if (tlvs.lsp_entries)
1435 {
1436 for (ALL_LIST_ELEMENTS_RO (tlvs.lsp_entries, node, entry))
1437 {
1438 zlog_debug ("ISIS-Snp (%s): %cSNP entry %s, seq 0x%08x,"
1439 " cksum 0x%04x, lifetime %us",
1440 circuit->area->area_tag,
1441 typechar,
1442 rawlspid_print (entry->lsp_id),
1443 ntohl (entry->seq_num),
1444 ntohs (entry->checksum), ntohs (entry->rem_lifetime));
1445 }
1446 }
1447 }
1448
1449 /* 7.3.15.2 b) Actions on LSP_ENTRIES reported */
1450 if (tlvs.lsp_entries)
1451 {
1452 for (ALL_LIST_ELEMENTS_RO (tlvs.lsp_entries, node, entry))
1453 {
1454 lsp = lsp_search (entry->lsp_id, circuit->area->lspdb[level - 1]);
1455 own_lsp = !memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
1456 if (lsp)
1457 {
1458 /* 7.3.15.2 b) 1) is this LSP newer */
1459 cmp = lsp_compare (circuit->area->area_tag, lsp, entry->seq_num,
1460 entry->checksum, entry->rem_lifetime);
1461 /* 7.3.15.2 b) 2) if it equals, clear SRM on p2p */
1462 if (cmp == LSP_EQUAL)
1463 {
1464 if (circuit->circ_type != CIRCUIT_T_BROADCAST)
1465 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
1466 /* 7.3.15.2 b) 3) if it is older, clear SSN and set SRM */
1467 }
1468 else if (cmp == LSP_OLDER)
1469 {
1470 ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
1471 ISIS_SET_FLAG (lsp->SRMflags, circuit);
1472 }
1473 else
1474 {
1475 /* 7.3.15.2 b) 4) if it is newer, set SSN and clear SRM
1476 * on p2p */
1477 if (own_lsp)
1478 {
1479 lsp_inc_seqnum (lsp, ntohl (entry->seq_num));
1480 ISIS_SET_FLAG (lsp->SRMflags, circuit);
1481 }
1482 else
1483 {
1484 ISIS_SET_FLAG (lsp->SSNflags, circuit);
1485 if (circuit->circ_type != CIRCUIT_T_BROADCAST)
1486 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
1487 }
1488 }
1489 }
1490 else
1491 {
1492 /* 7.3.15.2 b) 5) if it was not found, and all of those are not 0,
1493 * insert it and set SSN on it */
1494 if (entry->rem_lifetime && entry->checksum && entry->seq_num &&
1495 memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN))
1496 {
1497 lsp = lsp_new (entry->lsp_id, ntohs (entry->rem_lifetime),
1498 0, 0, entry->checksum, level);
1499 lsp_insert (lsp, circuit->area->lspdb[level - 1]);
1500 ISIS_SET_FLAG (lsp->SSNflags, circuit);
1501 }
1502 }
1503 }
1504 }
1505
1506 /* 7.3.15.2 c) on CSNP set SRM for all in range which were not reported */
1507 if (snp_type == ISIS_SNP_CSNP_FLAG)
1508 {
1509 /*
1510 * Build a list from our own LSP db bounded with start_ and stop_lsp_id
1511 */
1512 lsp_list = list_new ();
1513 lsp_build_list_nonzero_ht (chdr->start_lsp_id, chdr->stop_lsp_id,
1514 lsp_list, circuit->area->lspdb[level - 1]);
1515
1516 /* Fixme: Find a better solution */
1517 if (tlvs.lsp_entries)
1518 {
1519 for (ALL_LIST_ELEMENTS (tlvs.lsp_entries, node, nnode, entry))
1520 {
1521 for (ALL_LIST_ELEMENTS (lsp_list, node2, nnode2, lsp))
1522 {
1523 if (lsp_id_cmp (lsp->lsp_header->lsp_id, entry->lsp_id) == 0)
1524 {
1525 list_delete_node (lsp_list, node2);
1526 break;
1527 }
1528 }
1529 }
1530 }
1531 /* on remaining LSPs we set SRM (neighbor knew not of) */
1532 for (ALL_LIST_ELEMENTS_RO (lsp_list, node, lsp))
1533 {
1534 ISIS_SET_FLAG (lsp->SRMflags, circuit);
1535 }
1536 /* lets free it */
1537 list_free (lsp_list);
1538 }
1539
1540 free_tlvs (&tlvs);
1541 return retval;
1542 }
1543
1544 static int
1545 process_csnp (int level, struct isis_circuit *circuit, u_char * ssnpa)
1546 {
1547 /* Sanity check - FIXME: move to correct place */
1548 if ((stream_get_endp (circuit->rcv_stream) -
1549 stream_get_getp (circuit->rcv_stream)) < ISIS_CSNP_HDRLEN)
1550 {
1551 zlog_warn ("Packet too short ( < %d)", ISIS_CSNP_HDRLEN);
1552 return ISIS_WARNING;
1553 }
1554
1555 return process_snp (ISIS_SNP_CSNP_FLAG, level, circuit, ssnpa);
1556 }
1557
1558 static int
1559 process_psnp (int level, struct isis_circuit *circuit, u_char * ssnpa)
1560 {
1561 if ((stream_get_endp (circuit->rcv_stream) -
1562 stream_get_getp (circuit->rcv_stream)) < ISIS_PSNP_HDRLEN)
1563 {
1564 zlog_warn ("Packet too short");
1565 return ISIS_WARNING;
1566 }
1567
1568 return process_snp (ISIS_SNP_PSNP_FLAG, level, circuit, ssnpa);
1569 }
1570
1571 /*
1572 * Process ISH
1573 * ISO - 10589
1574 * Section 8.2.2 - Receiving ISH PDUs by an intermediate system
1575 * FIXME: sample packet dump, need to figure 0x81 - looks like NLPid
1576 * 0x82 0x15 0x01 0x00 0x04 0x01 0x2c 0x59
1577 * 0x38 0x08 0x47 0x00 0x01 0x00 0x02 0x00
1578 * 0x03 0x00 0x81 0x01 0xcc
1579 */
1580 static int
1581 process_is_hello (struct isis_circuit *circuit)
1582 {
1583 struct isis_adjacency *adj;
1584 int retval = ISIS_OK;
1585 u_char neigh_len;
1586 u_char *sysid;
1587
1588 /* In this point in time we are not yet able to handle is_hellos
1589 * on lan - Sorry juniper...
1590 */
1591 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
1592 return retval;
1593
1594 neigh_len = stream_getc (circuit->rcv_stream);
1595 sysid = STREAM_PNT (circuit->rcv_stream) + neigh_len - 1 - ISIS_SYS_ID_LEN;
1596 adj = circuit->u.p2p.neighbor;
1597 if (!adj)
1598 {
1599 /* 8.2.2 */
1600 adj = isis_new_adj (sysid, NULL, 0, circuit);
1601 if (adj == NULL)
1602 return ISIS_ERROR;
1603
1604 isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
1605 adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
1606 circuit->u.p2p.neighbor = adj;
1607 }
1608 /* 8.2.2 a) */
1609 if ((adj->adj_state == ISIS_ADJ_UP) && memcmp (adj->sysid, sysid,
1610 ISIS_SYS_ID_LEN))
1611 {
1612 /* 8.2.2 a) 1) FIXME: adjStateChange(down) event */
1613 /* 8.2.2 a) 2) delete the adj */
1614 XFREE (MTYPE_ISIS_ADJACENCY, adj);
1615 /* 8.2.2 a) 3) create a new adj */
1616 adj = isis_new_adj (sysid, NULL, 0, circuit);
1617 if (adj == NULL)
1618 return ISIS_ERROR;
1619
1620 /* 8.2.2 a) 3) i */
1621 isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
1622 /* 8.2.2 a) 3) ii */
1623 adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
1624 /* 8.2.2 a) 4) quite meaningless */
1625 }
1626 /* 8.2.2 b) ignore on condition */
1627 if ((adj->adj_state == ISIS_ADJ_INITIALIZING) &&
1628 (adj->sys_type == ISIS_SYSTYPE_IS))
1629 {
1630 /* do nothing */
1631 }
1632 else
1633 {
1634 /* 8.2.2 c) respond with a p2p IIH */
1635 send_hello (circuit, 1);
1636 }
1637 /* 8.2.2 d) type is IS */
1638 adj->sys_type = ISIS_SYSTYPE_IS;
1639 /* 8.2.2 e) FIXME: Circuit type of? */
1640
1641 return retval;
1642 }
1643
1644 /*
1645 * PDU Dispatcher
1646 */
1647
1648 static int
1649 isis_handle_pdu (struct isis_circuit *circuit, u_char * ssnpa)
1650 {
1651 struct isis_fixed_hdr *hdr;
1652 struct esis_fixed_hdr *esis_hdr;
1653
1654 int retval = ISIS_OK;
1655
1656 /*
1657 * Let's first read data from stream to the header
1658 */
1659 hdr = (struct isis_fixed_hdr *) STREAM_DATA (circuit->rcv_stream);
1660
1661 if ((hdr->idrp != ISO10589_ISIS) && (hdr->idrp != ISO9542_ESIS))
1662 {
1663 zlog_warn ("Not an IS-IS or ES-IS packet IDRP=%02x", hdr->idrp);
1664 return ISIS_ERROR;
1665 }
1666
1667 /* now we need to know if this is an ISO 9542 packet and
1668 * take real good care of it, waaa!
1669 */
1670 if (hdr->idrp == ISO9542_ESIS)
1671 {
1672 esis_hdr = (struct esis_fixed_hdr *) STREAM_DATA (circuit->rcv_stream);
1673 stream_set_getp (circuit->rcv_stream, ESIS_FIXED_HDR_LEN);
1674 /* FIXME: Need to do some acceptence tests */
1675 /* example length... */
1676 switch (esis_hdr->pdu_type)
1677 {
1678 case ESH_PDU:
1679 /* FIXME */
1680 break;
1681 case ISH_PDU:
1682 zlog_debug ("AN ISH PDU!!");
1683 retval = process_is_hello (circuit);
1684 break;
1685 default:
1686 return ISIS_ERROR;
1687 }
1688 return retval;
1689 }
1690 else
1691 {
1692 stream_set_getp (circuit->rcv_stream, ISIS_FIXED_HDR_LEN);
1693 }
1694 /*
1695 * and then process it
1696 */
1697
1698 if (hdr->length < ISIS_MINIMUM_FIXED_HDR_LEN)
1699 {
1700 zlog_err ("Fixed header length = %d", hdr->length);
1701 return ISIS_ERROR;
1702 }
1703
1704 if (hdr->version1 != 1)
1705 {
1706 zlog_warn ("Unsupported ISIS version %u", hdr->version1);
1707 return ISIS_WARNING;
1708 }
1709 /* either 6 or 0 */
1710 if ((hdr->id_len != 0) && (hdr->id_len != ISIS_SYS_ID_LEN))
1711 {
1712 zlog_err
1713 ("IDFieldLengthMismatch: ID Length field in a received PDU %u, "
1714 "while the parameter for this IS is %u", hdr->id_len,
1715 ISIS_SYS_ID_LEN);
1716 return ISIS_ERROR;
1717 }
1718
1719 if (hdr->version2 != 1)
1720 {
1721 zlog_warn ("Unsupported ISIS version %u", hdr->version2);
1722 return ISIS_WARNING;
1723 }
1724 /* either 3 or 0 */
1725 if ((hdr->max_area_addrs != 0)
1726 && (hdr->max_area_addrs != isis->max_area_addrs))
1727 {
1728 zlog_err ("maximumAreaAddressesMismatch: maximumAreaAdresses in a "
1729 "received PDU %u while the parameter for this IS is %u",
1730 hdr->max_area_addrs, isis->max_area_addrs);
1731 return ISIS_ERROR;
1732 }
1733
1734 switch (hdr->pdu_type)
1735 {
1736 case L1_LAN_HELLO:
1737 retval = process_lan_hello (ISIS_LEVEL1, circuit, ssnpa);
1738 break;
1739 case L2_LAN_HELLO:
1740 retval = process_lan_hello (ISIS_LEVEL2, circuit, ssnpa);
1741 break;
1742 case P2P_HELLO:
1743 retval = process_p2p_hello (circuit);
1744 break;
1745 case L1_LINK_STATE:
1746 retval = process_lsp (ISIS_LEVEL1, circuit, ssnpa);
1747 break;
1748 case L2_LINK_STATE:
1749 retval = process_lsp (ISIS_LEVEL2, circuit, ssnpa);
1750 break;
1751 case L1_COMPLETE_SEQ_NUM:
1752 retval = process_csnp (ISIS_LEVEL1, circuit, ssnpa);
1753 break;
1754 case L2_COMPLETE_SEQ_NUM:
1755 retval = process_csnp (ISIS_LEVEL2, circuit, ssnpa);
1756 break;
1757 case L1_PARTIAL_SEQ_NUM:
1758 retval = process_psnp (ISIS_LEVEL1, circuit, ssnpa);
1759 break;
1760 case L2_PARTIAL_SEQ_NUM:
1761 retval = process_psnp (ISIS_LEVEL2, circuit, ssnpa);
1762 break;
1763 default:
1764 return ISIS_ERROR;
1765 }
1766
1767 return retval;
1768 }
1769
1770 #ifdef GNU_LINUX
1771 int
1772 isis_receive (struct thread *thread)
1773 {
1774 struct isis_circuit *circuit;
1775 u_char ssnpa[ETH_ALEN];
1776 int retval;
1777
1778 /*
1779 * Get the circuit
1780 */
1781 circuit = THREAD_ARG (thread);
1782 assert (circuit);
1783
1784 if (circuit->rcv_stream == NULL)
1785 circuit->rcv_stream = stream_new (ISO_MTU (circuit));
1786 else
1787 stream_reset (circuit->rcv_stream);
1788
1789 retval = circuit->rx (circuit, ssnpa);
1790 circuit->t_read = NULL;
1791
1792 if (retval == ISIS_OK)
1793 retval = isis_handle_pdu (circuit, ssnpa);
1794
1795 /*
1796 * prepare for next packet.
1797 */
1798 THREAD_READ_ON (master, circuit->t_read, isis_receive, circuit,
1799 circuit->fd);
1800
1801 return retval;
1802 }
1803
1804 #else
1805 int
1806 isis_receive (struct thread *thread)
1807 {
1808 struct isis_circuit *circuit;
1809 u_char ssnpa[ETH_ALEN];
1810 int retval;
1811
1812 /*
1813 * Get the circuit
1814 */
1815 circuit = THREAD_ARG (thread);
1816 assert (circuit);
1817
1818 circuit->t_read = NULL;
1819
1820 if (circuit->rcv_stream == NULL)
1821 circuit->rcv_stream = stream_new (ISO_MTU (circuit));
1822 else
1823 stream_reset (circuit->rcv_stream);
1824
1825 retval = circuit->rx (circuit, ssnpa);
1826
1827 if (retval == ISIS_OK)
1828 retval = isis_handle_pdu (circuit, ssnpa);
1829
1830 /*
1831 * prepare for next packet.
1832 */
1833 circuit->t_read = thread_add_timer_msec (master, isis_receive, circuit,
1834 listcount
1835 (circuit->area->circuit_list) *
1836 100);
1837
1838 return retval;
1839 }
1840
1841 #endif
1842
1843 /* filling of the fixed isis header */
1844 void
1845 fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type)
1846 {
1847 memset (hdr, 0, sizeof (struct isis_fixed_hdr));
1848
1849 hdr->idrp = ISO10589_ISIS;
1850
1851 switch (pdu_type)
1852 {
1853 case L1_LAN_HELLO:
1854 case L2_LAN_HELLO:
1855 hdr->length = ISIS_LANHELLO_HDRLEN;
1856 break;
1857 case P2P_HELLO:
1858 hdr->length = ISIS_P2PHELLO_HDRLEN;
1859 break;
1860 case L1_LINK_STATE:
1861 case L2_LINK_STATE:
1862 hdr->length = ISIS_LSP_HDR_LEN;
1863 break;
1864 case L1_COMPLETE_SEQ_NUM:
1865 case L2_COMPLETE_SEQ_NUM:
1866 hdr->length = ISIS_CSNP_HDRLEN;
1867 break;
1868 case L1_PARTIAL_SEQ_NUM:
1869 case L2_PARTIAL_SEQ_NUM:
1870 hdr->length = ISIS_PSNP_HDRLEN;
1871 break;
1872 default:
1873 zlog_warn ("fill_fixed_hdr(): unknown pdu type %d", pdu_type);
1874 return;
1875 }
1876 hdr->length += ISIS_FIXED_HDR_LEN;
1877 hdr->pdu_type = pdu_type;
1878 hdr->version1 = 1;
1879 hdr->id_len = 0; /* ISIS_SYS_ID_LEN - 0==6 */
1880 hdr->version2 = 1;
1881 hdr->max_area_addrs = 0; /* isis->max_area_addrs - 0==3 */
1882 }
1883
1884 /*
1885 * SEND SIDE
1886 */
1887 static void
1888 fill_fixed_hdr_andstream (struct isis_fixed_hdr *hdr, u_char pdu_type,
1889 struct stream *stream)
1890 {
1891 fill_fixed_hdr (hdr, pdu_type);
1892
1893 stream_putc (stream, hdr->idrp);
1894 stream_putc (stream, hdr->length);
1895 stream_putc (stream, hdr->version1);
1896 stream_putc (stream, hdr->id_len);
1897 stream_putc (stream, hdr->pdu_type);
1898 stream_putc (stream, hdr->version2);
1899 stream_putc (stream, hdr->reserved);
1900 stream_putc (stream, hdr->max_area_addrs);
1901
1902 return;
1903 }
1904
1905 int
1906 send_hello (struct isis_circuit *circuit, int level)
1907 {
1908 struct isis_fixed_hdr fixed_hdr;
1909 struct isis_lan_hello_hdr hello_hdr;
1910 struct isis_p2p_hello_hdr p2p_hello_hdr;
1911
1912 u_int32_t interval;
1913 unsigned long len_pointer, length;
1914 int retval;
1915
1916 if (circuit->interface->mtu == 0)
1917 {
1918 zlog_warn ("circuit has zero MTU");
1919 return ISIS_WARNING;
1920 }
1921
1922 if (!circuit->snd_stream)
1923 circuit->snd_stream = stream_new (ISO_MTU (circuit));
1924 else
1925 stream_reset (circuit->snd_stream);
1926
1927 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
1928 if (level == 1)
1929 fill_fixed_hdr_andstream (&fixed_hdr, L1_LAN_HELLO,
1930 circuit->snd_stream);
1931 else
1932 fill_fixed_hdr_andstream (&fixed_hdr, L2_LAN_HELLO,
1933 circuit->snd_stream);
1934 else
1935 fill_fixed_hdr_andstream (&fixed_hdr, P2P_HELLO, circuit->snd_stream);
1936
1937 /*
1938 * Fill LAN Level 1 or 2 Hello PDU header
1939 */
1940 memset (&hello_hdr, 0, sizeof (struct isis_lan_hello_hdr));
1941 interval = circuit->hello_multiplier[level - 1] *
1942 circuit->hello_interval[level - 1];
1943 if (interval > USHRT_MAX)
1944 interval = USHRT_MAX;
1945 hello_hdr.circuit_t = circuit->circuit_is_type;
1946 memcpy (hello_hdr.source_id, isis->sysid, ISIS_SYS_ID_LEN);
1947 hello_hdr.hold_time = htons ((u_int16_t) interval);
1948
1949 hello_hdr.pdu_len = 0; /* Update the PDU Length later */
1950 len_pointer = stream_get_endp (circuit->snd_stream) + 3 + ISIS_SYS_ID_LEN;
1951
1952 /* copy the shared part of the hello to the p2p hello if needed */
1953 if (circuit->circ_type == CIRCUIT_T_P2P)
1954 {
1955 memcpy (&p2p_hello_hdr, &hello_hdr, 5 + ISIS_SYS_ID_LEN);
1956 p2p_hello_hdr.local_id = circuit->circuit_id;
1957 /* FIXME: need better understanding */
1958 stream_put (circuit->snd_stream, &p2p_hello_hdr, ISIS_P2PHELLO_HDRLEN);
1959 }
1960 else
1961 {
1962 hello_hdr.prio = circuit->u.bc.priority[level - 1];
1963 if (level == 1 && circuit->u.bc.l1_desig_is)
1964 {
1965 memcpy (hello_hdr.lan_id, circuit->u.bc.l1_desig_is,
1966 ISIS_SYS_ID_LEN + 1);
1967 }
1968 else if (level == 2 && circuit->u.bc.l2_desig_is)
1969 {
1970 memcpy (hello_hdr.lan_id, circuit->u.bc.l2_desig_is,
1971 ISIS_SYS_ID_LEN + 1);
1972 }
1973 stream_put (circuit->snd_stream, &hello_hdr, ISIS_LANHELLO_HDRLEN);
1974 }
1975
1976 /*
1977 * Then the variable length part
1978 */
1979 /* add circuit password */
1980 if (circuit->passwd.type)
1981 if (tlv_add_authinfo (circuit->passwd.type, circuit->passwd.len,
1982 circuit->passwd.passwd, circuit->snd_stream))
1983 return ISIS_WARNING;
1984 /* Area Addresses TLV */
1985 assert (circuit->area);
1986 if (circuit->area->area_addrs && circuit->area->area_addrs->count > 0)
1987 if (tlv_add_area_addrs (circuit->area->area_addrs, circuit->snd_stream))
1988 return ISIS_WARNING;
1989
1990 /* LAN Neighbors TLV */
1991 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
1992 {
1993 if (level == 1 && circuit->u.bc.lan_neighs[0]->count > 0)
1994 if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[0],
1995 circuit->snd_stream))
1996 return ISIS_WARNING;
1997 if (level == 2 && circuit->u.bc.lan_neighs[1]->count > 0)
1998 if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[1],
1999 circuit->snd_stream))
2000 return ISIS_WARNING;
2001 }
2002
2003 /* Protocols Supported TLV */
2004 if (circuit->nlpids.count > 0)
2005 if (tlv_add_nlpid (&circuit->nlpids, circuit->snd_stream))
2006 return ISIS_WARNING;
2007 /* IP interface Address TLV */
2008 if (circuit->ip_router && circuit->ip_addrs && circuit->ip_addrs->count > 0)
2009 if (tlv_add_ip_addrs (circuit->ip_addrs, circuit->snd_stream))
2010 return ISIS_WARNING;
2011
2012 #ifdef HAVE_IPV6
2013 /* IPv6 Interface Address TLV */
2014 if (circuit->ipv6_router && circuit->ipv6_link &&
2015 circuit->ipv6_link->count > 0)
2016 if (tlv_add_ipv6_addrs (circuit->ipv6_link, circuit->snd_stream))
2017 return ISIS_WARNING;
2018 #endif /* HAVE_IPV6 */
2019
2020 if (circuit->u.bc.pad_hellos)
2021 if (tlv_add_padding (circuit->snd_stream))
2022 return ISIS_WARNING;
2023
2024 length = stream_get_endp (circuit->snd_stream);
2025 /* Update PDU length */
2026 stream_putw_at (circuit->snd_stream, len_pointer, (u_int16_t) length);
2027
2028 retval = circuit->tx (circuit, level);
2029 if (retval)
2030 zlog_warn ("sending of LAN Level %d Hello failed", level);
2031
2032 /* DEBUG_ADJ_PACKETS */
2033 if (isis->debugs & DEBUG_ADJ_PACKETS)
2034 {
2035 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
2036 {
2037 zlog_debug ("ISIS-Adj (%s): Sent L%d LAN IIH on %s, length %ld",
2038 circuit->area->area_tag, level, circuit->interface->name,
2039 /* FIXME: use %z when we stop supporting old compilers. */
2040 (unsigned long) STREAM_SIZE (circuit->snd_stream));
2041 }
2042 else
2043 {
2044 zlog_debug ("ISIS-Adj (%s): Sent P2P IIH on %s, length %ld",
2045 circuit->area->area_tag, circuit->interface->name,
2046 /* FIXME: use %z when we stop supporting old compilers. */
2047 (unsigned long) STREAM_SIZE (circuit->snd_stream));
2048 }
2049 }
2050
2051 return retval;
2052 }
2053
2054 static int
2055 send_lan_hello (struct isis_circuit *circuit, int level)
2056 {
2057 return send_hello (circuit, level);
2058 }
2059
2060 int
2061 send_lan_l1_hello (struct thread *thread)
2062 {
2063 struct isis_circuit *circuit;
2064 int retval;
2065
2066 circuit = THREAD_ARG (thread);
2067 assert (circuit);
2068 circuit->u.bc.t_send_lan_hello[0] = NULL;
2069
2070 if (circuit->u.bc.run_dr_elect[0])
2071 retval = isis_dr_elect (circuit, 1);
2072
2073 retval = send_lan_hello (circuit, 1);
2074
2075 /* set next timer thread */
2076 THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
2077 send_lan_l1_hello, circuit,
2078 isis_jitter (circuit->hello_interval[0], IIH_JITTER));
2079
2080 return retval;
2081 }
2082
2083 int
2084 send_lan_l2_hello (struct thread *thread)
2085 {
2086 struct isis_circuit *circuit;
2087 int retval;
2088
2089 circuit = THREAD_ARG (thread);
2090 assert (circuit);
2091 circuit->u.bc.t_send_lan_hello[1] = NULL;
2092
2093 if (circuit->u.bc.run_dr_elect[1])
2094 retval = isis_dr_elect (circuit, 2);
2095
2096 retval = send_lan_hello (circuit, 2);
2097
2098 /* set next timer thread */
2099 THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
2100 send_lan_l2_hello, circuit,
2101 isis_jitter (circuit->hello_interval[1], IIH_JITTER));
2102
2103 return retval;
2104 }
2105
2106 int
2107 send_p2p_hello (struct thread *thread)
2108 {
2109 struct isis_circuit *circuit;
2110
2111 circuit = THREAD_ARG (thread);
2112 assert (circuit);
2113 circuit->u.p2p.t_send_p2p_hello = NULL;
2114
2115 send_hello (circuit, 1);
2116
2117 /* set next timer thread */
2118 THREAD_TIMER_ON (master, circuit->u.p2p.t_send_p2p_hello, send_p2p_hello,
2119 circuit, isis_jitter (circuit->hello_interval[1],
2120 IIH_JITTER));
2121
2122 return ISIS_OK;
2123 }
2124
2125 static int
2126 build_csnp (int level, u_char * start, u_char * stop, struct list *lsps,
2127 struct isis_circuit *circuit)
2128 {
2129 struct isis_fixed_hdr fixed_hdr;
2130 struct isis_passwd *passwd;
2131 int retval = ISIS_OK;
2132 unsigned long lenp;
2133 u_int16_t length;
2134
2135 if (level == 1)
2136 fill_fixed_hdr_andstream (&fixed_hdr, L1_COMPLETE_SEQ_NUM,
2137 circuit->snd_stream);
2138 else
2139 fill_fixed_hdr_andstream (&fixed_hdr, L2_COMPLETE_SEQ_NUM,
2140 circuit->snd_stream);
2141
2142 /*
2143 * Fill Level 1 or 2 Complete Sequence Numbers header
2144 */
2145
2146 lenp = stream_get_endp (circuit->snd_stream);
2147 stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
2148 /* no need to send the source here, it is always us if we csnp */
2149 stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
2150 /* with zero circuit id - ref 9.10, 9.11 */
2151 stream_putc (circuit->snd_stream, 0x00);
2152
2153 stream_put (circuit->snd_stream, start, ISIS_SYS_ID_LEN + 2);
2154 stream_put (circuit->snd_stream, stop, ISIS_SYS_ID_LEN + 2);
2155
2156 /*
2157 * And TLVs
2158 */
2159 if (level == 1)
2160 passwd = &circuit->area->area_passwd;
2161 else
2162 passwd = &circuit->area->domain_passwd;
2163
2164 if (CHECK_FLAG(passwd->snp_auth, SNP_AUTH_SEND))
2165 if (passwd->type)
2166 retval = tlv_add_authinfo (passwd->type, passwd->len,
2167 passwd->passwd, circuit->snd_stream);
2168
2169 if (!retval && lsps)
2170 {
2171 retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
2172 }
2173 length = (u_int16_t) stream_get_endp (circuit->snd_stream);
2174 assert (length >= ISIS_CSNP_HDRLEN);
2175 /* Update PU length */
2176 stream_putw_at (circuit->snd_stream, lenp, length);
2177
2178 return retval;
2179 }
2180
2181 /*
2182 * FIXME: support multiple CSNPs
2183 */
2184
2185 int
2186 send_csnp (struct isis_circuit *circuit, int level)
2187 {
2188 int retval = ISIS_OK;
2189 u_char start[ISIS_SYS_ID_LEN + 2];
2190 u_char stop[ISIS_SYS_ID_LEN + 2];
2191 struct list *list = NULL;
2192 struct listnode *node;
2193 struct isis_lsp *lsp;
2194
2195 memset (start, 0x00, ISIS_SYS_ID_LEN + 2);
2196 memset (stop, 0xff, ISIS_SYS_ID_LEN + 2);
2197
2198 if (circuit->area->lspdb[level - 1] &&
2199 dict_count (circuit->area->lspdb[level - 1]) > 0)
2200 {
2201 list = list_new ();
2202 lsp_build_list (start, stop, list, circuit->area->lspdb[level - 1]);
2203
2204 if (circuit->snd_stream == NULL)
2205 circuit->snd_stream = stream_new (ISO_MTU (circuit));
2206 else
2207 stream_reset (circuit->snd_stream);
2208
2209 retval = build_csnp (level, start, stop, list, circuit);
2210
2211 if (isis->debugs & DEBUG_SNP_PACKETS)
2212 {
2213 zlog_debug ("ISIS-Snp (%s): Sent L%d CSNP on %s, length %ld",
2214 circuit->area->area_tag, level, circuit->interface->name,
2215 /* FIXME: use %z when we stop supporting old compilers. */
2216 (unsigned long) STREAM_SIZE (circuit->snd_stream));
2217 for (ALL_LIST_ELEMENTS_RO (list, node, lsp))
2218 {
2219 zlog_debug ("ISIS-Snp (%s): CSNP entry %s, seq 0x%08x,"
2220 " cksum 0x%04x, lifetime %us",
2221 circuit->area->area_tag,
2222 rawlspid_print (lsp->lsp_header->lsp_id),
2223 ntohl (lsp->lsp_header->seq_num),
2224 ntohs (lsp->lsp_header->checksum),
2225 ntohs (lsp->lsp_header->rem_lifetime));
2226 }
2227 }
2228
2229 list_delete (list);
2230
2231 if (retval == ISIS_OK)
2232 retval = circuit->tx (circuit, level);
2233 }
2234 return retval;
2235 }
2236
2237 int
2238 send_l1_csnp (struct thread *thread)
2239 {
2240 struct isis_circuit *circuit;
2241 int retval = ISIS_OK;
2242
2243 circuit = THREAD_ARG (thread);
2244 assert (circuit);
2245
2246 circuit->t_send_csnp[0] = NULL;
2247
2248 if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[0])
2249 {
2250 send_csnp (circuit, 1);
2251 }
2252 /* set next timer thread */
2253 THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
2254 isis_jitter (circuit->csnp_interval[0], CSNP_JITTER));
2255
2256 return retval;
2257 }
2258
2259 int
2260 send_l2_csnp (struct thread *thread)
2261 {
2262 struct isis_circuit *circuit;
2263 int retval = ISIS_OK;
2264
2265 circuit = THREAD_ARG (thread);
2266 assert (circuit);
2267
2268 circuit->t_send_csnp[1] = NULL;
2269
2270 if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[1])
2271 {
2272 send_csnp (circuit, 2);
2273 }
2274 /* set next timer thread */
2275 THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
2276 isis_jitter (circuit->csnp_interval[1], CSNP_JITTER));
2277
2278 return retval;
2279 }
2280
2281 static int
2282 build_psnp (int level, struct isis_circuit *circuit, struct list *lsps)
2283 {
2284 struct isis_fixed_hdr fixed_hdr;
2285 unsigned long lenp;
2286 u_int16_t length;
2287 int retval = 0;
2288 struct isis_lsp *lsp;
2289 struct isis_passwd *passwd;
2290 struct listnode *node;
2291
2292 if (level == 1)
2293 fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
2294 circuit->snd_stream);
2295 else
2296 fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
2297 circuit->snd_stream);
2298
2299 /*
2300 * Fill Level 1 or 2 Partial Sequence Numbers header
2301 */
2302 lenp = stream_get_endp (circuit->snd_stream);
2303 stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
2304 stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
2305 stream_putc (circuit->snd_stream, circuit->idx);
2306
2307 /*
2308 * And TLVs
2309 */
2310
2311 if (level == 1)
2312 passwd = &circuit->area->area_passwd;
2313 else
2314 passwd = &circuit->area->domain_passwd;
2315
2316 if (CHECK_FLAG(passwd->snp_auth, SNP_AUTH_SEND))
2317 if (passwd->type)
2318 retval = tlv_add_authinfo (passwd->type, passwd->len,
2319 passwd->passwd, circuit->snd_stream);
2320
2321 if (!retval && lsps)
2322 {
2323 retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
2324 }
2325
2326 if (isis->debugs & DEBUG_SNP_PACKETS)
2327 {
2328 for (ALL_LIST_ELEMENTS_RO (lsps, node, lsp))
2329 {
2330 zlog_debug ("ISIS-Snp (%s): PSNP entry %s, seq 0x%08x,"
2331 " cksum 0x%04x, lifetime %us",
2332 circuit->area->area_tag,
2333 rawlspid_print (lsp->lsp_header->lsp_id),
2334 ntohl (lsp->lsp_header->seq_num),
2335 ntohs (lsp->lsp_header->checksum),
2336 ntohs (lsp->lsp_header->rem_lifetime));
2337 }
2338 }
2339
2340 length = (u_int16_t) stream_get_endp (circuit->snd_stream);
2341 assert (length >= ISIS_PSNP_HDRLEN);
2342 /* Update PDU length */
2343 stream_putw_at (circuit->snd_stream, lenp, length);
2344
2345 return ISIS_OK;
2346 }
2347
2348 /*
2349 * 7.3.15.4 action on expiration of partial SNP interval
2350 * level 1
2351 */
2352 static int
2353 send_psnp (int level, struct isis_circuit *circuit)
2354 {
2355 int retval = ISIS_OK;
2356 struct isis_lsp *lsp;
2357 struct list *list = NULL;
2358 struct listnode *node;
2359
2360 if ((circuit->circ_type == CIRCUIT_T_BROADCAST &&
2361 !circuit->u.bc.is_dr[level - 1]) ||
2362 circuit->circ_type != CIRCUIT_T_BROADCAST)
2363 {
2364
2365 if (circuit->area->lspdb[level - 1] &&
2366 dict_count (circuit->area->lspdb[level - 1]) > 0)
2367 {
2368 list = list_new ();
2369 lsp_build_list_ssn (circuit, list, circuit->area->lspdb[level - 1]);
2370
2371 if (listcount (list) > 0)
2372 {
2373 if (circuit->snd_stream == NULL)
2374 circuit->snd_stream = stream_new (ISO_MTU (circuit));
2375 else
2376 stream_reset (circuit->snd_stream);
2377
2378
2379 if (isis->debugs & DEBUG_SNP_PACKETS)
2380 zlog_debug ("ISIS-Snp (%s): Sent L%d PSNP on %s, length %ld",
2381 circuit->area->area_tag, level,
2382 circuit->interface->name,
2383 /* FIXME: use %z when we stop supporting old
2384 * compilers. */
2385 (unsigned long) STREAM_SIZE (circuit->snd_stream));
2386
2387 retval = build_psnp (level, circuit, list);
2388 if (retval == ISIS_OK)
2389 retval = circuit->tx (circuit, level);
2390
2391 if (retval == ISIS_OK)
2392 {
2393 /*
2394 * sending succeeded, we can clear SSN flags of this circuit
2395 * for the LSPs in list
2396 */
2397 for (ALL_LIST_ELEMENTS_RO (list, node, lsp))
2398 ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
2399 }
2400 }
2401 list_delete (list);
2402 }
2403 }
2404
2405 return retval;
2406 }
2407
2408 int
2409 send_l1_psnp (struct thread *thread)
2410 {
2411
2412 struct isis_circuit *circuit;
2413 int retval = ISIS_OK;
2414
2415 circuit = THREAD_ARG (thread);
2416 assert (circuit);
2417
2418 circuit->t_send_psnp[0] = NULL;
2419
2420 send_psnp (1, circuit);
2421 /* set next timer thread */
2422 THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
2423 isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
2424
2425 return retval;
2426 }
2427
2428 /*
2429 * 7.3.15.4 action on expiration of partial SNP interval
2430 * level 2
2431 */
2432 int
2433 send_l2_psnp (struct thread *thread)
2434 {
2435 struct isis_circuit *circuit;
2436 int retval = ISIS_OK;
2437
2438 circuit = THREAD_ARG (thread);
2439 assert (circuit);
2440
2441 circuit->t_send_psnp[1] = NULL;
2442
2443 send_psnp (2, circuit);
2444
2445 /* set next timer thread */
2446 THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
2447 isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
2448
2449 return retval;
2450 }
2451
2452 /*
2453 * ISO 10589 - 7.3.14.3
2454 */
2455 int
2456 send_lsp (struct thread *thread)
2457 {
2458 struct isis_circuit *circuit;
2459 struct isis_lsp *lsp;
2460 struct listnode *node;
2461 int retval = 0;
2462
2463 circuit = THREAD_ARG (thread);
2464 assert (circuit);
2465
2466 if (circuit->state == C_STATE_UP)
2467 {
2468 lsp = listgetdata ((node = listhead (circuit->lsp_queue)));
2469
2470 /*
2471 * Do not send if levels do not match
2472 */
2473 if (!(lsp->level & circuit->circuit_is_type))
2474 goto dontsend;
2475
2476 /*
2477 * Do not send if we do not have adjacencies in state up on the circuit
2478 */
2479 if (circuit->upadjcount[lsp->level - 1] == 0)
2480 goto dontsend;
2481 /* only send if it needs sending */
2482 if ((time (NULL) - lsp->last_sent) >=
2483 circuit->area->lsp_gen_interval[lsp->level - 1])
2484 {
2485
2486 if (isis->debugs & DEBUG_UPDATE_PACKETS)
2487 {
2488 zlog_debug
2489 ("ISIS-Upd (%s): Sent L%d LSP %s, seq 0x%08x, cksum 0x%04x,"
2490 " lifetime %us on %s", circuit->area->area_tag, lsp->level,
2491 rawlspid_print (lsp->lsp_header->lsp_id),
2492 ntohl (lsp->lsp_header->seq_num),
2493 ntohs (lsp->lsp_header->checksum),
2494 ntohs (lsp->lsp_header->rem_lifetime),
2495 circuit->interface->name);
2496 }
2497 /* copy our lsp to the send buffer */
2498 stream_copy (circuit->snd_stream, lsp->pdu);
2499
2500 retval = circuit->tx (circuit, lsp->level);
2501
2502 /*
2503 * If the sending succeeded, we can del the lsp from circuits
2504 * lsp_queue
2505 */
2506 if (retval == ISIS_OK)
2507 {
2508 list_delete_node (circuit->lsp_queue, node);
2509
2510 /*
2511 * On broadcast circuits also the SRMflag can be cleared
2512 */
2513 if (circuit->circ_type == CIRCUIT_T_BROADCAST)
2514 ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
2515
2516 if (flags_any_set (lsp->SRMflags) == 0)
2517 {
2518 /*
2519 * need to remember when we were last sent
2520 */
2521 lsp->last_sent = time (NULL);
2522 }
2523 }
2524 else
2525 {
2526 zlog_debug ("sending of level %d link state failed", lsp->level);
2527 }
2528 }
2529 else
2530 {
2531 /* my belief is that if it wasn't his time, the lsp can be removed
2532 * from the queue
2533 */
2534 dontsend:
2535 list_delete_node (circuit->lsp_queue, node);
2536 }
2537 #if 0
2538 /*
2539 * If there are still LSPs send next one after lsp-interval (33 msecs)
2540 */
2541 if (listcount (circuit->lsp_queue) > 0)
2542 thread_add_timer (master, send_lsp, circuit, 1);
2543 #endif
2544 }
2545
2546 return retval;
2547 }
2548
2549 int
2550 ack_lsp (struct isis_link_state_hdr *hdr, struct isis_circuit *circuit,
2551 int level)
2552 {
2553 unsigned long lenp;
2554 int retval;
2555 u_int16_t length;
2556 struct isis_fixed_hdr fixed_hdr;
2557
2558 if (!circuit->snd_stream)
2559 circuit->snd_stream = stream_new (ISO_MTU (circuit));
2560 else
2561 stream_reset (circuit->snd_stream);
2562
2563 // fill_llc_hdr (stream);
2564 if (level == 1)
2565 fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
2566 circuit->snd_stream);
2567 else
2568 fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
2569 circuit->snd_stream);
2570
2571
2572 lenp = stream_get_endp (circuit->snd_stream);
2573 stream_putw (circuit->snd_stream, 0); /* PDU length */
2574 stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
2575 stream_putc (circuit->snd_stream, circuit->idx);
2576 stream_putc (circuit->snd_stream, 9); /* code */
2577 stream_putc (circuit->snd_stream, 16); /* len */
2578
2579 stream_putw (circuit->snd_stream, ntohs (hdr->rem_lifetime));
2580 stream_put (circuit->snd_stream, hdr->lsp_id, ISIS_SYS_ID_LEN + 2);
2581 stream_putl (circuit->snd_stream, ntohl (hdr->seq_num));
2582 stream_putw (circuit->snd_stream, ntohs (hdr->checksum));
2583
2584 length = (u_int16_t) stream_get_endp (circuit->snd_stream);
2585 /* Update PDU length */
2586 stream_putw_at (circuit->snd_stream, lenp, length);
2587
2588 retval = circuit->tx (circuit, level);
2589
2590 return retval;
2591 }
2592
Various project for quagga