2 * IS-IS Rout(e)ing protocol - isis_lsp.c
5 * Copyright (C) 2001,2002 Sampo Saaristo
6 * Tampere University of Technology
7 * Institute of Communications Engineering
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)
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
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.
38 #include "isisd/dict.h"
39 #include "isisd/isis_constants.h"
40 #include "isisd/isis_common.h"
41 #include "isisd/isis_circuit.h"
42 #include "isisd/isisd.h"
43 #include "isisd/isis_tlv.h"
44 #include "isisd/isis_lsp.h"
45 #include "isisd/isis_pdu.h"
46 #include "isisd/isis_dynhn.h"
47 #include "isisd/isis_misc.h"
48 #include "isisd/isis_flags.h"
49 #include "isisd/iso_checksum.h"
50 #include "isisd/isis_csm.h"
51 #include "isisd/isis_adjacency.h"
52 #include "isisd/isis_spf.h"
54 #ifdef TOPOLOGY_GENERATE
58 #define LSP_MEMORY_PREASSIGN
60 extern struct isis
*isis
;
61 extern struct thread_master
*master
;
62 extern struct in_addr router_id_zebra
;
64 /* staticly assigned vars for printing purposes */
65 char lsp_bits_string
[200]; /* FIXME: enough ? */
68 lsp_id_cmp (u_char
* id1
, u_char
* id2
)
70 return memcmp (id1
, id2
, ISIS_SYS_ID_LEN
+ 2);
78 dict
= dict_create (DICTCOUNT_T_MAX
, (dict_comp_t
) lsp_id_cmp
);
84 lsp_search (u_char
* id
, dict_t
* lspdb
)
91 zlog_debug ("searching db");
92 for (dn
= dict_first (lspdb
); dn
; dn
= dict_next (lspdb
, dn
))
94 zlog_debug ("%s\t%pX", rawlspid_print ((char *) dnode_getkey (dn
)),
97 #endif /* EXTREME DEBUG */
99 node
= dict_lookup (lspdb
, id
);
102 return (struct isis_lsp
*) dnode_get (node
);
108 lsp_clear_data (struct isis_lsp
*lsp
)
115 if (lsp
->tlv_data
.nlpids
)
116 XFREE (MTYPE_ISIS_TLV
, lsp
->tlv_data
.nlpids
);
117 if (lsp
->tlv_data
.hostname
)
118 XFREE (MTYPE_ISIS_TLV
, lsp
->tlv_data
.hostname
);
120 if (lsp
->tlv_data
.is_neighs
)
121 list_delete (lsp
->tlv_data
.is_neighs
);
122 if (lsp
->tlv_data
.area_addrs
)
123 list_delete (lsp
->tlv_data
.area_addrs
);
124 if (lsp
->tlv_data
.es_neighs
)
125 list_delete (lsp
->tlv_data
.es_neighs
);
126 if (lsp
->tlv_data
.ipv4_addrs
)
127 list_delete (lsp
->tlv_data
.ipv4_addrs
);
128 if (lsp
->tlv_data
.ipv4_int_reachs
)
129 list_delete (lsp
->tlv_data
.ipv4_int_reachs
);
130 if (lsp
->tlv_data
.ipv4_ext_reachs
)
131 list_delete (lsp
->tlv_data
.ipv4_ext_reachs
);
133 if (lsp
->tlv_data
.ipv6_addrs
)
134 list_delete (lsp
->tlv_data
.ipv6_addrs
);
135 if (lsp
->tlv_data
.ipv6_reachs
)
136 list_delete (lsp
->tlv_data
.ipv6_reachs
);
137 #endif /* HAVE_IPV6 */
139 memset (&lsp
->tlv_data
, 0, sizeof (struct tlvs
));
145 lsp_destroy (struct isis_lsp
*lsp
)
150 lsp_clear_data (lsp
);
152 if (LSP_FRAGMENT (lsp
->lsp_header
->lsp_id
) == 0 && lsp
->lspu
.frags
)
154 list_delete (lsp
->lspu
.frags
);
158 stream_free (lsp
->pdu
);
159 XFREE (MTYPE_ISIS_LSP
, lsp
);
163 lsp_db_destroy (dict_t
* lspdb
)
165 dnode_t
*dnode
, *next
;
166 struct isis_lsp
*lsp
;
168 dnode
= dict_first (lspdb
);
171 next
= dict_next (lspdb
, dnode
);
172 lsp
= dnode_get (dnode
);
174 dict_delete_free (lspdb
, dnode
);
184 * Remove all the frags belonging to the given lsp
187 lsp_remove_frags (struct list
*frags
, dict_t
* lspdb
)
190 struct listnode
*lnode
;
191 struct isis_lsp
*lsp
;
193 for (lnode
= listhead (frags
); lnode
; nextnode (lnode
))
195 lsp
= getdata (lnode
);
196 dnode
= dict_lookup (lspdb
, lsp
->lsp_header
->lsp_id
);
198 dnode_destroy (dict_delete (lspdb
, dnode
));
201 list_delete_all_node (frags
);
207 lsp_search_and_destroy (u_char
* id
, dict_t
* lspdb
)
210 struct isis_lsp
*lsp
;
212 node
= dict_lookup (lspdb
, id
);
215 node
= dict_delete (lspdb
, node
);
216 lsp
= dnode_get (node
);
218 * If this is a zero lsp, remove all the frags now
220 if (LSP_FRAGMENT (lsp
->lsp_header
->lsp_id
) == 0)
223 lsp_remove_frags (lsp
->lspu
.frags
, lspdb
);
228 * else just remove this frag, from the zero lsps' frag list
230 if (lsp
->lspu
.zero_lsp
&& lsp
->lspu
.zero_lsp
->lspu
.frags
)
231 listnode_delete (lsp
->lspu
.zero_lsp
->lspu
.frags
, lsp
);
234 dnode_destroy (node
);
239 * Compares a LSP to given values
240 * Params are given in net order
243 lsp_compare (char *areatag
, struct isis_lsp
*lsp
, u_int32_t seq_num
,
244 u_int16_t checksum
, u_int16_t rem_lifetime
)
246 /* no point in double ntohl on seqnum */
247 if (lsp
->lsp_header
->seq_num
== seq_num
&&
248 lsp
->lsp_header
->checksum
== checksum
&&
249 /*comparing with 0, no need to do ntohl */
250 ((lsp
->lsp_header
->rem_lifetime
== 0 && rem_lifetime
== 0) ||
251 (lsp
->lsp_header
->rem_lifetime
!= 0 && rem_lifetime
!= 0)))
253 if (isis
->debugs
& DEBUG_SNP_PACKETS
)
255 zlog_debug ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x,"
258 rawlspid_print (lsp
->lsp_header
->lsp_id
),
259 ntohl (lsp
->lsp_header
->seq_num
),
260 ntohs (lsp
->lsp_header
->checksum
),
261 ntohs (lsp
->lsp_header
->rem_lifetime
));
262 zlog_debug ("ISIS-Snp (%s): is equal to ours seq 0x%08x,"
263 " cksum 0x%04x, lifetime %us",
265 ntohl (seq_num
), ntohs (checksum
), ntohs (rem_lifetime
));
270 if (ntohl (seq_num
) >= ntohl (lsp
->lsp_header
->seq_num
))
272 if (isis
->debugs
& DEBUG_SNP_PACKETS
)
274 zlog_debug ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x,"
277 rawlspid_print (lsp
->lsp_header
->lsp_id
),
278 ntohl (seq_num
), ntohs (checksum
), ntohs (rem_lifetime
));
279 zlog_debug ("ISIS-Snp (%s): is newer than ours seq 0x%08x, "
280 "cksum 0x%04x, lifetime %us",
282 ntohl (lsp
->lsp_header
->seq_num
),
283 ntohs (lsp
->lsp_header
->checksum
),
284 ntohs (lsp
->lsp_header
->rem_lifetime
));
288 if (isis
->debugs
& DEBUG_SNP_PACKETS
)
291 ("ISIS-Snp (%s): LSP %s seq 0x%08x, cksum 0x%04x, lifetime %us",
292 areatag
, rawlspid_print (lsp
->lsp_header
->lsp_id
), ntohl (seq_num
),
293 ntohs (checksum
), ntohs (rem_lifetime
));
294 zlog_debug ("ISIS-Snp (%s): is older than ours seq 0x%08x,"
295 " cksum 0x%04x, lifetime %us", areatag
,
296 ntohl (lsp
->lsp_header
->seq_num
),
297 ntohs (lsp
->lsp_header
->checksum
),
298 ntohs (lsp
->lsp_header
->rem_lifetime
));
305 lsp_inc_seqnum (struct isis_lsp
*lsp
, u_int32_t seq_num
)
309 if (seq_num
== 0 || ntohl (lsp
->lsp_header
->seq_num
) > seq_num
)
310 newseq
= ntohl (lsp
->lsp_header
->seq_num
) + 1;
314 lsp
->lsp_header
->seq_num
= htonl (newseq
);
315 iso_csum_create (STREAM_DATA (lsp
->pdu
) + 12,
316 ntohs (lsp
->lsp_header
->pdu_len
) - 12, 12);
322 * Genetates checksum for LSP and its frags
325 lsp_seqnum_update (struct isis_lsp
*lsp0
)
327 struct isis_lsp
*lsp
;
328 struct listnode
*node
;
330 lsp_inc_seqnum (lsp0
, 0);
332 if (!lsp0
->lspu
.frags
)
335 for (node
= listhead (lsp0
->lspu
.frags
); node
; nextnode (node
))
337 lsp
= getdata (node
);
338 lsp_inc_seqnum (lsp
, 0);
345 isis_lsp_authinfo_check (struct stream
*stream
, struct isis_area
*area
,
346 int pdulen
, struct isis_passwd
*passwd
)
348 uint32_t expected
= 0, found
;
352 expected
|= TLVFLAG_AUTH_INFO
;
353 retval
= parse_tlvs (area
->area_tag
, stream
->data
+
354 ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
,
355 pdulen
- ISIS_FIXED_HDR_LEN
356 - ISIS_LSP_HDR_LEN
, &expected
, &found
, &tlvs
);
357 if (retval
|| !(found
& TLVFLAG_AUTH_INFO
))
358 return 1; /* Auth fail (parsing failed or no auth-tlv) */
360 return authentication_check (passwd
, &tlvs
.auth_info
);
364 lsp_update_data (struct isis_lsp
*lsp
, struct stream
*stream
,
365 struct isis_area
*area
)
367 uint32_t expected
= 0, found
;
370 /* copying only the relevant part of our stream */
371 lsp
->pdu
= stream_new (stream
->endp
);
372 lsp
->pdu
->getp
= stream
->getp
;
373 lsp
->pdu
->endp
= stream
->endp
;
374 memcpy (lsp
->pdu
->data
, stream
->data
, stream
->endp
);
376 /* setting pointers to the correct place */
377 lsp
->isis_header
= (struct isis_fixed_hdr
*) (STREAM_DATA (lsp
->pdu
));
378 lsp
->lsp_header
= (struct isis_link_state_hdr
*) (STREAM_DATA (lsp
->pdu
) +
380 lsp
->age_out
= ZERO_AGE_LIFETIME
;
381 lsp
->installed
= time (NULL
);
383 * Get LSP data i.e. TLVs
385 expected
|= TLVFLAG_AUTH_INFO
;
386 expected
|= TLVFLAG_AREA_ADDRS
;
387 expected
|= TLVFLAG_IS_NEIGHS
;
388 if ((lsp
->lsp_header
->lsp_bits
& 3) == 3) /* a level 2 LSP */
389 expected
|= TLVFLAG_PARTITION_DESIG_LEVEL2_IS
;
390 expected
|= TLVFLAG_NLPID
;
391 if (area
->dynhostname
)
392 expected
|= TLVFLAG_DYN_HOSTNAME
;
395 expected
|= TLVFLAG_TE_IS_NEIGHS
;
396 expected
|= TLVFLAG_TE_IPV4_REACHABILITY
;
397 expected
|= TLVFLAG_TE_ROUTER_ID
;
399 expected
|= TLVFLAG_IPV4_ADDR
;
400 expected
|= TLVFLAG_IPV4_INT_REACHABILITY
;
401 expected
|= TLVFLAG_IPV4_EXT_REACHABILITY
;
403 expected
|= TLVFLAG_IPV6_ADDR
;
404 expected
|= TLVFLAG_IPV6_REACHABILITY
;
405 #endif /* HAVE_IPV6 */
407 retval
= parse_tlvs (area
->area_tag
, lsp
->pdu
->data
+
408 ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
,
409 ntohs (lsp
->lsp_header
->pdu_len
) - ISIS_FIXED_HDR_LEN
410 - ISIS_LSP_HDR_LEN
, &expected
, &found
, &lsp
->tlv_data
);
412 if (found
& TLVFLAG_DYN_HOSTNAME
)
414 if (area
->dynhostname
)
415 isis_dynhn_insert (lsp
->lsp_header
->lsp_id
, lsp
->tlv_data
.hostname
,
416 (lsp
->lsp_header
->lsp_bits
& LSPBIT_IST
) ==
417 IS_LEVEL_1_AND_2
? IS_LEVEL_2
:
418 (lsp
->lsp_header
->lsp_bits
& LSPBIT_IST
));
424 lsp_update (struct isis_lsp
*lsp
, struct isis_link_state_hdr
*lsp_hdr
,
425 struct stream
*stream
, struct isis_area
*area
)
427 /* free the old lsp data */
428 XFREE (MTYPE_STREAM_DATA
, lsp
->pdu
);
429 lsp_clear_data (lsp
);
431 /* rebuild the lsp data */
432 lsp_update_data (lsp
, stream
, area
);
434 /* set the new values for lsp header */
435 memcpy (lsp
->lsp_header
, lsp_hdr
, ISIS_LSP_HDR_LEN
);
438 /* creation of LSP directly from what we received */
440 lsp_new_from_stream_ptr (struct stream
*stream
,
441 u_int16_t pdu_len
, struct isis_lsp
*lsp0
,
442 struct isis_area
*area
)
444 struct isis_lsp
*lsp
;
446 lsp
= XMALLOC (MTYPE_ISIS_LSP
, sizeof (struct isis_lsp
));
447 memset (lsp
, 0, sizeof (struct isis_lsp
));
449 lsp_update_data (lsp
, stream
, area
);
454 * zero lsp -> create the list for fragments
456 lsp
->lspu
.frags
= list_new ();
461 * a fragment -> set the backpointer and add this to zero lsps frag list
463 lsp
->lspu
.zero_lsp
= lsp0
;
464 listnode_add (lsp0
->lspu
.frags
, lsp
);
471 lsp_new (u_char
* lsp_id
, u_int16_t rem_lifetime
, u_int32_t seq_num
,
472 u_int8_t lsp_bits
, u_int16_t checksum
, int level
)
474 struct isis_lsp
*lsp
;
476 lsp
= XMALLOC (MTYPE_ISIS_LSP
, sizeof (struct isis_lsp
));
479 /* FIXME: set lspdbol bit */
480 zlog_warn ("lsp_new(): out of memory");
483 memset (lsp
, 0, sizeof (struct isis_lsp
));
484 #ifdef LSP_MEMORY_PREASSIGN
485 lsp
->pdu
= stream_new (1514); /*Should be minimal mtu? yup... */
487 /* We need to do realloc on TLVs additions */
488 lsp
->pdu
= malloc (ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
489 #endif /* LSP_MEMORY_PREASSIGN */
490 if (LSP_FRAGMENT (lsp_id
) == 0)
491 lsp
->lspu
.frags
= list_new ();
492 lsp
->isis_header
= (struct isis_fixed_hdr
*) (STREAM_DATA (lsp
->pdu
));
493 lsp
->lsp_header
= (struct isis_link_state_hdr
*)
494 (STREAM_DATA (lsp
->pdu
) + ISIS_FIXED_HDR_LEN
);
496 /* at first we fill the FIXED HEADER */
497 (level
== 1) ? fill_fixed_hdr (lsp
->isis_header
, L1_LINK_STATE
) :
498 fill_fixed_hdr (lsp
->isis_header
, L2_LINK_STATE
);
500 /* now for the LSP HEADER */
501 /* Minimal LSP PDU size */
502 lsp
->lsp_header
->pdu_len
= htons (ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
503 memcpy (lsp
->lsp_header
->lsp_id
, lsp_id
, ISIS_SYS_ID_LEN
+ 2);
504 lsp
->lsp_header
->checksum
= checksum
; /* Provided in network order */
505 lsp
->lsp_header
->seq_num
= htonl (seq_num
);
506 lsp
->lsp_header
->rem_lifetime
= htons (rem_lifetime
);
507 lsp
->lsp_header
->lsp_bits
= lsp_bits
;
509 lsp
->age_out
= ZERO_AGE_LIFETIME
;
511 stream_forward_endp (lsp
->pdu
, ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
513 /* #ifdef EXTREME_DEBUG */
515 zlog_debug ("New LSP with ID %s-%02x-%02x seqnum %08x", sysid_print (lsp_id
),
516 LSP_PSEUDO_ID (lsp
->lsp_header
->lsp_id
),
517 LSP_FRAGMENT (lsp
->lsp_header
->lsp_id
),
518 ntohl (lsp
->lsp_header
->seq_num
));
519 /* #endif EXTREME DEBUG */
525 lsp_insert (struct isis_lsp
*lsp
, dict_t
* lspdb
)
527 dict_alloc_insert (lspdb
, lsp
->lsp_header
->lsp_id
, lsp
);
531 * Build a list of LSPs with non-zero ht bounded by start and stop ids
534 lsp_build_list_nonzero_ht (u_char
* start_id
, u_char
* stop_id
,
535 struct list
*list
, dict_t
* lspdb
)
537 dnode_t
*first
, *last
, *curr
;
539 first
= dict_lower_bound (lspdb
, start_id
);
543 last
= dict_upper_bound (lspdb
, stop_id
);
547 if (((struct isis_lsp
*) (curr
->dict_data
))->lsp_header
->rem_lifetime
)
548 listnode_add (list
, first
->dict_data
);
552 curr
= dict_next (lspdb
, curr
);
554 ((struct isis_lsp
*) (curr
->dict_data
))->lsp_header
->rem_lifetime
)
555 listnode_add (list
, curr
->dict_data
);
564 * Build a list of all LSPs bounded by start and stop ids
567 lsp_build_list (u_char
* start_id
, u_char
* stop_id
,
568 struct list
*list
, dict_t
* lspdb
)
570 dnode_t
*first
, *last
, *curr
;
572 first
= dict_lower_bound (lspdb
, start_id
);
576 last
= dict_upper_bound (lspdb
, stop_id
);
580 listnode_add (list
, first
->dict_data
);
584 curr
= dict_next (lspdb
, curr
);
586 listnode_add (list
, curr
->dict_data
);
595 * Build a list of LSPs with SSN flag set for the given circuit
598 lsp_build_list_ssn (struct isis_circuit
*circuit
, struct list
*list
,
601 dnode_t
*dnode
, *next
;
602 struct isis_lsp
*lsp
;
604 dnode
= dict_first (lspdb
);
605 while (dnode
!= NULL
)
607 next
= dict_next (lspdb
, dnode
);
608 lsp
= dnode_get (dnode
);
609 if (ISIS_CHECK_FLAG (lsp
->SSNflags
, circuit
))
610 listnode_add (list
, lsp
);
618 lsp_set_time (struct isis_lsp
*lsp
)
622 if (lsp
->lsp_header
->rem_lifetime
== 0)
624 if (lsp
->age_out
!= 0)
629 /* If we are turning 0 */
630 /* ISO 10589 - 7.3.16.4 first paragraph */
632 if (ntohs (lsp
->lsp_header
->rem_lifetime
) == 1)
634 /* 7.3.16.4 a) set SRM flags on all */
635 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
636 /* 7.3.16.4 b) retain only the header FIXME */
637 /* 7.3.16.4 c) record the time to purge FIXME (other way to do it) */
640 lsp
->lsp_header
->rem_lifetime
=
641 htons (ntohs (lsp
->lsp_header
->rem_lifetime
) - 1);
645 lspid_print (u_char
* lsp_id
, u_char
* trg
, char dynhost
, char frag
)
647 struct isis_dynhn
*dyn
= NULL
;
648 u_char id
[SYSID_STRLEN
];
651 dyn
= dynhn_find_by_id (lsp_id
);
656 sprintf ((char *)id
, "%.14s", dyn
->name
.name
);
657 else if (!memcmp (isis
->sysid
, lsp_id
, ISIS_SYS_ID_LEN
) & dynhost
)
658 sprintf ((char *)id
, "%.14s", unix_hostname ());
661 memcpy (id
, sysid_print (lsp_id
), 15);
664 sprintf ((char *)trg
, "%s.%02x-%02x", id
, LSP_PSEUDO_ID (lsp_id
),
665 LSP_FRAGMENT (lsp_id
));
667 sprintf ((char *)trg
, "%s.%02x", id
, LSP_PSEUDO_ID (lsp_id
));
670 /* Convert the lsp attribute bits to attribute string */
672 lsp_bits2string (u_char
* lsp_bits
)
674 char *pos
= lsp_bits_string
;
679 /* we only focus on the default metric */
680 pos
+= sprintf (pos
, "%d/",
681 ISIS_MASK_LSP_ATT_DEFAULT_BIT (*lsp_bits
) ? 1 : 0);
683 pos
+= sprintf (pos
, "%d/",
684 ISIS_MASK_LSP_PARTITION_BIT (*lsp_bits
) ? 1 : 0);
686 pos
+= sprintf (pos
, "%d", ISIS_MASK_LSP_OL_BIT (*lsp_bits
) ? 1 : 0);
690 return lsp_bits_string
;
693 /* this function prints the lsp on show isis database */
695 lsp_print (dnode_t
* node
, struct vty
*vty
, char dynhost
)
697 struct isis_lsp
*lsp
= dnode_get (node
);
700 lspid_print (lsp
->lsp_header
->lsp_id
, LSPid
, dynhost
, 1);
701 vty_out (vty
, "%-21s%c ", LSPid
, lsp
->own_lsp
? '*' : ' ');
702 vty_out (vty
, "0x%08x ", ntohl (lsp
->lsp_header
->seq_num
));
703 vty_out (vty
, "0x%04x ", ntohs (lsp
->lsp_header
->checksum
));
705 if (ntohs (lsp
->lsp_header
->rem_lifetime
) == 0)
706 vty_out (vty
, " (%2u)", lsp
->age_out
);
708 vty_out (vty
, "%5u", ntohs (lsp
->lsp_header
->rem_lifetime
));
710 vty_out (vty
, " %s%s",
711 lsp_bits2string (&lsp
->lsp_header
->lsp_bits
), VTY_NEWLINE
);
715 lsp_print_detail (dnode_t
* node
, struct vty
*vty
, char dynhost
)
717 struct isis_lsp
*lsp
= dnode_get (node
);
718 struct area_addr
*area_addr
;
720 struct listnode
*lnode
;
721 struct is_neigh
*is_neigh
;
722 struct te_is_neigh
*te_is_neigh
;
723 struct ipv4_reachability
*ipv4_reach
;
724 struct in_addr
*ipv4_addr
;
725 struct te_ipv4_reachability
*te_ipv4_reach
;
727 struct ipv6_reachability
*ipv6_reach
;
731 u_char hostname
[255];
733 u_char ipv4_reach_prefix
[20];
734 u_char ipv4_reach_mask
[20];
735 u_char ipv4_address
[20];
737 lspid_print (lsp
->lsp_header
->lsp_id
, LSPid
, dynhost
, 1);
738 lsp_print (node
, vty
, dynhost
);
740 /* for all area address */
741 if (lsp
->tlv_data
.area_addrs
)
743 LIST_LOOP (lsp
->tlv_data
.area_addrs
, area_addr
, lnode
)
745 vty_out (vty
, " Area Address: %s%s",
746 isonet_print (area_addr
->area_addr
, area_addr
->addr_len
),
751 /* for the nlpid tlv */
752 if (lsp
->tlv_data
.nlpids
)
754 for (i
= 0; i
< lsp
->tlv_data
.nlpids
->count
; i
++)
756 switch (lsp
->tlv_data
.nlpids
->nlpids
[i
])
760 vty_out (vty
, " NLPID: 0x%X%s",
761 lsp
->tlv_data
.nlpids
->nlpids
[i
], VTY_NEWLINE
);
764 vty_out (vty
, " NLPID: %s%s", "unknown", VTY_NEWLINE
);
770 /* for the hostname tlv */
771 if (lsp
->tlv_data
.hostname
)
773 bzero (hostname
, sizeof (hostname
));
774 memcpy (hostname
, lsp
->tlv_data
.hostname
->name
,
775 lsp
->tlv_data
.hostname
->namelen
);
776 vty_out (vty
, " Hostname: %s%s", hostname
, VTY_NEWLINE
);
779 if (lsp
->tlv_data
.ipv4_addrs
)
781 LIST_LOOP (lsp
->tlv_data
.ipv4_addrs
, ipv4_addr
, lnode
)
783 memcpy (ipv4_address
, inet_ntoa (*ipv4_addr
), sizeof (ipv4_address
));
784 vty_out (vty
, " IP: %s%s", ipv4_address
, VTY_NEWLINE
);
789 if (lsp
->tlv_data
.router_id
)
791 memcpy (ipv4_address
, inet_ntoa (lsp
->tlv_data
.router_id
->id
),
792 sizeof (ipv4_address
));
793 vty_out (vty
, " Router ID: %s%s", ipv4_address
, VTY_NEWLINE
);
796 /* for the IS neighbor tlv */
797 if (lsp
->tlv_data
.is_neighs
)
799 LIST_LOOP (lsp
->tlv_data
.is_neighs
, is_neigh
, lnode
)
801 lspid_print (is_neigh
->neigh_id
, LSPid
, dynhost
, 0);
802 vty_out (vty
, " Metric: %d IS %s%s",
803 is_neigh
->metrics
.metric_default
, LSPid
, VTY_NEWLINE
);
807 /* for the internal reachable tlv */
808 if (lsp
->tlv_data
.ipv4_int_reachs
)
809 LIST_LOOP (lsp
->tlv_data
.ipv4_int_reachs
, ipv4_reach
, lnode
)
811 memcpy (ipv4_reach_prefix
, inet_ntoa (ipv4_reach
->prefix
),
812 sizeof (ipv4_reach_prefix
));
813 memcpy (ipv4_reach_mask
, inet_ntoa (ipv4_reach
->mask
),
814 sizeof (ipv4_reach_mask
));
815 vty_out (vty
, " Metric: %d IP %s %s%s",
816 ipv4_reach
->metrics
.metric_default
, ipv4_reach_prefix
,
817 ipv4_reach_mask
, VTY_NEWLINE
);
820 /* for the external reachable tlv */
821 if (lsp
->tlv_data
.ipv4_ext_reachs
)
822 LIST_LOOP (lsp
->tlv_data
.ipv4_ext_reachs
, ipv4_reach
, lnode
)
824 memcpy (ipv4_reach_prefix
, inet_ntoa (ipv4_reach
->prefix
),
825 sizeof (ipv4_reach_prefix
));
826 memcpy (ipv4_reach_mask
, inet_ntoa (ipv4_reach
->mask
),
827 sizeof (ipv4_reach_mask
));
828 vty_out (vty
, " Metric: %d IP-External %s %s%s",
829 ipv4_reach
->metrics
.metric_default
, ipv4_reach_prefix
,
830 ipv4_reach_mask
, VTY_NEWLINE
);
835 if (lsp
->tlv_data
.ipv6_reachs
)
836 LIST_LOOP (lsp
->tlv_data
.ipv6_reachs
, ipv6_reach
, lnode
)
838 memset (&in6
, 0, sizeof (in6
));
839 memcpy (in6
.s6_addr
, ipv6_reach
->prefix
,
840 PSIZE (ipv6_reach
->prefix_len
));
841 inet_ntop (AF_INET6
, &in6
, (char *)buff
, BUFSIZ
);
842 if ((ipv6_reach
->control_info
&&
843 CTRL_INFO_DISTRIBUTION
) == DISTRIBUTION_INTERNAL
)
844 vty_out (vty
, " Metric: %d IPv6-Intern %s/%d%s",
845 ntohl (ipv6_reach
->metric
),
846 buff
, ipv6_reach
->prefix_len
, VTY_NEWLINE
);
848 vty_out (vty
, " Metric: %d IPv6-Extern %s/%d%s",
849 ntohl (ipv6_reach
->metric
),
850 buff
, ipv6_reach
->prefix_len
, VTY_NEWLINE
);
853 /* TE IS neighbor tlv */
854 if (lsp
->tlv_data
.te_is_neighs
)
855 LIST_LOOP (lsp
->tlv_data
.te_is_neighs
, te_is_neigh
, lnode
)
857 /* FIXME: metric display is wrong. */
858 lspid_print (te_is_neigh
->neigh_id
, LSPid
, dynhost
, 0);
859 vty_out (vty
, " Metric: %d extd-IS %s%s",
860 te_is_neigh
->te_metric
[0], LSPid
, VTY_NEWLINE
);
864 if (lsp
->tlv_data
.te_ipv4_reachs
)
865 LIST_LOOP (lsp
->tlv_data
.te_ipv4_reachs
, te_ipv4_reach
, lnode
)
867 /* FIXME: There should be better way to output this stuff. */
868 vty_out (vty
, " Metric: %d extd-IP %s/%d%s",
869 ntohl (te_ipv4_reach
->te_metric
),
870 inet_ntoa (newprefix2inaddr (&te_ipv4_reach
->prefix_start
,
871 te_ipv4_reach
->control
)),
872 te_ipv4_reach
->control
& 0x3F, VTY_NEWLINE
);
878 /* print all the lsps info in the local lspdb */
880 lsp_print_all (struct vty
*vty
, dict_t
* lspdb
, char detail
, char dynhost
)
883 dnode_t
*node
= dict_first (lspdb
), *next
;
886 /* print the title, for both modes */
887 vty_out (vty
, "LSP ID LSP Seq Num LSP Checksum "
888 "LSP Holdtime ATT/P/OL%s", VTY_NEWLINE
);
890 if (detail
== ISIS_UI_LEVEL_BRIEF
)
894 /* I think it is unnecessary, so I comment it out */
895 /* dict_contains (lspdb, node); */
896 next
= dict_next (lspdb
, node
);
897 lsp_print (node
, vty
, dynhost
);
902 else if (detail
== ISIS_UI_LEVEL_DETAIL
)
906 next
= dict_next (lspdb
, node
);
907 lsp_print_detail (node
, vty
, dynhost
);
916 #if 0 /* Seems to be old code */
917 /* this function reallocate memory to an lsp pdu, with an additional
918 * size of memory, it scans the lsp and moves all pointers the
921 lsppdu_realloc (struct isis_lsp
* lsp
, int memorytype
, int size
)
925 retval
= STREAM_DATA (lsp
->pdu
) + ntohs (lsp
->lsp_header
->pdu_len
);
926 #ifdef LSP_MEMORY_PREASSIGN
927 lsp
->lsp_header
->pdu_len
= htons (ntohs (lsp
->lsp_header
->pdu_len
) + size
);
929 #else /* otherwise we have to move all pointers */
931 newpdu
= stream_new (ntohs (lsp
->lsp_header
->pdu_len
) + size
);
932 memcpy (STREAM_DATA (newpdu
), STREAM_DATA (lsp
->pdu
),
933 ntohs (lsp
->lsp_header
->pdu_len
));
934 XFREE (memorytype
, lsp
->pdu
);
936 lsp
->isis_header
= (struct isis_fixed_hdr
*) STREAM_DATA (lsp
->pdu
);
937 lsp
->lsp_header
= (struct isis_link_state_hdr
*)
938 (STREAM_DATA (lsp
->pdu
) + ISIS_FIXED_HDR_LEN
);
939 htons (ntohs (lsp
->lsp_header
->pdu_len
) += size
);
940 return STREAM_DATA (lsp
->pdu
) + (lsp
->lsp_header
->pdu_len
- size
);
941 #endif /* LSP_MEMORY_PREASSIGN */
945 #if 0 /* Saving the old one just in case :) */
947 * Builds the lsp->tlv_data
948 * and writes the tlvs into lsp->pdu
951 lsp_build_nonpseudo (struct isis_lsp
*lsp
, struct isis_area
*area
)
953 struct is_neigh
*is_neigh
;
954 struct listnode
*node
, *ipnode
;
955 int level
= lsp
->level
;
956 struct isis_circuit
*circuit
;
957 struct prefix_ipv4
*ipv4
;
958 struct ipv4_reachability
*ipreach
;
959 struct isis_adjacency
*nei
;
961 struct prefix_ipv6
*ipv6
;
962 struct ipv6_reachability
*ip6reach
;
963 #endif /* HAVE_IPV6 */
966 * First add the tlvs related to area
970 if (lsp
->tlv_data
.area_addrs
== NULL
)
971 lsp
->tlv_data
.area_addrs
= list_new ();
972 list_add_list (lsp
->tlv_data
.area_addrs
, area
->area_addrs
);
973 /* Protocols Supported */
974 if (area
->ip_circuits
> 0
976 || area
->ipv6_circuits
> 0
977 #endif /* HAVE_IPV6 */
980 lsp
->tlv_data
.nlpids
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct nlpids
));
981 lsp
->tlv_data
.nlpids
->count
= 0;
982 if (area
->ip_circuits
> 0)
984 lsp
->tlv_data
.nlpids
->count
++;
985 lsp
->tlv_data
.nlpids
->nlpids
[0] = NLPID_IP
;
988 if (area
->ipv6_circuits
> 0)
990 lsp
->tlv_data
.nlpids
->count
++;
991 lsp
->tlv_data
.nlpids
->nlpids
[lsp
->tlv_data
.nlpids
->count
- 1] =
994 #endif /* HAVE_IPV6 */
996 /* Dynamic Hostname */
997 if (area
->dynhostname
)
999 lsp
->tlv_data
.hostname
= XMALLOC (MTYPE_ISIS_TLV
,
1000 sizeof (struct hostname
));
1001 memcpy (&lsp
->tlv_data
.hostname
->name
, unix_hostname (),
1002 strlen (unix_hostname ()));
1003 lsp
->tlv_data
.hostname
->namelen
= strlen (unix_hostname ());
1005 #ifdef TOPOLOGY_GENERATE
1007 * If we have a topology in this area, we need to connect this lsp to
1008 * the first topology lsp
1010 if ((area
->topology
) && (level
== 1))
1012 if (lsp
->tlv_data
.is_neighs
== NULL
)
1013 lsp
->tlv_data
.is_neighs
= list_new ();
1014 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1015 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1016 memcpy (&is_neigh
->neigh_id
, area
->topology_baseis
, ISIS_SYS_ID_LEN
);
1017 /* connected to the first */
1018 is_neigh
->neigh_id
[ISIS_SYS_ID_LEN
- 1] = (0x01);
1019 /* this is actually the same system, why mess the SPT */
1020 is_neigh
->metrics
.metric_default
= 0;
1021 is_neigh
->metrics
.metric_delay
= METRICS_UNSUPPORTED
;
1022 is_neigh
->metrics
.metric_expense
= METRICS_UNSUPPORTED
;
1023 is_neigh
->metrics
.metric_error
= METRICS_UNSUPPORTED
;
1024 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
1030 * Then add tlvs related to circuits
1032 for (node
= listhead (area
->circuit_list
); node
; nextnode (node
))
1034 circuit
= getdata (node
);
1035 if (circuit
->state
!= C_STATE_UP
)
1039 * Add IPv4 internal reachability of this circuit
1041 if (circuit
->ip_router
&& circuit
->ip_addrs
&&
1042 circuit
->ip_addrs
->count
> 0)
1044 if (lsp
->tlv_data
.ipv4_int_reachs
== NULL
)
1046 lsp
->tlv_data
.ipv4_int_reachs
= list_new ();
1047 lsp
->tlv_data
.ipv4_int_reachs
->del
= free_tlv
;
1049 for (ipnode
= listhead (circuit
->ip_addrs
); ipnode
;
1052 ipv4
= getdata (ipnode
);
1054 XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct ipv4_reachability
));
1055 ipreach
->metrics
= circuit
->metrics
[level
- 1];
1056 ipreach
->prefix
= ipv4
->prefix
;
1057 masklen2ip (ipv4
->prefixlen
, &ipreach
->mask
);
1058 listnode_add (lsp
->tlv_data
.ipv4_int_reachs
, ipreach
);
1063 * Add IPv6 reachability of this circuit
1065 if (circuit
->ipv6_router
&& circuit
->ipv6_non_link
&&
1066 circuit
->ipv6_non_link
->count
> 0)
1068 if (lsp
->tlv_data
.ipv6_reachs
== NULL
)
1070 lsp
->tlv_data
.ipv6_reachs
= list_new ();
1071 lsp
->tlv_data
.ipv6_reachs
->del
= free_tlv
;
1073 for (ipnode
= listhead (circuit
->ipv6_non_link
); ipnode
;
1076 ipv6
= getdata (ipnode
);
1078 XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct ipv6_reachability
));
1079 memset (ip6reach
, 0, sizeof (struct ipv6_reachability
));
1081 htonl (circuit
->metrics
[level
- 1].metric_default
);
1082 ip6reach
->control_info
= 0;
1083 ip6reach
->prefix_len
= ipv6
->prefixlen
;
1084 memcpy (&ip6reach
->prefix
, ipv6
->prefix
.s6_addr
,
1085 (ipv6
->prefixlen
+ 7) / 8);
1086 listnode_add (lsp
->tlv_data
.ipv6_reachs
, ip6reach
);
1089 #endif /* HAVE_IPV6 */
1091 switch (circuit
->circ_type
)
1093 case CIRCUIT_T_BROADCAST
:
1094 if (level
& circuit
->circuit_is_type
)
1096 if (lsp
->tlv_data
.is_neighs
== NULL
)
1098 lsp
->tlv_data
.is_neighs
= list_new ();
1099 lsp
->tlv_data
.is_neighs
->del
= free_tlv
;
1101 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1102 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1104 memcpy (&is_neigh
->neigh_id
,
1105 circuit
->u
.bc
.l1_desig_is
, ISIS_SYS_ID_LEN
+ 1);
1107 memcpy (&is_neigh
->neigh_id
,
1108 circuit
->u
.bc
.l2_desig_is
, ISIS_SYS_ID_LEN
+ 1);
1109 is_neigh
->metrics
= circuit
->metrics
[level
- 1];
1110 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
1114 nei
= circuit
->u
.p2p
.neighbor
;
1115 if (nei
&& (level
& nei
->circuit_t
))
1117 if (lsp
->tlv_data
.is_neighs
== NULL
)
1119 lsp
->tlv_data
.is_neighs
= list_new ();
1120 lsp
->tlv_data
.is_neighs
->del
= free_tlv
;
1122 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1123 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1124 memcpy (&is_neigh
->neigh_id
, nei
->sysid
, ISIS_SYS_ID_LEN
);
1125 is_neigh
->metrics
= circuit
->metrics
[level
- 1];
1126 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
1129 case CIRCUIT_T_STATIC_IN
:
1130 zlog_warn ("lsp_area_create: unsupported circuit type");
1132 case CIRCUIT_T_STATIC_OUT
:
1133 zlog_warn ("lsp_area_create: unsupported circuit type");
1136 zlog_warn ("lsp_area_create: unsupported circuit type");
1139 zlog_warn ("lsp_area_create: unknown circuit type");
1143 stream_forward_endp (lsp
->pdu
, ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
1145 if (lsp
->tlv_data
.nlpids
)
1146 tlv_add_nlpid (lsp
->tlv_data
.nlpids
, lsp
->pdu
);
1147 if (lsp
->tlv_data
.hostname
)
1148 tlv_add_dynamic_hostname (lsp
->tlv_data
.hostname
, lsp
->pdu
);
1149 if (lsp
->tlv_data
.area_addrs
&& listcount (lsp
->tlv_data
.area_addrs
) > 0)
1150 tlv_add_area_addrs (lsp
->tlv_data
.area_addrs
, lsp
->pdu
);
1151 if (lsp
->tlv_data
.is_neighs
&& listcount (lsp
->tlv_data
.is_neighs
) > 0)
1152 tlv_add_is_neighs (lsp
->tlv_data
.is_neighs
, lsp
->pdu
);
1153 if (lsp
->tlv_data
.ipv4_int_reachs
&&
1154 listcount (lsp
->tlv_data
.ipv4_int_reachs
) > 0)
1155 tlv_add_ipv4_reachs (lsp
->tlv_data
.ipv4_int_reachs
, lsp
->pdu
);
1157 if (lsp
->tlv_data
.ipv6_reachs
&& listcount (lsp
->tlv_data
.ipv6_reachs
) > 0)
1158 tlv_add_ipv6_reachs (lsp
->tlv_data
.ipv6_reachs
, lsp
->pdu
);
1159 #endif /* HAVE_IPV6 */
1161 lsp
->lsp_header
->pdu_len
= htons (stream_get_endp (lsp
->pdu
));
1167 #define FRAG_THOLD(S,T) \
1168 ((STREAM_SIZE(S)*T)/100)
1170 /* stream*, area->lsp_frag_threshold, increment */
1171 #define FRAG_NEEDED(S,T,I) \
1172 (STREAM_SIZE(S)-STREAM_REMAIN(S)+(I) > FRAG_THOLD(S,T))
1175 lsp_tlv_fit (struct isis_lsp
*lsp
, struct list
**from
, struct list
**to
,
1176 int tlvsize
, int frag_thold
,
1177 int tlv_build_func (struct list
*, struct stream
*))
1181 /* can we fit all ? */
1182 if (!FRAG_NEEDED (lsp
->pdu
, frag_thold
, listcount (*from
) * tlvsize
+ 2))
1184 tlv_build_func (*from
, lsp
->pdu
);
1188 else if (!FRAG_NEEDED (lsp
->pdu
, frag_thold
, tlvsize
+ 2))
1190 /* fit all we can */
1191 count
= FRAG_THOLD (lsp
->pdu
, frag_thold
) - 2 -
1192 (STREAM_SIZE (lsp
->pdu
) - STREAM_REMAIN (lsp
->pdu
));
1194 count
= count
/ tlvsize
;
1195 for (i
= 0; i
< count
; i
++)
1197 listnode_add (*to
, getdata (listhead (*from
)));
1198 listnode_delete (*from
, getdata (listhead (*from
)));
1200 tlv_build_func (*to
, lsp
->pdu
);
1202 lsp
->lsp_header
->pdu_len
= htons (stream_get_endp (lsp
->pdu
));
1206 static struct isis_lsp
*
1207 lsp_next_frag (u_char frag_num
, struct isis_lsp
*lsp0
, struct isis_area
*area
,
1210 struct isis_lsp
*lsp
;
1211 u_char frag_id
[ISIS_SYS_ID_LEN
+ 2];
1213 memcpy (frag_id
, lsp0
->lsp_header
->lsp_id
, ISIS_SYS_ID_LEN
+ 1);
1214 LSP_FRAGMENT (frag_id
) = frag_num
;
1215 lsp
= lsp_search (frag_id
, area
->lspdb
[level
- 1]);
1219 * Clear the TLVs, but inherit the authinfo
1221 lsp_clear_data (lsp
);
1222 if (lsp0
->tlv_data
.auth_info
.type
)
1224 memcpy (&lsp
->tlv_data
.auth_info
, &lsp
->tlv_data
.auth_info
,
1225 sizeof (struct isis_passwd
));
1226 tlv_add_authinfo (lsp
->tlv_data
.auth_info
.type
,
1227 lsp
->tlv_data
.auth_info
.len
,
1228 lsp
->tlv_data
.auth_info
.passwd
, lsp
->pdu
);
1232 lsp
= lsp_new (frag_id
, area
->max_lsp_lifetime
[level
- 1], 0, area
->is_type
,
1235 lsp_insert (lsp
, area
->lspdb
[level
- 1]);
1236 listnode_add (lsp0
->lspu
.frags
, lsp
);
1237 lsp
->lspu
.zero_lsp
= lsp0
;
1239 * Copy the authinfo from zero LSP
1241 if (lsp0
->tlv_data
.auth_info
.type
)
1243 memcpy (&lsp
->tlv_data
.auth_info
, &lsp
->tlv_data
.auth_info
,
1244 sizeof (struct isis_passwd
));
1245 tlv_add_authinfo (lsp
->tlv_data
.auth_info
.type
,
1246 lsp
->tlv_data
.auth_info
.len
,
1247 lsp
->tlv_data
.auth_info
.passwd
, lsp
->pdu
);
1253 * Builds the LSP data part. This func creates a new frag whenever
1254 * area->lsp_frag_threshold is exceeded.
1258 lsp_build_nonpseudo (struct isis_lsp
*lsp
, struct isis_area
*area
)
1260 struct is_neigh
*is_neigh
;
1261 struct listnode
*node
, *ipnode
;
1262 int level
= lsp
->level
;
1263 struct isis_circuit
*circuit
;
1264 struct prefix_ipv4
*ipv4
;
1265 struct ipv4_reachability
*ipreach
;
1266 struct isis_adjacency
*nei
;
1268 struct prefix_ipv6
*ipv6
, *ip6prefix
;
1269 struct ipv6_reachability
*ip6reach
;
1270 #endif /* HAVE_IPV6 */
1271 struct tlvs tlv_data
;
1272 struct isis_lsp
*lsp0
= lsp
;
1273 struct isis_passwd
*passwd
;
1274 struct in_addr
*routerid
;
1277 * First add the tlvs related to area
1280 /* Area addresses */
1281 if (lsp
->tlv_data
.area_addrs
== NULL
)
1282 lsp
->tlv_data
.area_addrs
= list_new ();
1283 list_add_list (lsp
->tlv_data
.area_addrs
, area
->area_addrs
);
1284 /* Protocols Supported */
1285 if (area
->ip_circuits
> 0
1287 || area
->ipv6_circuits
> 0
1288 #endif /* HAVE_IPV6 */
1291 lsp
->tlv_data
.nlpids
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct nlpids
));
1292 lsp
->tlv_data
.nlpids
->count
= 0;
1293 if (area
->ip_circuits
> 0)
1295 lsp
->tlv_data
.nlpids
->count
++;
1296 lsp
->tlv_data
.nlpids
->nlpids
[0] = NLPID_IP
;
1299 if (area
->ipv6_circuits
> 0)
1301 lsp
->tlv_data
.nlpids
->count
++;
1302 lsp
->tlv_data
.nlpids
->nlpids
[lsp
->tlv_data
.nlpids
->count
- 1] =
1305 #endif /* HAVE_IPV6 */
1307 /* Dynamic Hostname */
1308 if (area
->dynhostname
)
1310 lsp
->tlv_data
.hostname
= XMALLOC (MTYPE_ISIS_TLV
,
1311 sizeof (struct hostname
));
1313 memcpy (lsp
->tlv_data
.hostname
->name
, unix_hostname (),
1314 strlen (unix_hostname ()));
1315 lsp
->tlv_data
.hostname
->namelen
= strlen (unix_hostname ());
1319 * Building the zero lsp
1321 stream_forward_endp (lsp
->pdu
, ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
1323 * Add the authentication info if its present
1325 (level
== 1) ? (passwd
= &area
->area_passwd
) :
1326 (passwd
= &area
->domain_passwd
);
1329 memcpy (&lsp
->tlv_data
.auth_info
, passwd
, sizeof (struct isis_passwd
));
1330 tlv_add_authinfo (passwd
->type
, passwd
->len
, passwd
->passwd
, lsp
->pdu
);
1332 if (lsp
->tlv_data
.nlpids
)
1333 tlv_add_nlpid (lsp
->tlv_data
.nlpids
, lsp
->pdu
);
1334 if (lsp
->tlv_data
.hostname
)
1335 tlv_add_dynamic_hostname (lsp
->tlv_data
.hostname
, lsp
->pdu
);
1336 if (lsp
->tlv_data
.area_addrs
&& listcount (lsp
->tlv_data
.area_addrs
) > 0)
1337 tlv_add_area_addrs (lsp
->tlv_data
.area_addrs
, lsp
->pdu
);
1339 memset (&tlv_data
, 0, sizeof (struct tlvs
));
1341 * IPv4 address TLV. We don't follow "C" vendor, but "J" vendor behavior -
1342 * one IPv4 address is put into LSP and this address is same as router id.
1344 if (router_id_zebra
.s_addr
!= 0)
1346 if (lsp
->tlv_data
.ipv4_addrs
== NULL
)
1347 lsp
->tlv_data
.ipv4_addrs
= list_new ();
1349 routerid
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct in_addr
));
1350 routerid
->s_addr
= router_id_zebra
.s_addr
;
1352 listnode_add (lsp
->tlv_data
.ipv4_addrs
, routerid
);
1355 * FIXME: Using add_tlv() directly is hack, but tlv_add_ip_addrs()
1356 * expects list of prefix_ipv4 structures, but we have list of
1357 * in_addr structures.
1359 add_tlv (IPV4_ADDR
, IPV4_MAX_BYTELEN
, (u_char
*) &routerid
->s_addr
,
1363 * Then build lists of tlvs related to circuits
1365 for (node
= listhead (area
->circuit_list
); node
; nextnode (node
))
1367 circuit
= getdata (node
);
1368 if (circuit
->state
!= C_STATE_UP
)
1372 * Add IPv4 internal reachability of this circuit
1374 if (circuit
->ip_router
&& circuit
->ip_addrs
&&
1375 circuit
->ip_addrs
->count
> 0)
1377 if (tlv_data
.ipv4_int_reachs
== NULL
)
1379 tlv_data
.ipv4_int_reachs
= list_new ();
1381 for (ipnode
= listhead (circuit
->ip_addrs
); ipnode
;
1384 ipv4
= getdata (ipnode
);
1386 XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct ipv4_reachability
));
1387 ipreach
->metrics
= circuit
->metrics
[level
- 1];
1388 masklen2ip (ipv4
->prefixlen
, &ipreach
->mask
);
1389 ipreach
->prefix
.s_addr
= ((ipreach
->mask
.s_addr
) &
1390 (ipv4
->prefix
.s_addr
));
1391 listnode_add (tlv_data
.ipv4_int_reachs
, ipreach
);
1397 * Add IPv6 reachability of this circuit
1399 if (circuit
->ipv6_router
&& circuit
->ipv6_non_link
&&
1400 circuit
->ipv6_non_link
->count
> 0)
1403 if (tlv_data
.ipv6_reachs
== NULL
)
1405 tlv_data
.ipv6_reachs
= list_new ();
1407 for (ipnode
= listhead (circuit
->ipv6_non_link
); ipnode
;
1410 ipv6
= getdata (ipnode
);
1412 XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct ipv6_reachability
));
1413 memset (ip6reach
, 0, sizeof (struct ipv6_reachability
));
1415 htonl (circuit
->metrics
[level
- 1].metric_default
);
1416 ip6reach
->control_info
= 0;
1417 ip6reach
->prefix_len
= ipv6
->prefixlen
;
1418 memcpy (&ip6prefix
, &ipv6
, sizeof(ip6prefix
));
1419 apply_mask_ipv6 (ip6prefix
);
1420 memcpy (ip6reach
->prefix
, ip6prefix
->prefix
.s6_addr
,
1421 sizeof (ip6reach
->prefix
));
1422 listnode_add (tlv_data
.ipv6_reachs
, ip6reach
);
1425 #endif /* HAVE_IPV6 */
1427 switch (circuit
->circ_type
)
1429 case CIRCUIT_T_BROADCAST
:
1430 if (level
& circuit
->circuit_is_type
)
1432 if (tlv_data
.is_neighs
== NULL
)
1434 tlv_data
.is_neighs
= list_new ();
1436 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1437 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1439 memcpy (is_neigh
->neigh_id
,
1440 circuit
->u
.bc
.l1_desig_is
, ISIS_SYS_ID_LEN
+ 1);
1442 memcpy (is_neigh
->neigh_id
,
1443 circuit
->u
.bc
.l2_desig_is
, ISIS_SYS_ID_LEN
+ 1);
1444 is_neigh
->metrics
= circuit
->metrics
[level
- 1];
1445 listnode_add (tlv_data
.is_neighs
, is_neigh
);
1449 nei
= circuit
->u
.p2p
.neighbor
;
1450 if (nei
&& (level
& nei
->circuit_t
))
1452 if (tlv_data
.is_neighs
== NULL
)
1454 tlv_data
.is_neighs
= list_new ();
1455 tlv_data
.is_neighs
->del
= free_tlv
;
1457 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1458 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1459 memcpy (is_neigh
->neigh_id
, nei
->sysid
, ISIS_SYS_ID_LEN
);
1460 is_neigh
->metrics
= circuit
->metrics
[level
- 1];
1461 listnode_add (tlv_data
.is_neighs
, is_neigh
);
1464 case CIRCUIT_T_STATIC_IN
:
1465 zlog_warn ("lsp_area_create: unsupported circuit type");
1467 case CIRCUIT_T_STATIC_OUT
:
1468 zlog_warn ("lsp_area_create: unsupported circuit type");
1471 zlog_warn ("lsp_area_create: unsupported circuit type");
1474 zlog_warn ("lsp_area_create: unknown circuit type");
1478 while (tlv_data
.ipv4_int_reachs
&& listcount (tlv_data
.ipv4_int_reachs
))
1480 if (lsp
->tlv_data
.ipv4_int_reachs
== NULL
)
1481 lsp
->tlv_data
.ipv4_int_reachs
= list_new ();
1482 lsp_tlv_fit (lsp
, &tlv_data
.ipv4_int_reachs
,
1483 &lsp
->tlv_data
.ipv4_int_reachs
,
1484 IPV4_REACH_LEN
, area
->lsp_frag_threshold
,
1485 tlv_add_ipv4_reachs
);
1486 if (tlv_data
.ipv4_int_reachs
&& listcount (tlv_data
.ipv4_int_reachs
))
1487 lsp
= lsp_next_frag (LSP_FRAGMENT (lsp
->lsp_header
->lsp_id
) + 1,
1492 while (tlv_data
.ipv6_reachs
&& listcount (tlv_data
.ipv6_reachs
))
1494 if (lsp
->tlv_data
.ipv6_reachs
== NULL
)
1495 lsp
->tlv_data
.ipv6_reachs
= list_new ();
1496 lsp_tlv_fit (lsp
, &tlv_data
.ipv6_reachs
,
1497 &lsp
->tlv_data
.ipv6_reachs
,
1498 IPV6_REACH_LEN
, area
->lsp_frag_threshold
,
1499 tlv_add_ipv6_reachs
);
1500 if (tlv_data
.ipv6_reachs
&& listcount (tlv_data
.ipv6_reachs
))
1501 lsp
= lsp_next_frag (LSP_FRAGMENT (lsp
->lsp_header
->lsp_id
) + 1,
1504 #endif /* HAVE_IPV6 */
1506 while (tlv_data
.is_neighs
&& listcount (tlv_data
.is_neighs
))
1508 if (lsp
->tlv_data
.is_neighs
== NULL
)
1509 lsp
->tlv_data
.is_neighs
= list_new ();
1510 lsp_tlv_fit (lsp
, &tlv_data
.is_neighs
,
1511 &lsp
->tlv_data
.is_neighs
,
1512 IS_NEIGHBOURS_LEN
, area
->lsp_frag_threshold
,
1514 if (tlv_data
.is_neighs
&& listcount (tlv_data
.is_neighs
))
1515 lsp
= lsp_next_frag (LSP_FRAGMENT (lsp
->lsp_header
->lsp_id
) + 1,
1523 #if 0 /* Old code? */
1525 build_lsp_data (struct isis_lsp
*lsp
, struct isis_area
*area
)
1527 struct list
*circuit_list
= area
->circuit_list
;
1528 struct isis_circuit
*circuit
;
1530 struct is_neigh
*is_neigh
;
1533 /* add our nlpids */
1534 /* the 2 is for the TL plus 1 for the nlpid */
1535 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 3);
1536 *tlv_ptr
= PROTOCOLS_SUPPORTED
; /* Type */
1537 *(tlv_ptr
+ 1) = 1; /* one protocol */
1538 #ifdef HAVE_IPV6 /*dunno if its right */
1539 *(tlv_ptr
+ 2) = NLPID_IPV6
;
1541 *(tlv_ptr
+ 2) = NLPID_IP
;
1542 #endif /* HAVE_IPV6 */
1544 /* we should add our areas here
1545 * FIXME: we need to figure out which should be added? Adj? All? First? */
1547 /* first, lets add ourselves to the IS neighbours info */
1548 /* the 2 is for the TL plus 1 for the virtual field */
1549 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 3);
1550 *tlv_ptr
= IS_NEIGHBOURS
; /* Type */
1551 *(tlv_ptr
+ 2) = 0; /* virtual is zero */
1552 lsp
->tlv_data
.is_neighs
= list_new (); /* new list of is_neighbours */
1553 /* assign space for the is_neigh at the pdu end */
1554 is_neigh
= (struct is_neigh
*) lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
,
1555 sizeof (struct is_neigh
));
1556 /* add this node to our list */
1557 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
1558 /* FIXME: Do we need our designated address here? */
1559 memcpy (&is_neigh
->neigh_id
, isis
->sysid
, ISIS_SYS_ID_LEN
+ 1);
1560 /* FIXME: Where should we really get our own LSPs metrics from? */
1561 circuit
= (struct isis_circuit
*) listhead (circuit_list
);
1562 /* is_neigh->metrics = circuit->metrics[lsp->level -1]; */
1565 (lsp
->tlv_data
.is_neighs
->count
* sizeof (struct is_neigh
) + 1);
1567 /* FIXME: scan for adjencecies and add them */
1569 /* FIXME: add reachability info */
1571 /* adding dynamic hostname if needed */
1572 if (area
->dynhostname
)
1574 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 2); /* the 2 is for the TL */
1575 *tlv_ptr
= DYNAMIC_HOSTNAME
; /* Type */
1576 *(tlv_ptr
+ 1) = strlen (unix_hostname ()); /* Length */
1577 lsp
->tlv_data
.hostname
= (struct hostname
*)
1578 (lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
,
1579 /* the -1 is to fit the length in the struct */
1580 strlen (unix_hostname ())) - 1);
1581 memcpy (lsp
->tlv_data
.hostname
->name
, unix_hostname (),
1582 strlen (unix_hostname ()));
1589 * 7.3.7 Generation on non-pseudonode LSPs
1592 lsp_generate_non_pseudo (struct isis_area
*area
, int level
)
1594 struct isis_lsp
*oldlsp
, *newlsp
;
1595 u_int32_t seq_num
= 0;
1596 u_char lspid
[ISIS_SYS_ID_LEN
+ 2];
1598 memset (&lspid
, 0, ISIS_SYS_ID_LEN
+ 2);
1599 memcpy (&lspid
, isis
->sysid
, ISIS_SYS_ID_LEN
);
1601 /* only builds the lsp if the area shares the level */
1602 if ((area
->is_type
& level
) == level
)
1604 oldlsp
= lsp_search (lspid
, area
->lspdb
[level
- 1]);
1607 seq_num
= ntohl (oldlsp
->lsp_header
->seq_num
);
1608 lsp_search_and_destroy (oldlsp
->lsp_header
->lsp_id
,
1609 area
->lspdb
[level
- 1]);
1610 /* FIXME: we should actually initiate a purge */
1612 newlsp
= lsp_new (lspid
, area
->max_lsp_lifetime
[level
- 1], seq_num
,
1613 area
->is_type
, 0, level
);
1614 newlsp
->own_lsp
= 1;
1616 lsp_insert (newlsp
, area
->lspdb
[level
- 1]);
1617 /* build_lsp_data (newlsp, area); */
1618 lsp_build_nonpseudo (newlsp
, area
);
1619 /* time to calculate our checksum */
1620 lsp_seqnum_update (newlsp
);
1623 /* DEBUG_ADJ_PACKETS */
1624 if (isis
->debugs
& DEBUG_ADJ_PACKETS
)
1626 /* FIXME: is this place right? fix missing info */
1627 zlog_debug ("ISIS-Upd (%s): Building L%d LSP", area
->area_tag
, level
);
1634 * 7.3.9 Generation of level 1 LSPs (non-pseudonode)
1637 lsp_l1_generate (struct isis_area
*area
)
1639 THREAD_TIMER_ON (master
, area
->t_lsp_refresh
[0], lsp_refresh_l1
, area
,
1640 MAX_LSP_GEN_INTERVAL
);
1642 return lsp_generate_non_pseudo (area
, 1);
1646 * 7.3.9 Generation of level 2 LSPs (non-pseudonode)
1649 lsp_l2_generate (struct isis_area
*area
)
1651 THREAD_TIMER_ON (master
, area
->t_lsp_refresh
[1], lsp_refresh_l2
, area
,
1652 MAX_LSP_GEN_INTERVAL
);
1654 return lsp_generate_non_pseudo (area
, 2);
1658 lsp_non_pseudo_regenerate (struct isis_area
*area
, int level
)
1660 dict_t
*lspdb
= area
->lspdb
[level
- 1];
1661 struct isis_lsp
*lsp
, *frag
;
1662 struct listnode
*node
;
1663 u_char lspid
[ISIS_SYS_ID_LEN
+ 2];
1665 memset (lspid
, 0, ISIS_SYS_ID_LEN
+ 2);
1666 memcpy (lspid
, isis
->sysid
, ISIS_SYS_ID_LEN
);
1668 lsp
= lsp_search (lspid
, lspdb
);
1673 ("ISIS-Upd (%s): lsp_non_pseudo_regenerate(): no L%d LSP found!",
1674 area
->area_tag
, level
);
1679 lsp_clear_data (lsp
);
1680 lsp_build_nonpseudo (lsp
, area
);
1681 lsp
->lsp_header
->rem_lifetime
= htons (isis_jitter
1682 (area
->max_lsp_lifetime
[level
- 1],
1684 lsp_seqnum_update (lsp
);
1686 if (isis
->debugs
& DEBUG_UPDATE_PACKETS
)
1688 zlog_debug ("ISIS-Upd (%s): refreshing our L%d LSP %s, "
1689 "seq 0x%08x, cksum 0x%04x lifetime %us",
1692 rawlspid_print (lsp
->lsp_header
->lsp_id
),
1693 ntohl (lsp
->lsp_header
->seq_num
),
1694 ntohs (lsp
->lsp_header
->checksum
),
1695 ntohs (lsp
->lsp_header
->rem_lifetime
));
1698 lsp
->last_generated
= time (NULL
);
1699 area
->lsp_regenerate_pending
[level
- 1] = 0;
1700 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
1701 for (node
= listhead (lsp
->lspu
.frags
); node
; nextnode (node
))
1703 frag
= getdata (node
);
1704 frag
->lsp_header
->rem_lifetime
= htons (isis_jitter
1706 max_lsp_lifetime
[level
- 1],
1708 ISIS_FLAGS_SET_ALL (frag
->SRMflags
);
1711 if (area
->ip_circuits
)
1712 isis_spf_schedule (area
, level
);
1714 if (area
->ipv6_circuits
)
1715 isis_spf_schedule6 (area
, level
);
1721 * Done at least every MAX_LSP_GEN_INTERVAL. Search own LSPs, update holding
1725 lsp_refresh_l1 (struct thread
*thread
)
1727 struct isis_area
*area
;
1728 unsigned long ref_time
;
1730 area
= THREAD_ARG (thread
);
1733 area
->t_lsp_refresh
[0] = NULL
;
1734 if (area
->is_type
& IS_LEVEL_1
)
1735 lsp_non_pseudo_regenerate (area
, 1);
1737 ref_time
= area
->lsp_refresh
[0] > MAX_LSP_GEN_INTERVAL
?
1738 MAX_LSP_GEN_INTERVAL
: area
->lsp_refresh
[0];
1740 THREAD_TIMER_ON (master
, area
->t_lsp_refresh
[0], lsp_refresh_l1
, area
,
1741 isis_jitter (ref_time
, MAX_AGE_JITTER
));
1747 lsp_refresh_l2 (struct thread
*thread
)
1749 struct isis_area
*area
;
1750 unsigned long ref_time
;
1752 area
= THREAD_ARG (thread
);
1755 area
->t_lsp_refresh
[1] = NULL
;
1756 if (area
->is_type
& IS_LEVEL_2
)
1757 lsp_non_pseudo_regenerate (area
, 2);
1759 ref_time
= area
->lsp_refresh
[1] > MAX_LSP_GEN_INTERVAL
?
1760 MAX_LSP_GEN_INTERVAL
: area
->lsp_refresh
[1];
1762 THREAD_TIMER_ON (master
, area
->t_lsp_refresh
[1], lsp_refresh_l2
, area
,
1763 isis_jitter (ref_time
, MAX_AGE_JITTER
));
1769 * Something has changed -> regenerate LSP
1773 lsp_l1_regenerate (struct thread
*thread
)
1775 struct isis_area
*area
;
1777 area
= THREAD_ARG (thread
);
1778 area
->lsp_regenerate_pending
[0] = 0;
1780 return lsp_non_pseudo_regenerate (area
, 1);
1784 lsp_l2_regenerate (struct thread
*thread
)
1786 struct isis_area
*area
;
1788 area
= THREAD_ARG (thread
);
1789 area
->lsp_regenerate_pending
[1] = 0;
1791 return lsp_non_pseudo_regenerate (area
, 2);
1795 lsp_regenerate_schedule (struct isis_area
*area
)
1797 struct isis_lsp
*lsp
;
1798 u_char id
[ISIS_SYS_ID_LEN
+ 2];
1800 memcpy (id
, isis
->sysid
, ISIS_SYS_ID_LEN
);
1801 LSP_PSEUDO_ID (id
) = LSP_FRAGMENT (id
) = 0;
1806 if (area
->is_type
& IS_LEVEL_1
)
1808 lsp
= lsp_search (id
, area
->lspdb
[0]);
1809 if (!lsp
|| area
->lsp_regenerate_pending
[0])
1812 * Throttle avoidance
1814 diff
= now
- lsp
->last_generated
;
1815 if (diff
< MIN_LSP_GEN_INTERVAL
)
1817 area
->lsp_regenerate_pending
[0] = 1;
1818 thread_add_timer (master
, lsp_l1_regenerate
, area
,
1819 MIN_LSP_GEN_INTERVAL
- diff
);
1823 lsp_non_pseudo_regenerate (area
, 1);
1829 if (area
->is_type
& IS_LEVEL_2
)
1831 lsp
= lsp_search (id
, area
->lspdb
[1]);
1832 if (!lsp
|| area
->lsp_regenerate_pending
[1])
1835 * Throttle avoidance
1837 diff
= now
- lsp
->last_generated
;
1838 if (diff
< MIN_LSP_GEN_INTERVAL
)
1840 area
->lsp_regenerate_pending
[1] = 1;
1841 thread_add_timer (master
, lsp_l2_regenerate
, area
,
1842 MIN_LSP_GEN_INTERVAL
- diff
);
1846 lsp_non_pseudo_regenerate (area
, 2);
1853 * Funcs for pseudonode LSPs
1857 * 7.3.8 and 7.3.10 Generation of level 1 and 2 pseudonode LSPs
1860 lsp_build_pseudo (struct isis_lsp
*lsp
, struct isis_circuit
*circuit
,
1863 struct isis_adjacency
*adj
;
1864 struct is_neigh
*is_neigh
;
1865 struct es_neigh
*es_neigh
;
1866 struct list
*adj_list
;
1867 struct listnode
*node
;
1868 struct isis_passwd
*passwd
;
1871 assert (circuit
->circ_type
== CIRCUIT_T_BROADCAST
);
1873 if (!circuit
->u
.bc
.is_dr
[level
- 1])
1874 return; /* we are not DIS on this circuit */
1878 lsp
->lsp_header
->lsp_bits
|= IS_LEVEL_1
;
1880 lsp
->lsp_header
->lsp_bits
|= IS_LEVEL_2
;
1883 * add self to IS neighbours
1885 if (lsp
->tlv_data
.is_neighs
== NULL
)
1887 lsp
->tlv_data
.is_neighs
= list_new ();
1888 lsp
->tlv_data
.is_neighs
->del
= free_tlv
;
1890 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1891 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1892 memcpy (&is_neigh
->neigh_id
, isis
->sysid
, ISIS_SYS_ID_LEN
);
1893 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
1895 adj_list
= list_new ();
1896 isis_adj_build_up_list (circuit
->u
.bc
.adjdb
[level
- 1], adj_list
);
1898 for (node
= listhead (adj_list
); node
; nextnode (node
))
1900 adj
= getdata (node
);
1901 if (adj
->circuit_t
& level
)
1903 if ((level
== 1 && adj
->sys_type
== ISIS_SYSTYPE_L1_IS
) ||
1904 (level
== 1 && adj
->sys_type
== ISIS_SYSTYPE_L2_IS
&&
1905 adj
->adj_usage
== ISIS_ADJ_LEVEL1AND2
) ||
1906 (level
== 2 && adj
->sys_type
== ISIS_SYSTYPE_L2_IS
))
1908 /* an IS neighbour -> add it */
1909 is_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct is_neigh
));
1910 memset (is_neigh
, 0, sizeof (struct is_neigh
));
1911 memcpy (&is_neigh
->neigh_id
, adj
->sysid
, ISIS_SYS_ID_LEN
);
1912 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
1914 else if (level
== 1 && adj
->sys_type
== ISIS_SYSTYPE_ES
)
1916 /* an ES neigbour add it, if we are building level 1 LSP */
1917 /* FIXME: the tlv-format is hard to use here */
1918 if (lsp
->tlv_data
.es_neighs
== NULL
)
1920 lsp
->tlv_data
.es_neighs
= list_new ();
1921 lsp
->tlv_data
.es_neighs
->del
= free_tlv
;
1923 es_neigh
= XMALLOC (MTYPE_ISIS_TLV
, sizeof (struct es_neigh
));
1924 memset (es_neigh
, 0, sizeof (struct es_neigh
));
1925 memcpy (&es_neigh
->first_es_neigh
, adj
->sysid
, ISIS_SYS_ID_LEN
);
1926 listnode_add (lsp
->tlv_data
.es_neighs
, is_neigh
);
1931 stream_forward_endp (lsp
->pdu
, ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
1933 * Add the authentication info if it's present
1935 (level
== 1) ? (passwd
= &circuit
->area
->area_passwd
) :
1936 (passwd
= &circuit
->area
->domain_passwd
);
1939 memcpy (&lsp
->tlv_data
.auth_info
, passwd
, sizeof (struct isis_passwd
));
1940 tlv_add_authinfo (passwd
->type
, passwd
->len
, passwd
->passwd
, lsp
->pdu
);
1943 if (lsp
->tlv_data
.is_neighs
&& listcount (lsp
->tlv_data
.is_neighs
) > 0)
1944 tlv_add_is_neighs (lsp
->tlv_data
.is_neighs
, lsp
->pdu
);
1946 if (lsp
->tlv_data
.es_neighs
&& listcount (lsp
->tlv_data
.es_neighs
) > 0)
1947 tlv_add_is_neighs (lsp
->tlv_data
.es_neighs
, lsp
->pdu
);
1949 lsp
->lsp_header
->pdu_len
= htons (stream_get_endp (lsp
->pdu
));
1950 iso_csum_create (STREAM_DATA (lsp
->pdu
) + 12,
1951 ntohs (lsp
->lsp_header
->pdu_len
) - 12, 12);
1953 list_delete (adj_list
);
1959 lsp_pseudo_regenerate (struct isis_circuit
*circuit
, int level
)
1961 dict_t
*lspdb
= circuit
->area
->lspdb
[level
- 1];
1962 struct isis_lsp
*lsp
;
1963 u_char lsp_id
[ISIS_SYS_ID_LEN
+ 2];
1965 memcpy (lsp_id
, isis
->sysid
, ISIS_SYS_ID_LEN
);
1966 LSP_PSEUDO_ID (lsp_id
) = circuit
->circuit_id
;
1967 LSP_FRAGMENT (lsp_id
) = 0;
1969 lsp
= lsp_search (lsp_id
, lspdb
);
1973 zlog_err ("lsp_pseudo_regenerate(): no l%d LSP %s found!", level
,
1974 rawlspid_print (lsp_id
));
1977 lsp_clear_data (lsp
);
1979 lsp_build_pseudo (lsp
, circuit
, level
);
1981 lsp
->lsp_header
->rem_lifetime
=
1982 htons (isis_jitter (circuit
->area
->max_lsp_lifetime
[level
- 1],
1985 lsp_inc_seqnum (lsp
, 0);
1987 if (isis
->debugs
& DEBUG_UPDATE_PACKETS
)
1989 zlog_debug ("ISIS-Upd (%s): refreshing pseudo LSP L%d %s",
1990 circuit
->area
->area_tag
, level
,
1991 rawlspid_print (lsp
->lsp_header
->lsp_id
));
1994 lsp
->last_generated
= time (NULL
);
1995 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2001 lsp_l1_refresh_pseudo (struct thread
*thread
)
2003 struct isis_circuit
*circuit
;
2005 unsigned long ref_time
;
2007 circuit
= THREAD_ARG (thread
);
2009 if (!circuit
->u
.bc
.is_dr
[0])
2010 return ISIS_ERROR
; /* FIXME: purge and such */
2012 circuit
->u
.bc
.t_refresh_pseudo_lsp
[0] = NULL
;
2014 retval
= lsp_pseudo_regenerate (circuit
, 1);
2016 ref_time
= circuit
->area
->lsp_refresh
[0] > MAX_LSP_GEN_INTERVAL
?
2017 MAX_LSP_GEN_INTERVAL
: circuit
->area
->lsp_refresh
[0];
2019 THREAD_TIMER_ON (master
, circuit
->u
.bc
.t_refresh_pseudo_lsp
[0],
2020 lsp_l1_refresh_pseudo
, circuit
,
2021 isis_jitter (ref_time
, MAX_AGE_JITTER
));
2027 lsp_l1_pseudo_generate (struct isis_circuit
*circuit
)
2029 struct isis_lsp
*lsp
;
2030 u_char id
[ISIS_SYS_ID_LEN
+ 2];
2031 unsigned long ref_time
;
2033 memcpy (id
, isis
->sysid
, ISIS_SYS_ID_LEN
);
2034 LSP_FRAGMENT (id
) = 0;
2035 LSP_PSEUDO_ID (id
) = circuit
->circuit_id
;
2038 * If for some reason have a pseudo LSP in the db already -> regenerate
2040 if (lsp_search (id
, circuit
->area
->lspdb
[0]))
2041 return lsp_pseudo_regenerate (circuit
, 1);
2042 lsp
= lsp_new (id
, circuit
->area
->max_lsp_lifetime
[0],
2043 1, circuit
->area
->is_type
, 0, 1);
2045 lsp_build_pseudo (lsp
, circuit
, 1);
2048 lsp_insert (lsp
, circuit
->area
->lspdb
[0]);
2049 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2051 ref_time
= circuit
->area
->lsp_refresh
[0] > MAX_LSP_GEN_INTERVAL
?
2052 MAX_LSP_GEN_INTERVAL
: circuit
->area
->lsp_refresh
[0];
2054 THREAD_TIMER_ON (master
, circuit
->u
.bc
.t_refresh_pseudo_lsp
[0],
2055 lsp_l1_refresh_pseudo
, circuit
,
2056 isis_jitter (ref_time
, MAX_AGE_JITTER
));
2058 return lsp_regenerate_schedule (circuit
->area
);
2062 lsp_l2_refresh_pseudo (struct thread
*thread
)
2064 struct isis_circuit
*circuit
;
2066 unsigned long ref_time
;
2067 circuit
= THREAD_ARG (thread
);
2069 if (!circuit
->u
.bc
.is_dr
[1])
2070 return ISIS_ERROR
; /* FIXME: purge and such */
2072 circuit
->u
.bc
.t_refresh_pseudo_lsp
[1] = NULL
;
2074 retval
= lsp_pseudo_regenerate (circuit
, 2);
2076 ref_time
= circuit
->area
->lsp_refresh
[1] > MAX_LSP_GEN_INTERVAL
?
2077 MAX_LSP_GEN_INTERVAL
: circuit
->area
->lsp_refresh
[1];
2079 THREAD_TIMER_ON (master
, circuit
->u
.bc
.t_refresh_pseudo_lsp
[1],
2080 lsp_l2_refresh_pseudo
, circuit
,
2081 isis_jitter (ref_time
, MAX_AGE_JITTER
));
2087 lsp_l2_pseudo_generate (struct isis_circuit
*circuit
)
2089 struct isis_lsp
*lsp
;
2090 u_char id
[ISIS_SYS_ID_LEN
+ 2];
2091 unsigned long ref_time
;
2093 memcpy (id
, isis
->sysid
, ISIS_SYS_ID_LEN
);
2094 LSP_FRAGMENT (id
) = 0;
2095 LSP_PSEUDO_ID (id
) = circuit
->circuit_id
;
2097 if (lsp_search (id
, circuit
->area
->lspdb
[1]))
2098 return lsp_pseudo_regenerate (circuit
, 2);
2100 lsp
= lsp_new (id
, circuit
->area
->max_lsp_lifetime
[1],
2101 1, circuit
->area
->is_type
, 0, 2);
2103 lsp_build_pseudo (lsp
, circuit
, 2);
2105 ref_time
= circuit
->area
->lsp_refresh
[1] > MAX_LSP_GEN_INTERVAL
?
2106 MAX_LSP_GEN_INTERVAL
: circuit
->area
->lsp_refresh
[1];
2110 lsp_insert (lsp
, circuit
->area
->lspdb
[1]);
2111 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2113 THREAD_TIMER_ON (master
, circuit
->u
.bc
.t_refresh_pseudo_lsp
[1],
2114 lsp_l2_refresh_pseudo
, circuit
,
2115 isis_jitter (ref_time
, MAX_AGE_JITTER
));
2117 return lsp_regenerate_schedule (circuit
->area
);
2121 * Walk through LSPs for an area
2122 * - set remaining lifetime
2123 * - set LSPs with SRMflag set for sending
2126 lsp_tick (struct thread
*thread
)
2128 struct isis_area
*area
;
2129 struct isis_circuit
*circuit
;
2130 struct isis_lsp
*lsp
;
2131 struct list
*lsp_list
;
2132 struct listnode
*lspnode
, *cnode
;
2133 dnode_t
*dnode
, *dnode_next
;
2136 lsp_list
= list_new ();
2138 area
= THREAD_ARG (thread
);
2140 area
->t_tick
= NULL
;
2141 THREAD_TIMER_ON (master
, area
->t_tick
, lsp_tick
, area
, 1);
2144 * Build a list of LSPs with (any) SRMflag set
2145 * and removed the ones that have aged out
2147 for (level
= 0; level
< ISIS_LEVELS
; level
++)
2149 if (area
->lspdb
[level
] && dict_count (area
->lspdb
[level
]) > 0)
2151 dnode
= dict_first (area
->lspdb
[level
]);
2152 while (dnode
!= NULL
)
2154 dnode_next
= dict_next (area
->lspdb
[level
], dnode
);
2155 lsp
= dnode_get (dnode
);
2157 if (lsp
->age_out
== 0)
2160 zlog_debug ("ISIS-Upd (%s): L%u LSP %s seq 0x%08x aged out",
2163 rawlspid_print (lsp
->lsp_header
->lsp_id
),
2164 ntohl (lsp
->lsp_header
->seq_num
));
2167 dict_delete (area
->lspdb
[level
], dnode
);
2169 else if (flags_any_set (lsp
->SRMflags
))
2170 listnode_add (lsp_list
, lsp
);
2175 * Send LSPs on circuits indicated by the SRMflags
2177 if (listcount (lsp_list
) > 0)
2179 for (cnode
= listhead (area
->circuit_list
); cnode
;
2182 circuit
= getdata (cnode
);
2183 for (lspnode
= listhead (lsp_list
); lspnode
;
2186 lsp
= getdata (lspnode
);
2187 if (ISIS_CHECK_FLAG (lsp
->SRMflags
, circuit
))
2189 /* FIXME: if same or elder lsp is already in lsp
2191 listnode_add (circuit
->lsp_queue
, lsp
);
2192 thread_add_event (master
, send_lsp
, circuit
, 0);
2197 list_delete_all_node (lsp_list
);
2201 list_delete (lsp_list
);
2207 lsp_purge_dr (u_char
* id
, struct isis_circuit
*circuit
, int level
)
2209 struct isis_lsp
*lsp
;
2211 lsp
= lsp_search (id
, circuit
->area
->lspdb
[level
- 1]);
2213 if (lsp
&& lsp
->purged
== 0)
2215 lsp
->lsp_header
->rem_lifetime
= htons (0);
2216 lsp
->lsp_header
->pdu_len
=
2217 htons (ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
2219 iso_csum_create (STREAM_DATA (lsp
->pdu
) + 12,
2220 ntohs (lsp
->lsp_header
->pdu_len
) - 12, 12);
2221 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2228 * Purge own LSP that is received and we don't have.
2229 * -> Do as in 7.3.16.4
2232 lsp_purge_non_exist (struct isis_link_state_hdr
*lsp_hdr
,
2233 struct isis_area
*area
)
2235 struct isis_lsp
*lsp
;
2238 * We need to create the LSP to be purged
2240 zlog_debug ("LSP PURGE NON EXIST");
2241 lsp
= XMALLOC (MTYPE_ISIS_LSP
, sizeof (struct isis_lsp
));
2242 memset (lsp
, 0, sizeof (struct isis_lsp
));
2243 /*FIXME: BUG BUG BUG! the lsp doesn't exist here! */
2244 /*did smt here, maybe good probably not */
2245 lsp
->level
= ((lsp_hdr
->lsp_bits
& LSPBIT_IST
) == IS_LEVEL_1
) ? 1 : 2;
2246 lsp
->pdu
= stream_new (ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
2247 lsp
->isis_header
= (struct isis_fixed_hdr
*) STREAM_DATA (lsp
->pdu
);
2248 fill_fixed_hdr (lsp
->isis_header
, (lsp
->level
== 1) ? L1_LINK_STATE
2250 lsp
->lsp_header
= (struct isis_link_state_hdr
*) (STREAM_DATA (lsp
->pdu
) +
2251 ISIS_FIXED_HDR_LEN
);
2252 memcpy (lsp
->lsp_header
, lsp_hdr
, ISIS_LSP_HDR_LEN
);
2255 * Retain only LSP header
2257 lsp
->lsp_header
->pdu_len
= htons (ISIS_FIXED_HDR_LEN
+ ISIS_LSP_HDR_LEN
);
2259 * Set the remaining lifetime to 0
2261 lsp
->lsp_header
->rem_lifetime
= 0;
2263 * Put the lsp into LSPdb
2265 lsp_insert (lsp
, area
->lspdb
[lsp
->level
- 1]);
2268 * Send in to whole area
2270 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2275 #ifdef TOPOLOGY_GENERATE
2277 top_lsp_refresh (struct thread
*thread
)
2279 struct isis_lsp
*lsp
;
2281 lsp
= THREAD_ARG (thread
);
2284 lsp
->t_lsp_top_ref
= NULL
;
2286 lsp
->lsp_header
->rem_lifetime
=
2287 htons (isis_jitter (MAX_AGE
, MAX_AGE_JITTER
));
2288 lsp
->lsp_header
->seq_num
= htonl (ntohl (lsp
->lsp_header
->seq_num
) + 1);
2290 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2291 if (isis
->debugs
& DEBUG_UPDATE_PACKETS
)
2293 zlog_debug ("ISIS-Upd (): refreshing Topology L1 %s",
2294 rawlspid_print (lsp
->lsp_header
->lsp_id
));
2297 /* time to calculate our checksum */
2298 iso_csum_create (STREAM_DATA (lsp
->pdu
) + 12,
2299 ntohs (lsp
->lsp_header
->pdu_len
) - 12, 12);
2300 THREAD_TIMER_ON (master
, lsp
->t_lsp_top_ref
, top_lsp_refresh
, lsp
,
2301 isis_jitter (MAX_LSP_GEN_INTERVAL
, MAX_LSP_GEN_JITTER
));
2307 generate_topology_lsps (struct isis_area
*area
)
2309 struct listnode
*node
;
2312 u_char lspid
[ISIS_SYS_ID_LEN
+ 2];
2313 struct isis_lsp
*lsp
;
2315 /* first we find the maximal node */
2316 LIST_LOOP (area
->topology
, arc
, node
)
2318 if (arc
->from_node
> max
)
2319 max
= arc
->from_node
;
2320 if (arc
->to_node
> max
)
2324 for (i
= 1; i
< (max
+ 1); i
++)
2326 memcpy (lspid
, area
->topology_baseis
, ISIS_SYS_ID_LEN
);
2327 LSP_PSEUDO_ID (lspid
) = 0x00;
2328 LSP_FRAGMENT (lspid
) = 0x00;
2329 lspid
[ISIS_SYS_ID_LEN
- 1] = (i
& 0xFF);
2330 lspid
[ISIS_SYS_ID_LEN
- 2] = ((i
>> 8) & 0xFF);
2332 lsp
= lsp_new (lspid
, isis_jitter (area
->max_lsp_lifetime
[0],
2333 MAX_AGE_JITTER
), 1, IS_LEVEL_1
, 0,
2335 lsp
->from_topology
= 1;
2336 /* creating data based on topology */
2337 build_topology_lsp_data (lsp
, area
, i
);
2338 /* time to calculate our checksum */
2339 iso_csum_create (STREAM_DATA (lsp
->pdu
) + 12,
2340 ntohs (lsp
->lsp_header
->pdu_len
) - 12, 12);
2341 THREAD_TIMER_ON (master
, lsp
->t_lsp_top_ref
, top_lsp_refresh
, lsp
,
2342 isis_jitter (MAX_LSP_GEN_INTERVAL
,
2343 MAX_LSP_GEN_JITTER
));
2345 ISIS_FLAGS_SET_ALL (lsp
->SRMflags
);
2346 lsp_insert (lsp
, area
->lspdb
[0]);
2352 remove_topology_lsps (struct isis_area
*area
)
2354 struct isis_lsp
*lsp
;
2355 dnode_t
*dnode
, *dnode_next
;
2357 dnode
= dict_first (area
->lspdb
[0]);
2358 while (dnode
!= NULL
)
2360 dnode_next
= dict_next (area
->lspdb
[0], dnode
);
2361 lsp
= dnode_get (dnode
);
2362 if (lsp
->from_topology
)
2364 THREAD_TIMER_OFF (lsp
->t_lsp_top_ref
);
2366 dict_delete (area
->lspdb
[0], dnode
);
2373 build_topology_lsp_data (struct isis_lsp
*lsp
, struct isis_area
*area
,
2376 struct listnode
*node
;
2379 struct is_neigh
*is_neigh
;
2383 /* add our nlpids */
2384 /* the 2 is for the TL plus 1 for the nlpid */
2385 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 3);
2386 *tlv_ptr
= PROTOCOLS_SUPPORTED
; /* Type */
2387 *(tlv_ptr
+ 1) = 1; /* one protocol */
2388 *(tlv_ptr
+ 2) = NLPID_IP
;
2389 lsp
->tlv_data
.nlpids
= (struct nlpids
*) (tlv_ptr
+ 1);
2391 /* first, lets add the tops */
2392 /* the 2 is for the TL plus 1 for the virtual field */
2393 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 3);
2394 *tlv_ptr
= IS_NEIGHBOURS
; /* Type */
2395 *(tlv_ptr
+ 1) = 1; /* this is the virtual char len */
2396 *(tlv_ptr
+ 2) = 0; /* virtual is zero */
2397 lsp
->tlv_data
.is_neighs
= list_new (); /* new list of is_neighbours */
2399 /* add reachability for this IS for simulated 1 */
2400 if (lsp_top_num
== 1)
2402 /* assign space for the is_neigh at the pdu end */
2403 is_neigh
= (struct is_neigh
*) lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
,
2406 /* add this node to our list */
2407 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
2408 memcpy (&is_neigh
->neigh_id
, isis
->sysid
, ISIS_SYS_ID_LEN
);
2409 LSP_PSEUDO_ID (is_neigh
->neigh_id
) = 0x00;
2410 is_neigh
->metrics
.metric_default
= 0x00; /* no special reason */
2411 is_neigh
->metrics
.metric_delay
= METRICS_UNSUPPORTED
;
2412 is_neigh
->metrics
.metric_expense
= METRICS_UNSUPPORTED
;
2413 is_neigh
->metrics
.metric_error
= METRICS_UNSUPPORTED
;
2414 /* don't forget the length */
2415 *(tlv_ptr
+ 1) += IS_NEIGHBOURS_LEN
; /* the -1 is the virtual */
2416 /* no need to check for fragging here, it is a lonely is_reach */
2419 /* addding is reachabilities */
2420 LIST_LOOP (area
->topology
, arc
, node
)
2422 if ((arc
->from_node
== lsp_top_num
) || (arc
->to_node
== lsp_top_num
))
2424 if (arc
->to_node
== lsp_top_num
)
2425 to_lsp
= arc
->from_node
;
2426 if (arc
->from_node
== lsp_top_num
)
2427 to_lsp
= arc
->to_node
;
2429 /* if the length here is about to cross the FF limit, we reTLV */
2430 if (*(tlv_ptr
+ 1) >= (0xFF - IS_NEIGHBOURS_LEN
))
2433 /* the 2 is for the TL plus 1 for the virtual field */
2434 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 3);
2435 *tlv_ptr
= IS_NEIGHBOURS
; /* Type */
2436 *(tlv_ptr
+ 1) = 1; /* this is the virtual char len */
2437 *(tlv_ptr
+ 2) = 0; /* virtual is zero */
2439 /* doing this here assures us that we won't add an "empty" tlv */
2440 /* assign space for the is_neigh at the pdu end */
2441 is_neigh
= (struct is_neigh
*) lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
,
2444 /* add this node to our list */
2445 listnode_add (lsp
->tlv_data
.is_neighs
, is_neigh
);
2446 memcpy (&is_neigh
->neigh_id
, area
->topology_baseis
, ISIS_SYS_ID_LEN
);
2447 LSP_PSEUDO_ID (is_neigh
->neigh_id
) = 0x00;
2448 is_neigh
->neigh_id
[ISIS_SYS_ID_LEN
- 1] = (to_lsp
& 0xFF);
2449 is_neigh
->neigh_id
[ISIS_SYS_ID_LEN
- 2] = ((to_lsp
>> 8) & 0xFF);
2450 is_neigh
->metrics
.metric_default
= arc
->distance
;
2451 is_neigh
->metrics
.metric_delay
= METRICS_UNSUPPORTED
;
2452 is_neigh
->metrics
.metric_expense
= METRICS_UNSUPPORTED
;
2453 is_neigh
->metrics
.metric_error
= METRICS_UNSUPPORTED
;
2454 /* don't forget the length */
2455 *(tlv_ptr
+ 1) += IS_NEIGHBOURS_LEN
; /* the -1 is the virtual */
2459 /* adding dynamic hostname if needed */
2460 if (area
->dynhostname
)
2462 memset (buff
, 0x00, 200);
2463 sprintf (buff
, "feedme%d", lsp_top_num
);
2464 /* the 2 is for the TL */
2465 tlv_ptr
= lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, 2);
2466 *tlv_ptr
= DYNAMIC_HOSTNAME
; /* Type */
2467 *(tlv_ptr
+ 1) = strlen (buff
); /* Length */
2468 /* the -1 is to fit the length in the struct */
2469 lsp
->tlv_data
.hostname
= (struct hostname
*)
2470 (lsppdu_realloc (lsp
, MTYPE_ISIS_TLV
, strlen (buff
)) - 1);
2471 memcpy (lsp
->tlv_data
.hostname
->name
, buff
, strlen (buff
));
2474 /* thanks to hannes, another bug bites the dust */
2475 lsp
->pdu
->endp
= ntohs (lsp
->lsp_header
->pdu_len
);
2477 #endif /* TOPOLOGY_GENERATE */