1 /*
2 * IS-IS Rout(e)ing protocol - isis_lsp.c
3 * LSP processing
4 *
5 * Copyright (C) 2001,2002 Sampo Saaristo
6 * Tampere University of Technology
7 * Institute of Communications Engineering
8 * Copyright (C) 2013-2015 Christian Franke <chris@opensourcerouting.org>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version.
14 *
15 * This program is distributed in the hope that it will be useful,but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * more details.
19
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 */
24
25 #include <zebra.h>
26
27 #include "linklist.h"
28 #include "thread.h"
29 #include "vty.h"
30 #include "stream.h"
31 #include "memory.h"
32 #include "log.h"
33 #include "prefix.h"
34 #include "command.h"
35 #include "hash.h"
36 #include "if.h"
37 #include "checksum.h"
38 #include "md5.h"
39 #include "table.h"
40
41 #include "isisd/dict.h"
42 #include "isisd/isis_constants.h"
43 #include "isisd/isis_common.h"
44 #include "isisd/isis_flags.h"
45 #include "isisd/isis_circuit.h"
46 #include "isisd/isisd.h"
47 #include "isisd/isis_tlv.h"
48 #include "isisd/isis_lsp.h"
49 #include "isisd/isis_pdu.h"
50 #include "isisd/isis_dynhn.h"
51 #include "isisd/isis_misc.h"
52 #include "isisd/isis_csm.h"
53 #include "isisd/isis_adjacency.h"
54 #include "isisd/isis_spf.h"
55 #include "isisd/isis_te.h"
56
57 #ifdef TOPOLOGY_GENERATE
58 #include "spgrid.h"
59 #endif
60
61 /* staticly assigned vars for printing purposes */
62 char lsp_bits_string[200]; /* FIXME: enough ? */
63
64 static int lsp_l1_refresh (struct thread *thread);
65 static int lsp_l2_refresh (struct thread *thread);
66 static int lsp_l1_refresh_pseudo (struct thread *thread);
67 static int lsp_l2_refresh_pseudo (struct thread *thread);
68
69 int
lsp_id_cmp(u_char * id1,u_char * id2)70 lsp_id_cmp (u_char * id1, u_char * id2)
71 {
72 return memcmp (id1, id2, ISIS_SYS_ID_LEN + 2);
73 }
74
75 dict_t *
lsp_db_init(void)76 lsp_db_init (void)
77 {
78 dict_t *dict;
79
80 dict = dict_create (DICTCOUNT_T_MAX, (dict_comp_t) lsp_id_cmp);
81
82 return dict;
83 }
84
85 struct isis_lsp *
lsp_search(u_char * id,dict_t * lspdb)86 lsp_search (u_char * id, dict_t * lspdb)
87 {
88 dnode_t *node;
89
90 #ifdef EXTREME_DEBUG
91 dnode_t *dn;
92
93 zlog_debug ("searching db");
94 for (dn = dict_first (lspdb); dn; dn = dict_next (lspdb, dn))
95 {
96 zlog_debug ("%s\t%pX", rawlspid_print ((u_char *) dnode_getkey (dn)),
97 dnode_get (dn));
98 }
99 #endif /* EXTREME DEBUG */
100
101 node = dict_lookup (lspdb, id);
102
103 if (node)
104 return (struct isis_lsp *) dnode_get (node);
105
106 return NULL;
107 }
108
109 static void
lsp_clear_data(struct isis_lsp * lsp)110 lsp_clear_data (struct isis_lsp *lsp)
111 {
112 if (!lsp)
113 return;
114
115 if (lsp->tlv_data.hostname)
116 isis_dynhn_remove (lsp->lsp_header->lsp_id);
117
118 if (lsp->own_lsp)
119 {
120 if (lsp->tlv_data.nlpids)
121 XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.nlpids);
122 if (lsp->tlv_data.hostname)
123 XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.hostname);
124 if (lsp->tlv_data.router_id)
125 XFREE (MTYPE_ISIS_TLV, lsp->tlv_data.router_id);
126 }
127
128 free_tlvs (&lsp->tlv_data);
129 }
130
131 static void
lsp_destroy(struct isis_lsp * lsp)132 lsp_destroy (struct isis_lsp *lsp)
133 {
134 struct listnode *cnode, *lnode, *lnnode;
135 struct isis_lsp *lsp_in_list;
136 struct isis_circuit *circuit;
137
138 if (!lsp)
139 return;
140
141 if (lsp->area->circuit_list) {
142 for (ALL_LIST_ELEMENTS_RO (lsp->area->circuit_list, cnode, circuit))
143 {
144 if (circuit->lsp_queue == NULL)
145 continue;
146 for (ALL_LIST_ELEMENTS (circuit->lsp_queue, lnode, lnnode, lsp_in_list))
147 if (lsp_in_list == lsp)
148 list_delete_node(circuit->lsp_queue, lnode);
149 }
150 }
151 ISIS_FLAGS_CLEAR_ALL (lsp->SSNflags);
152 ISIS_FLAGS_CLEAR_ALL (lsp->SRMflags);
153
154 lsp_clear_data (lsp);
155
156 if (LSP_FRAGMENT (lsp->lsp_header->lsp_id) == 0 && lsp->lspu.frags)
157 {
158 list_delete (lsp->lspu.frags);
159 lsp->lspu.frags = NULL;
160 }
161
162 isis_spf_schedule (lsp->area, lsp->level);
163 #ifdef HAVE_IPV6
164 isis_spf_schedule6 (lsp->area, lsp->level);
165 #endif
166
167 if (lsp->pdu)
168 stream_free (lsp->pdu);
169 XFREE (MTYPE_ISIS_LSP, lsp);
170 }
171
172 void
lsp_db_destroy(dict_t * lspdb)173 lsp_db_destroy (dict_t * lspdb)
174 {
175 dnode_t *dnode, *next;
176 struct isis_lsp *lsp;
177
178 dnode = dict_first (lspdb);
179 while (dnode)
180 {
181 next = dict_next (lspdb, dnode);
182 lsp = dnode_get (dnode);
183 lsp_destroy (lsp);
184 dict_delete_free (lspdb, dnode);
185 dnode = next;
186 }
187
188 dict_free (lspdb);
189
190 return;
191 }
192
193 /*
194 * Remove all the frags belonging to the given lsp
195 */
196 static void
lsp_remove_frags(struct list * frags,dict_t * lspdb)197 lsp_remove_frags (struct list *frags, dict_t * lspdb)
198 {
199 dnode_t *dnode;
200 struct listnode *lnode, *lnnode;
201 struct isis_lsp *lsp;
202
203 for (ALL_LIST_ELEMENTS (frags, lnode, lnnode, lsp))
204 {
205 dnode = dict_lookup (lspdb, lsp->lsp_header->lsp_id);
206 lsp_destroy (lsp);
207 dnode_destroy (dict_delete (lspdb, dnode));
208 }
209
210 list_delete_all_node (frags);
211
212 return;
213 }
214
215 void
lsp_search_and_destroy(u_char * id,dict_t * lspdb)216 lsp_search_and_destroy (u_char * id, dict_t * lspdb)
217 {
218 dnode_t *node;
219 struct isis_lsp *lsp;
220
221 node = dict_lookup (lspdb, id);
222 if (node)
223 {
224 node = dict_delete (lspdb, node);
225 lsp = dnode_get (node);
226 /*
227 * If this is a zero lsp, remove all the frags now
228 */
229 if (LSP_FRAGMENT (lsp->lsp_header->lsp_id) == 0)
230 {
231 if (lsp->lspu.frags)
232 lsp_remove_frags (lsp->lspu.frags, lspdb);
233 }
234 else
235 {
236 /*
237 * else just remove this frag, from the zero lsps' frag list
238 */
239 if (lsp->lspu.zero_lsp && lsp->lspu.zero_lsp->lspu.frags)
240 listnode_delete (lsp->lspu.zero_lsp->lspu.frags, lsp);
241 }
242 lsp_destroy (lsp);
243 dnode_destroy (node);
244 }
245 }
246
247 /*
248 * Compares a LSP to given values
249 * Params are given in net order
250 */
251 int
lsp_compare(char * areatag,struct isis_lsp * lsp,u_int32_t seq_num,u_int16_t checksum,u_int16_t rem_lifetime)252 lsp_compare (char *areatag, struct isis_lsp *lsp, u_int32_t seq_num,
253 u_int16_t checksum, u_int16_t rem_lifetime)
254 {
255 /* no point in double ntohl on seqnum */
256 if (lsp->lsp_header->seq_num == seq_num &&
257 lsp->lsp_header->checksum == checksum &&
258 /*comparing with 0, no need to do ntohl */
259 ((lsp->lsp_header->rem_lifetime == 0 && rem_lifetime == 0) ||
260 (lsp->lsp_header->rem_lifetime != 0 && rem_lifetime != 0)))
261 {
262 if (isis->debugs & DEBUG_SNP_PACKETS)
263 {
264 zlog_debug ("ISIS-Snp (%s): Compare LSP %s seq 0x%08x, cksum 0x%04x,"
265 " lifetime %us",
266 areatag,
267 rawlspid_print (lsp->lsp_header->lsp_id),
268 ntohl (lsp->lsp_header->seq_num),
269 ntohs (lsp->lsp_header->checksum),
270 ntohs (lsp->lsp_header->rem_lifetime));
271 zlog_debug ("ISIS-Snp (%s): is equal to ours seq 0x%08x,"
272 " cksum 0x%04x, lifetime %us",
273 areatag,
274 ntohl (seq_num), ntohs (checksum), ntohs (rem_lifetime));
275 }
276 return LSP_EQUAL;
277 }
278
279 /*
280 * LSPs with identical checksums should only be treated as newer if:
281 * a) The current LSP has a remaining lifetime != 0 and the other LSP has a
282 * remaining lifetime == 0. In this case, we should participate in the purge
283 * and should not treat the current LSP with remaining lifetime == 0 as older.
284 * b) The LSP has an incorrect checksum. In this case, we need to react as given
285 * in 7.3.16.2.
286 */
287 if (ntohl (seq_num) > ntohl (lsp->lsp_header->seq_num)
288 || (ntohl(seq_num) == ntohl(lsp->lsp_header->seq_num)
289 && ( (lsp->lsp_header->rem_lifetime != 0
290 && rem_lifetime == 0)
291 || lsp->lsp_header->checksum != checksum)))
292 {
293 if (isis->debugs & DEBUG_SNP_PACKETS)
294 {
295 zlog_debug ("ISIS-Snp (%s): Compare LSP %s seq 0x%08x, cksum 0x%04x,"
296 " lifetime %us",
297 areatag,
298 rawlspid_print (lsp->lsp_header->lsp_id),
299 ntohl (seq_num), ntohs (checksum), ntohs (rem_lifetime));
300 zlog_debug ("ISIS-Snp (%s): is newer than ours seq 0x%08x, "
301 "cksum 0x%04x, lifetime %us",
302 areatag,
303 ntohl (lsp->lsp_header->seq_num),
304 ntohs (lsp->lsp_header->checksum),
305 ntohs (lsp->lsp_header->rem_lifetime));
306 }
307 return LSP_NEWER;
308 }
309 if (isis->debugs & DEBUG_SNP_PACKETS)
310 {
311 zlog_debug
312 ("ISIS-Snp (%s): Compare LSP %s seq 0x%08x, cksum 0x%04x, lifetime %us",
313 areatag, rawlspid_print (lsp->lsp_header->lsp_id), ntohl (seq_num),
314 ntohs (checksum), ntohs (rem_lifetime));
315 zlog_debug ("ISIS-Snp (%s): is older than ours seq 0x%08x,"
316 " cksum 0x%04x, lifetime %us", areatag,
317 ntohl (lsp->lsp_header->seq_num),
318 ntohs (lsp->lsp_header->checksum),
319 ntohs (lsp->lsp_header->rem_lifetime));
320 }
321
322 return LSP_OLDER;
323 }
324
325 static void
lsp_auth_add(struct isis_lsp * lsp)326 lsp_auth_add (struct isis_lsp *lsp)
327 {
328 struct isis_passwd *passwd;
329 unsigned char hmac_md5_hash[ISIS_AUTH_MD5_SIZE];
330
331 /*
332 * Add the authentication info if its present
333 */
334 (lsp->level == IS_LEVEL_1) ? (passwd = &lsp->area->area_passwd) :
335 (passwd = &lsp->area->domain_passwd);
336 switch (passwd->type)
337 {
338 /* Cleartext */
339 case ISIS_PASSWD_TYPE_CLEARTXT:
340 memcpy (&lsp->tlv_data.auth_info, passwd, sizeof (struct isis_passwd));
341 tlv_add_authinfo (passwd->type, passwd->len, passwd->passwd, lsp->pdu);
342 break;
343
344 /* HMAC MD5 */
345 case ISIS_PASSWD_TYPE_HMAC_MD5:
346 /* Remember where TLV is written so we can later
347 * overwrite the MD5 hash */
348 lsp->auth_tlv_offset = stream_get_endp (lsp->pdu);
349 memset(&hmac_md5_hash, 0, ISIS_AUTH_MD5_SIZE);
350 lsp->tlv_data.auth_info.type = ISIS_PASSWD_TYPE_HMAC_MD5;
351 lsp->tlv_data.auth_info.len = ISIS_AUTH_MD5_SIZE;
352 memcpy (&lsp->tlv_data.auth_info.passwd, hmac_md5_hash,
353 ISIS_AUTH_MD5_SIZE);
354 tlv_add_authinfo (passwd->type, ISIS_AUTH_MD5_SIZE, hmac_md5_hash,
355 lsp->pdu);
356 break;
357
358 default:
359 break;
360 }
361 }
362
363 static void
lsp_auth_update(struct isis_lsp * lsp)364 lsp_auth_update (struct isis_lsp *lsp)
365 {
366 struct isis_passwd *passwd;
367 unsigned char hmac_md5_hash[ISIS_AUTH_MD5_SIZE];
368 uint16_t checksum, rem_lifetime;
369
370 /* For HMAC MD5 we need to recompute the md5 hash and store it */
371 (lsp->level == IS_LEVEL_1) ? (passwd = &lsp->area->area_passwd) :
372 (passwd = &lsp->area->domain_passwd);
373 if (passwd->type != ISIS_PASSWD_TYPE_HMAC_MD5)
374 return;
375
376 /*
377 * In transient conditions (when net is configured where authentication
378 * config and lsp regenerate schedule is not yet run), there could be
379 * an own_lsp with auth_tlv_offset set to 0. In such a case, simply
380 * return, when lsp_regenerate is run, lsp will have auth tlv.
381 */
382 if (lsp->auth_tlv_offset == 0)
383 return;
384
385 /*
386 * RFC 5304 set auth value, checksum and remaining lifetime to zero
387 * before computation and reset to old values after computation.
388 */
389 checksum = lsp->lsp_header->checksum;
390 rem_lifetime = lsp->lsp_header->rem_lifetime;
391 lsp->lsp_header->checksum = 0;
392 lsp->lsp_header->rem_lifetime = 0;
393 /* Set the authentication value as well to zero */
394 memset (STREAM_DATA (lsp->pdu) + lsp->auth_tlv_offset + 3,
395 0, ISIS_AUTH_MD5_SIZE);
396 /* Compute autentication value */
397 hmac_md5 (STREAM_DATA (lsp->pdu), stream_get_endp(lsp->pdu),
398 (unsigned char *) &passwd->passwd, passwd->len,
399 (unsigned char *) &hmac_md5_hash);
400 /* Copy the hash into the stream */
401 memcpy (STREAM_DATA (lsp->pdu) + lsp->auth_tlv_offset + 3,
402 hmac_md5_hash, ISIS_AUTH_MD5_SIZE);
403 memcpy (&lsp->tlv_data.auth_info.passwd, hmac_md5_hash,
404 ISIS_AUTH_MD5_SIZE);
405 /* Copy back the checksum and remaining lifetime */
406 lsp->lsp_header->checksum = checksum;
407 lsp->lsp_header->rem_lifetime = rem_lifetime;
408 }
409
410 void
lsp_inc_seqnum(struct isis_lsp * lsp,u_int32_t seq_num)411 lsp_inc_seqnum (struct isis_lsp *lsp, u_int32_t seq_num)
412 {
413 u_int32_t newseq;
414
415 if (seq_num == 0 || ntohl (lsp->lsp_header->seq_num) > seq_num)
416 newseq = ntohl (lsp->lsp_header->seq_num) + 1;
417 else
418 newseq = seq_num + 1;
419
420 lsp->lsp_header->seq_num = htonl (newseq);
421
422 /* Recompute authentication and checksum information */
423 lsp_auth_update (lsp);
424 /* ISO 10589 - 7.3.11 Generation of the checksum
425 * The checksum shall be computed over all fields in the LSP which appear
426 * after the Remaining Lifetime field. This field (and those appearing
427 * before it) are excluded so that the LSP may be aged by systems without
428 * requiring recomputation.
429 */
430 fletcher_checksum(STREAM_DATA (lsp->pdu) + 12,
431 ntohs (lsp->lsp_header->pdu_len) - 12, 12);
432
433 isis_spf_schedule (lsp->area, lsp->level);
434 #ifdef HAVE_IPV6
435 isis_spf_schedule6 (lsp->area, lsp->level);
436 #endif
437
438 return;
439 }
440
441 /*
442 * Genetates checksum for LSP and its frags
443 */
444 static void
lsp_seqnum_update(struct isis_lsp * lsp0)445 lsp_seqnum_update (struct isis_lsp *lsp0)
446 {
447 struct isis_lsp *lsp;
448 struct listnode *node;
449
450 lsp_inc_seqnum (lsp0, 0);
451
452 if (!lsp0->lspu.frags)
453 return;
454
455 for (ALL_LIST_ELEMENTS_RO (lsp0->lspu.frags, node, lsp))
456 lsp_inc_seqnum (lsp, 0);
457
458 return;
459 }
460
461 static u_int8_t
lsp_bits_generate(int level,int overload_bit,int attached_bit)462 lsp_bits_generate (int level, int overload_bit, int attached_bit)
463 {
464 u_int8_t lsp_bits = 0;
465 if (level == IS_LEVEL_1)
466 lsp_bits = IS_LEVEL_1;
467 else
468 lsp_bits = IS_LEVEL_1_AND_2;
469 if (overload_bit)
470 lsp_bits |= overload_bit;
471 if (attached_bit)
472 lsp_bits |= attached_bit;
473 return lsp_bits;
474 }
475
476 static void
lsp_update_data(struct isis_lsp * lsp,struct stream * stream,struct isis_area * area,int level)477 lsp_update_data (struct isis_lsp *lsp, struct stream *stream,
478 struct isis_area *area, int level)
479 {
480 uint32_t expected = 0, found;
481 int retval;
482
483 /* free the old lsp data */
484 lsp_clear_data (lsp);
485
486 /* copying only the relevant part of our stream */
487 if (lsp->pdu != NULL)
488 stream_free (lsp->pdu);
489 lsp->pdu = stream_dup (stream);
490
491 /* setting pointers to the correct place */
492 lsp->isis_header = (struct isis_fixed_hdr *) (STREAM_DATA (lsp->pdu));
493 lsp->lsp_header = (struct isis_link_state_hdr *) (STREAM_DATA (lsp->pdu) +
494 ISIS_FIXED_HDR_LEN);
495 lsp->area = area;
496 lsp->level = level;
497 lsp->age_out = ZERO_AGE_LIFETIME;
498 lsp->installed = time (NULL);
499 /*
500 * Get LSP data i.e. TLVs
501 */
502 expected |= TLVFLAG_AUTH_INFO;
503 expected |= TLVFLAG_AREA_ADDRS;
504 expected |= TLVFLAG_IS_NEIGHS;
505 expected |= TLVFLAG_NLPID;
506 if (area->dynhostname)
507 expected |= TLVFLAG_DYN_HOSTNAME;
508 if (area->newmetric)
509 {
510 expected |= TLVFLAG_TE_IS_NEIGHS;
511 expected |= TLVFLAG_TE_IPV4_REACHABILITY;
512 expected |= TLVFLAG_TE_ROUTER_ID;
513 }
514 expected |= TLVFLAG_IPV4_ADDR;
515 expected |= TLVFLAG_IPV4_INT_REACHABILITY;
516 expected |= TLVFLAG_IPV4_EXT_REACHABILITY;
517 #ifdef HAVE_IPV6
518 expected |= TLVFLAG_IPV6_ADDR;
519 expected |= TLVFLAG_IPV6_REACHABILITY;
520 #endif /* HAVE_IPV6 */
521
522 retval = parse_tlvs (area->area_tag, STREAM_DATA (lsp->pdu) +
523 ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN,
524 ntohs (lsp->lsp_header->pdu_len) -
525 ISIS_FIXED_HDR_LEN - ISIS_LSP_HDR_LEN,
526 &expected, &found, &lsp->tlv_data,
527 NULL);
528 if (retval != ISIS_OK)
529 {
530 zlog_warn ("Could not parse LSP");
531 return;
532 }
533
534 if ((found & TLVFLAG_DYN_HOSTNAME) && (area->dynhostname))
535 {
536 isis_dynhn_insert (lsp->lsp_header->lsp_id, lsp->tlv_data.hostname,
537 (lsp->lsp_header->lsp_bits & LSPBIT_IST) ==
538 IS_LEVEL_1_AND_2 ? IS_LEVEL_2 : IS_LEVEL_1);
539 }
540
541 return;
542 }
543
544 void
lsp_update(struct isis_lsp * lsp,struct stream * stream,struct isis_area * area,int level)545 lsp_update (struct isis_lsp *lsp, struct stream *stream,
546 struct isis_area *area, int level)
547 {
548 dnode_t *dnode = NULL;
549
550 /* Remove old LSP from database. This is required since the
551 * lsp_update_data will free the lsp->pdu (which has the key, lsp_id)
552 * and will update it with the new data in the stream. */
553 dnode = dict_lookup (area->lspdb[level - 1], lsp->lsp_header->lsp_id);
554 if (dnode)
555 dnode_destroy (dict_delete (area->lspdb[level - 1], dnode));
556
557 /* rebuild the lsp data */
558 lsp_update_data (lsp, stream, area, level);
559
560 /* insert the lsp back into the database */
561 lsp_insert (lsp, area->lspdb[level - 1]);
562 }
563
564 /* creation of LSP directly from what we received */
565 struct isis_lsp *
lsp_new_from_stream_ptr(struct stream * stream,u_int16_t pdu_len,struct isis_lsp * lsp0,struct isis_area * area,int level)566 lsp_new_from_stream_ptr (struct stream *stream,
567 u_int16_t pdu_len, struct isis_lsp *lsp0,
568 struct isis_area *area, int level)
569 {
570 struct isis_lsp *lsp;
571
572 lsp = XCALLOC (MTYPE_ISIS_LSP, sizeof (struct isis_lsp));
573 lsp_update_data (lsp, stream, area, level);
574
575 if (lsp0 == NULL)
576 {
577 /*
578 * zero lsp -> create the list for fragments
579 */
580 lsp->lspu.frags = list_new ();
581 }
582 else
583 {
584 /*
585 * a fragment -> set the backpointer and add this to zero lsps frag list
586 */
587 lsp->lspu.zero_lsp = lsp0;
588 listnode_add (lsp0->lspu.frags, lsp);
589 }
590
591 return lsp;
592 }
593
594 struct isis_lsp *
lsp_new(struct isis_area * area,u_char * lsp_id,u_int16_t rem_lifetime,u_int32_t seq_num,u_int8_t lsp_bits,u_int16_t checksum,int level)595 lsp_new(struct isis_area *area, u_char * lsp_id,
596 u_int16_t rem_lifetime, u_int32_t seq_num,
597 u_int8_t lsp_bits, u_int16_t checksum, int level)
598 {
599 struct isis_lsp *lsp;
600
601 lsp = XCALLOC (MTYPE_ISIS_LSP, sizeof (struct isis_lsp));
602 lsp->area = area;
603
604 lsp->pdu = stream_new(LLC_LEN + area->lsp_mtu);
605 if (LSP_FRAGMENT (lsp_id) == 0)
606 lsp->lspu.frags = list_new ();
607 lsp->isis_header = (struct isis_fixed_hdr *) (STREAM_DATA (lsp->pdu));
608 lsp->lsp_header = (struct isis_link_state_hdr *)
609 (STREAM_DATA (lsp->pdu) + ISIS_FIXED_HDR_LEN);
610
611 /* at first we fill the FIXED HEADER */
612 (level == IS_LEVEL_1) ? fill_fixed_hdr (lsp->isis_header, L1_LINK_STATE) :
613 fill_fixed_hdr (lsp->isis_header, L2_LINK_STATE);
614
615 /* now for the LSP HEADER */
616 /* Minimal LSP PDU size */
617 lsp->lsp_header->pdu_len = htons (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
618 memcpy (lsp->lsp_header->lsp_id, lsp_id, ISIS_SYS_ID_LEN + 2);
619 lsp->lsp_header->checksum = checksum; /* Provided in network order */
620 lsp->lsp_header->seq_num = htonl (seq_num);
621 lsp->lsp_header->rem_lifetime = htons (rem_lifetime);
622 lsp->lsp_header->lsp_bits = lsp_bits;
623 lsp->level = level;
624 lsp->age_out = ZERO_AGE_LIFETIME;
625
626 stream_forward_endp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
627
628 if (isis->debugs & DEBUG_EVENTS)
629 zlog_debug ("New LSP with ID %s-%02x-%02x len %d seqnum %08x",
630 sysid_print (lsp_id), LSP_PSEUDO_ID (lsp->lsp_header->lsp_id),
631 LSP_FRAGMENT (lsp->lsp_header->lsp_id),
632 ntohl (lsp->lsp_header->pdu_len),
633 ntohl (lsp->lsp_header->seq_num));
634
635 return lsp;
636 }
637
638 void
lsp_insert(struct isis_lsp * lsp,dict_t * lspdb)639 lsp_insert (struct isis_lsp *lsp, dict_t * lspdb)
640 {
641 dict_alloc_insert (lspdb, lsp->lsp_header->lsp_id, lsp);
642 if (lsp->lsp_header->seq_num != 0)
643 {
644 isis_spf_schedule (lsp->area, lsp->level);
645 #ifdef HAVE_IPV6
646 isis_spf_schedule6 (lsp->area, lsp->level);
647 #endif
648 }
649 }
650
651 /*
652 * Build a list of LSPs with non-zero ht bounded by start and stop ids
653 */
654 void
lsp_build_list_nonzero_ht(u_char * start_id,u_char * stop_id,struct list * list,dict_t * lspdb)655 lsp_build_list_nonzero_ht (u_char * start_id, u_char * stop_id,
656 struct list *list, dict_t * lspdb)
657 {
658 dnode_t *first, *last, *curr;
659
660 first = dict_lower_bound (lspdb, start_id);
661 if (!first)
662 return;
663
664 last = dict_upper_bound (lspdb, stop_id);
665
666 curr = first;
667
668 if (((struct isis_lsp *) (curr->dict_data))->lsp_header->rem_lifetime)
669 listnode_add (list, first->dict_data);
670
671 while (curr)
672 {
673 curr = dict_next (lspdb, curr);
674 if (curr &&
675 ((struct isis_lsp *) (curr->dict_data))->lsp_header->rem_lifetime)
676 listnode_add (list, curr->dict_data);
677 if (curr == last)
678 break;
679 }
680
681 return;
682 }
683
684 /*
685 * Build a list of num_lsps LSPs bounded by start_id and stop_id.
686 */
687 void
lsp_build_list(u_char * start_id,u_char * stop_id,u_char num_lsps,struct list * list,dict_t * lspdb)688 lsp_build_list (u_char * start_id, u_char * stop_id, u_char num_lsps,
689 struct list *list, dict_t * lspdb)
690 {
691 u_char count;
692 dnode_t *first, *last, *curr;
693
694 first = dict_lower_bound (lspdb, start_id);
695 if (!first)
696 return;
697
698 last = dict_upper_bound (lspdb, stop_id);
699
700 curr = first;
701
702 listnode_add (list, first->dict_data);
703 count = 1;
704
705 while (curr)
706 {
707 curr = dict_next (lspdb, curr);
708 if (curr)
709 {
710 listnode_add (list, curr->dict_data);
711 count++;
712 }
713 if (count == num_lsps || curr == last)
714 break;
715 }
716
717 return;
718 }
719
720 /*
721 * Build a list of LSPs with SSN flag set for the given circuit
722 */
723 void
lsp_build_list_ssn(struct isis_circuit * circuit,u_char num_lsps,struct list * list,dict_t * lspdb)724 lsp_build_list_ssn (struct isis_circuit *circuit, u_char num_lsps,
725 struct list *list, dict_t * lspdb)
726 {
727 dnode_t *dnode, *next;
728 struct isis_lsp *lsp;
729 u_char count = 0;
730
731 dnode = dict_first (lspdb);
732 while (dnode != NULL)
733 {
734 next = dict_next (lspdb, dnode);
735 lsp = dnode_get (dnode);
736 if (ISIS_CHECK_FLAG (lsp->SSNflags, circuit))
737 {
738 listnode_add (list, lsp);
739 ++count;
740 }
741 if (count == num_lsps)
742 break;
743 dnode = next;
744 }
745
746 return;
747 }
748
749 static void
lsp_set_time(struct isis_lsp * lsp)750 lsp_set_time (struct isis_lsp *lsp)
751 {
752 assert (lsp);
753
754 if (lsp->lsp_header->rem_lifetime == 0)
755 {
756 if (lsp->age_out > 0)
757 lsp->age_out--;
758 return;
759 }
760
761 lsp->lsp_header->rem_lifetime =
762 htons (ntohs (lsp->lsp_header->rem_lifetime) - 1);
763 }
764
765 static void
lspid_print(u_char * lsp_id,u_char * trg,char dynhost,char frag)766 lspid_print (u_char * lsp_id, u_char * trg, char dynhost, char frag)
767 {
768 struct isis_dynhn *dyn = NULL;
769 u_char id[SYSID_STRLEN];
770
771 if (dynhost)
772 dyn = dynhn_find_by_id (lsp_id);
773 else
774 dyn = NULL;
775
776 if (dyn)
777 sprintf ((char *)id, "%.14s", dyn->name.name);
778 else if (!memcmp (isis->sysid, lsp_id, ISIS_SYS_ID_LEN) && dynhost)
779 sprintf ((char *)id, "%.14s", unix_hostname ());
780 else
781 memcpy (id, sysid_print (lsp_id), 15);
782 if (frag)
783 sprintf ((char *)trg, "%s.%02x-%02x", id, LSP_PSEUDO_ID (lsp_id),
784 LSP_FRAGMENT (lsp_id));
785 else
786 sprintf ((char *)trg, "%s.%02x", id, LSP_PSEUDO_ID (lsp_id));
787 }
788
789 /* Convert the lsp attribute bits to attribute string */
790 const char *
lsp_bits2string(u_char * lsp_bits)791 lsp_bits2string (u_char * lsp_bits)
792 {
793 char *pos = lsp_bits_string;
794
795 if (!*lsp_bits)
796 return " none";
797
798 /* we only focus on the default metric */
799 pos += sprintf (pos, "%d/",
800 ISIS_MASK_LSP_ATT_DEFAULT_BIT (*lsp_bits) ? 1 : 0);
801
802 pos += sprintf (pos, "%d/",
803 ISIS_MASK_LSP_PARTITION_BIT (*lsp_bits) ? 1 : 0);
804
805 pos += sprintf (pos, "%d", ISIS_MASK_LSP_OL_BIT (*lsp_bits) ? 1 : 0);
806
807 *(pos) = '\0';
808
809 return lsp_bits_string;
810 }
811
812 /* this function prints the lsp on show isis database */
813 void
lsp_print(struct isis_lsp * lsp,struct vty * vty,char dynhost)814 lsp_print (struct isis_lsp *lsp, struct vty *vty, char dynhost)
815 {
816 u_char LSPid[255];
817 char age_out[8];
818
819 lspid_print (lsp->lsp_header->lsp_id, LSPid, dynhost, 1);
820 vty_out (vty, "%-21s%c ", LSPid, lsp->own_lsp ? '*' : ' ');
821 vty_out (vty, "%5u ", ntohs (lsp->lsp_header->pdu_len));
822 vty_out (vty, "0x%08x ", ntohl (lsp->lsp_header->seq_num));
823 vty_out (vty, "0x%04x ", ntohs (lsp->lsp_header->checksum));
824 if (ntohs (lsp->lsp_header->rem_lifetime) == 0)
825 {
826 snprintf (age_out, 8, "(%u)", lsp->age_out);
827 age_out[7] = '\0';
828 vty_out (vty, "%7s ", age_out);
829 }
830 else
831 vty_out (vty, " %5u ", ntohs (lsp->lsp_header->rem_lifetime));
832 vty_out (vty, "%s%s",
833 lsp_bits2string (&lsp->lsp_header->lsp_bits), VTY_NEWLINE);
834 }
835
836 void
lsp_print_detail(struct isis_lsp * lsp,struct vty * vty,char dynhost)837 lsp_print_detail (struct isis_lsp *lsp, struct vty *vty, char dynhost)
838 {
839 struct area_addr *area_addr;
840 int i;
841 struct listnode *lnode;
842 struct is_neigh *is_neigh;
843 struct te_is_neigh *te_is_neigh;
844 struct ipv4_reachability *ipv4_reach;
845 struct in_addr *ipv4_addr;
846 struct te_ipv4_reachability *te_ipv4_reach;
847 #ifdef HAVE_IPV6
848 struct ipv6_reachability *ipv6_reach;
849 struct in6_addr in6;
850 u_char buff[BUFSIZ];
851 #endif
852 u_char LSPid[255];
853 u_char hostname[255];
854 u_char ipv4_reach_prefix[20];
855 u_char ipv4_reach_mask[20];
856 u_char ipv4_address[20];
857
858 lspid_print (lsp->lsp_header->lsp_id, LSPid, dynhost, 1);
859 lsp_print (lsp, vty, dynhost);
860
861 /* for all area address */
862 if (lsp->tlv_data.area_addrs)
863 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.area_addrs, lnode, area_addr))
864 {
865 vty_out (vty, " Area Address: %s%s",
866 isonet_print (area_addr->area_addr, area_addr->addr_len),
867 VTY_NEWLINE);
868 }
869
870 /* for the nlpid tlv */
871 if (lsp->tlv_data.nlpids)
872 {
873 for (i = 0; i < lsp->tlv_data.nlpids->count; i++)
874 {
875 switch (lsp->tlv_data.nlpids->nlpids[i])
876 {
877 case NLPID_IP:
878 case NLPID_IPV6:
879 vty_out (vty, " NLPID : 0x%X%s",
880 lsp->tlv_data.nlpids->nlpids[i], VTY_NEWLINE);
881 break;
882 default:
883 vty_out (vty, " NLPID : %s%s", "unknown", VTY_NEWLINE);
884 break;
885 }
886 }
887 }
888
889 /* for the hostname tlv */
890 if (lsp->tlv_data.hostname)
891 {
892 bzero (hostname, sizeof (hostname));
893 memcpy (hostname, lsp->tlv_data.hostname->name,
894 lsp->tlv_data.hostname->namelen);
895 vty_out (vty, " Hostname : %s%s", hostname, VTY_NEWLINE);
896 }
897
898 /* authentication tlv */
899 if (lsp->tlv_data.auth_info.type != ISIS_PASSWD_TYPE_UNUSED)
900 {
901 if (lsp->tlv_data.auth_info.type == ISIS_PASSWD_TYPE_HMAC_MD5)
902 vty_out (vty, " Auth type : md5%s", VTY_NEWLINE);
903 else if (lsp->tlv_data.auth_info.type == ISIS_PASSWD_TYPE_CLEARTXT)
904 vty_out (vty, " Auth type : clear text%s", VTY_NEWLINE);
905 }
906
907 /* TE router id */
908 if (lsp->tlv_data.router_id)
909 {
910 memcpy (ipv4_address, inet_ntoa (lsp->tlv_data.router_id->id),
911 sizeof (ipv4_address));
912 vty_out (vty, " Router ID : %s%s", ipv4_address, VTY_NEWLINE);
913 }
914
915 if (lsp->tlv_data.ipv4_addrs)
916 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.ipv4_addrs, lnode, ipv4_addr))
917 {
918 memcpy (ipv4_address, inet_ntoa (*ipv4_addr), sizeof (ipv4_address));
919 vty_out (vty, " IPv4 Address: %s%s", ipv4_address, VTY_NEWLINE);
920 }
921
922 /* for the IS neighbor tlv */
923 if (lsp->tlv_data.is_neighs)
924 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.is_neighs, lnode, is_neigh))
925 {
926 lspid_print (is_neigh->neigh_id, LSPid, dynhost, 0);
927 vty_out (vty, " Metric : %-8d IS : %s%s",
928 is_neigh->metrics.metric_default, LSPid, VTY_NEWLINE);
929 }
930
931 /* for the internal reachable tlv */
932 if (lsp->tlv_data.ipv4_int_reachs)
933 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.ipv4_int_reachs, lnode,
934 ipv4_reach))
935 {
936 memcpy (ipv4_reach_prefix, inet_ntoa (ipv4_reach->prefix),
937 sizeof (ipv4_reach_prefix));
938 memcpy (ipv4_reach_mask, inet_ntoa (ipv4_reach->mask),
939 sizeof (ipv4_reach_mask));
940 vty_out (vty, " Metric : %-8d IPv4-Internal : %s %s%s",
941 ipv4_reach->metrics.metric_default, ipv4_reach_prefix,
942 ipv4_reach_mask, VTY_NEWLINE);
943 }
944
945 /* for the external reachable tlv */
946 if (lsp->tlv_data.ipv4_ext_reachs)
947 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.ipv4_ext_reachs, lnode,
948 ipv4_reach))
949 {
950 memcpy (ipv4_reach_prefix, inet_ntoa (ipv4_reach->prefix),
951 sizeof (ipv4_reach_prefix));
952 memcpy (ipv4_reach_mask, inet_ntoa (ipv4_reach->mask),
953 sizeof (ipv4_reach_mask));
954 vty_out (vty, " Metric : %-8d IPv4-External : %s %s%s",
955 ipv4_reach->metrics.metric_default, ipv4_reach_prefix,
956 ipv4_reach_mask, VTY_NEWLINE);
957 }
958
959 /* IPv6 tlv */
960 #ifdef HAVE_IPV6
961 if (lsp->tlv_data.ipv6_reachs)
962 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.ipv6_reachs, lnode, ipv6_reach))
963 {
964 memset (&in6, 0, sizeof (in6));
965 memcpy (in6.s6_addr, ipv6_reach->prefix,
966 PSIZE (ipv6_reach->prefix_len));
967 inet_ntop (AF_INET6, &in6, (char *)buff, BUFSIZ);
968 if ((ipv6_reach->control_info &
969 CTRL_INFO_DISTRIBUTION) == DISTRIBUTION_INTERNAL)
970 vty_out (vty, " Metric : %-8d IPv6-Internal : %s/%d%s",
971 ntohl (ipv6_reach->metric),
972 buff, ipv6_reach->prefix_len, VTY_NEWLINE);
973 else
974 vty_out (vty, " Metric : %-8d IPv6-External : %s/%d%s",
975 ntohl (ipv6_reach->metric),
976 buff, ipv6_reach->prefix_len, VTY_NEWLINE);
977 }
978 #endif
979
980 /* TE IS neighbor tlv */
981 if (lsp->tlv_data.te_is_neighs)
982 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.te_is_neighs, lnode, te_is_neigh))
983 {
984 lspid_print (te_is_neigh->neigh_id, LSPid, dynhost, 0);
985 vty_out (vty, " Metric : %-8d IS-Extended : %s%s",
986 GET_TE_METRIC(te_is_neigh), LSPid, VTY_NEWLINE);
987 if (IS_MPLS_TE(isisMplsTE))
988 mpls_te_print_detail(vty, te_is_neigh);
989 }
990
991 /* TE IPv4 tlv */
992 if (lsp->tlv_data.te_ipv4_reachs)
993 for (ALL_LIST_ELEMENTS_RO (lsp->tlv_data.te_ipv4_reachs, lnode,
994 te_ipv4_reach))
995 {
996 /* FIXME: There should be better way to output this stuff. */
997 vty_out (vty, " Metric : %-8d IPv4-Extended : %s/%d%s",
998 ntohl (te_ipv4_reach->te_metric),
999 inet_ntoa (newprefix2inaddr (&te_ipv4_reach->prefix_start,
1000 te_ipv4_reach->control)),
1001 te_ipv4_reach->control & 0x3F, VTY_NEWLINE);
1002 }
1003 vty_out (vty, "%s", VTY_NEWLINE);
1004
1005 return;
1006 }
1007
1008 /* print all the lsps info in the local lspdb */
1009 int
lsp_print_all(struct vty * vty,dict_t * lspdb,char detail,char dynhost)1010 lsp_print_all (struct vty *vty, dict_t * lspdb, char detail, char dynhost)
1011 {
1012
1013 dnode_t *node = dict_first (lspdb), *next;
1014 int lsp_count = 0;
1015
1016 if (detail == ISIS_UI_LEVEL_BRIEF)
1017 {
1018 while (node != NULL)
1019 {
1020 /* I think it is unnecessary, so I comment it out */
1021 /* dict_contains (lspdb, node); */
1022 next = dict_next (lspdb, node);
1023 lsp_print (dnode_get (node), vty, dynhost);
1024 node = next;
1025 lsp_count++;
1026 }
1027 }
1028 else if (detail == ISIS_UI_LEVEL_DETAIL)
1029 {
1030 while (node != NULL)
1031 {
1032 next = dict_next (lspdb, node);
1033 lsp_print_detail (dnode_get (node), vty, dynhost);
1034 node = next;
1035 lsp_count++;
1036 }
1037 }
1038
1039 return lsp_count;
1040 }
1041
1042 #define FRAG_THOLD(S,T) \
1043 ((STREAM_SIZE(S)*T)/100)
1044
1045 /* stream*, area->lsp_frag_threshold, increment */
1046 #define FRAG_NEEDED(S,T,I) \
1047 (STREAM_SIZE(S)-STREAM_REMAIN(S)+(I) > FRAG_THOLD(S,T))
1048
1049 /* FIXME: It shouldn't be necessary to pass tlvsize here, TLVs can have
1050 * variable length (TE TLVs, sub TLVs). */
1051 static void
lsp_tlv_fit(struct isis_lsp * lsp,struct list ** from,struct list ** to,int tlvsize,int frag_thold,int tlv_build_func (struct list *,struct stream *))1052 lsp_tlv_fit (struct isis_lsp *lsp, struct list **from, struct list **to,
1053 int tlvsize, int frag_thold,
1054 int tlv_build_func (struct list *, struct stream *))
1055 {
1056 int count, i;
1057
1058 /* can we fit all ? */
1059 if (!FRAG_NEEDED (lsp->pdu, frag_thold, listcount (*from) * tlvsize + 2))
1060 {
1061 tlv_build_func (*from, lsp->pdu);
1062 if (listcount (*to) != 0)
1063 {
1064 struct listnode *node, *nextnode;
1065 void *elem;
1066
1067 for (ALL_LIST_ELEMENTS (*from, node, nextnode, elem))
1068 {
1069 listnode_add (*to, elem);
1070 list_delete_node (*from, node);
1071 }
1072 }
1073 else
1074 {
1075 list_free (*to);
1076 *to = *from;
1077 *from = NULL;
1078 }
1079 }
1080 else if (!FRAG_NEEDED (lsp->pdu, frag_thold, tlvsize + 2))
1081 {
1082 /* fit all we can */
1083 count = FRAG_THOLD (lsp->pdu, frag_thold) - 2 -
1084 (STREAM_SIZE (lsp->pdu) - STREAM_REMAIN (lsp->pdu));
1085 count = count / tlvsize;
1086 if (count > (int)listcount (*from))
1087 count = listcount (*from);
1088 for (i = 0; i < count; i++)
1089 {
1090 listnode_add (*to, listgetdata (listhead (*from)));
1091 listnode_delete (*from, listgetdata (listhead (*from)));
1092 }
1093 tlv_build_func (*to, lsp->pdu);
1094 }
1095 lsp->lsp_header->pdu_len = htons (stream_get_endp (lsp->pdu));
1096 return;
1097 }
1098
1099 /* Process IS_NEIGHBOURS TLV with TE subTLVs */
1100 static void
lsp_te_tlv_fit(struct isis_lsp * lsp,struct list ** from,struct list ** to,int frag_thold)1101 lsp_te_tlv_fit (struct isis_lsp *lsp, struct list **from, struct list **to, int frag_thold)
1102 {
1103 int count, size = 0;
1104 struct listnode *node, *nextnode;
1105 struct te_is_neigh *elem;
1106
1107 /* Start computing real size of TLVs */
1108 for (ALL_LIST_ELEMENTS (*from, node, nextnode, elem))
1109 size = size + elem->sub_tlvs_length + IS_NEIGHBOURS_LEN;
1110
1111 /* can we fit all ? */
1112 if (!FRAG_NEEDED (lsp->pdu, frag_thold, size))
1113 {
1114 tlv_add_te_is_neighs (*from, lsp->pdu);
1115 if (listcount (*to) != 0)
1116 {
1117 for (ALL_LIST_ELEMENTS (*from, node, nextnode, elem))
1118 {
1119 listnode_add (*to, elem);
1120 list_delete_node (*from, node);
1121 }
1122 }
1123 else
1124 {
1125 list_free (*to);
1126 *to = *from;
1127 *from = NULL;
1128 }
1129 }
1130 else
1131 {
1132 /* fit all we can */
1133 /* Compute remaining place in LSP PDU */
1134 count = FRAG_THOLD (lsp->pdu, frag_thold) - 2 -
1135 (STREAM_SIZE (lsp->pdu) - STREAM_REMAIN (lsp->pdu));
1136 /* Determine size of TE SubTLVs */
1137 elem = (struct te_is_neigh *)listgetdata ((struct listnode *)listhead (*from));
1138 count = count - elem->sub_tlvs_length - IS_NEIGHBOURS_LEN;
1139 if (count > 0)
1140 {
1141 while (count > 0)
1142 {
1143 listnode_add (*to, listgetdata ((struct listnode *)listhead (*from)));
1144 listnode_delete (*from, listgetdata ((struct listnode *)listhead (*from)));
1145
1146 elem = (struct te_is_neigh *)listgetdata ((struct listnode *)listhead (*from));
1147 count = count - elem->sub_tlvs_length - IS_NEIGHBOURS_LEN;
1148 }
1149
1150 tlv_add_te_is_neighs (*to, lsp->pdu);
1151 }
1152 }
1153 lsp->lsp_header->pdu_len = htons (stream_get_endp (lsp->pdu));
1154 return;
1155 }
1156
1157 static u_int16_t
lsp_rem_lifetime(struct isis_area * area,int level)1158 lsp_rem_lifetime (struct isis_area *area, int level)
1159 {
1160 u_int16_t rem_lifetime;
1161
1162 /* Add jitter to configured LSP lifetime */
1163 rem_lifetime = isis_jitter (area->max_lsp_lifetime[level - 1],
1164 MAX_AGE_JITTER);
1165
1166 /* No jitter if the max refresh will be less than configure gen interval */
1167 /* N.B. this calucation is acceptable since rem_lifetime is in [332,65535] at
1168 * this point */
1169 if (area->lsp_gen_interval[level - 1] > (rem_lifetime - 300))
1170 rem_lifetime = area->max_lsp_lifetime[level - 1];
1171
1172 return rem_lifetime;
1173 }
1174
1175 static u_int16_t
lsp_refresh_time(struct isis_lsp * lsp,u_int16_t rem_lifetime)1176 lsp_refresh_time (struct isis_lsp *lsp, u_int16_t rem_lifetime)
1177 {
1178 struct isis_area *area = lsp->area;
1179 int level = lsp->level;
1180 u_int16_t refresh_time;
1181
1182 /* Add jitter to LSP refresh time */
1183 refresh_time = isis_jitter (area->lsp_refresh[level - 1],
1184 MAX_LSP_GEN_JITTER);
1185
1186 /* RFC 4444 : make sure the refresh time is at least less than 300
1187 * of the remaining lifetime and more than gen interval */
1188 if (refresh_time <= area->lsp_gen_interval[level - 1] ||
1189 refresh_time > (rem_lifetime - 300))
1190 refresh_time = rem_lifetime - 300;
1191
1192 /* In cornercases, refresh_time might be <= lsp_gen_interval, however
1193 * we accept this violation to satisfy refresh_time <= rem_lifetime - 300 */
1194
1195 return refresh_time;
1196 }
1197
1198 static struct isis_lsp *
lsp_next_frag(u_char frag_num,struct isis_lsp * lsp0,struct isis_area * area,int level)1199 lsp_next_frag (u_char frag_num, struct isis_lsp *lsp0, struct isis_area *area,
1200 int level)
1201 {
1202 struct isis_lsp *lsp;
1203 u_char frag_id[ISIS_SYS_ID_LEN + 2];
1204
1205 memcpy (frag_id, lsp0->lsp_header->lsp_id, ISIS_SYS_ID_LEN + 1);
1206 LSP_FRAGMENT (frag_id) = frag_num;
1207 /* FIXME add authentication TLV for fragment LSPs */
1208 lsp = lsp_search (frag_id, area->lspdb[level - 1]);
1209 if (lsp)
1210 {
1211 /* Clear the TLVs */
1212 lsp_clear_data (lsp);
1213 return lsp;
1214 }
1215 lsp = lsp_new (area, frag_id, ntohs(lsp0->lsp_header->rem_lifetime), 0,
1216 lsp_bits_generate (level, area->overload_bit,
1217 area->attached_bit), 0, level);
1218 lsp->area = area;
1219 lsp->own_lsp = 1;
1220 lsp_insert (lsp, area->lspdb[level - 1]);
1221 listnode_add (lsp0->lspu.frags, lsp);
1222 lsp->lspu.zero_lsp = lsp0;
1223 return lsp;
1224 }
1225
1226 static void
lsp_build_ext_reach_ipv4(struct isis_lsp * lsp,struct isis_area * area,struct tlvs * tlv_data)1227 lsp_build_ext_reach_ipv4(struct isis_lsp *lsp, struct isis_area *area,
1228 struct tlvs *tlv_data)
1229 {
1230 struct route_table *er_table;
1231 struct route_node *rn;
1232 struct prefix_ipv4 *ipv4;
1233 struct isis_ext_info *info;
1234 struct ipv4_reachability *ipreach;
1235 struct te_ipv4_reachability *te_ipreach;
1236
1237 er_table = get_ext_reach(area, AF_INET, lsp->level);
1238 if (!er_table)
1239 return;
1240
1241 for (rn = route_top(er_table); rn; rn = route_next(rn))
1242 {
1243 if (!rn->info)
1244 continue;
1245
1246 ipv4 = (struct prefix_ipv4*)&rn->p;
1247 info = rn->info;
1248 if (area->oldmetric)
1249 {
1250 if (tlv_data->ipv4_ext_reachs == NULL)
1251 {
1252 tlv_data->ipv4_ext_reachs = list_new();
1253 tlv_data->ipv4_ext_reachs->del = free_tlv;
1254 }
1255 ipreach = XMALLOC(MTYPE_ISIS_TLV, sizeof(*ipreach));
1256
1257 ipreach->prefix.s_addr = ipv4->prefix.s_addr;
1258 masklen2ip(ipv4->prefixlen, &ipreach->mask);
1259 ipreach->prefix.s_addr &= ipreach->mask.s_addr;
1260
1261 if ((info->metric & 0x3f) != info->metric)
1262 ipreach->metrics.metric_default = 0x3f;
1263 else
1264 ipreach->metrics.metric_default = info->metric;
1265 ipreach->metrics.metric_expense = METRICS_UNSUPPORTED;
1266 ipreach->metrics.metric_error = METRICS_UNSUPPORTED;
1267 ipreach->metrics.metric_delay = METRICS_UNSUPPORTED;
1268 listnode_add(tlv_data->ipv4_ext_reachs, ipreach);
1269 }
1270 if (area->newmetric)
1271 {
1272 if (tlv_data->te_ipv4_reachs == NULL)
1273 {
1274 tlv_data->te_ipv4_reachs = list_new();
1275 tlv_data->te_ipv4_reachs->del = free_tlv;
1276 }
1277 te_ipreach =
1278 XCALLOC(MTYPE_ISIS_TLV,
1279 sizeof(*te_ipreach) - 1 + PSIZE(ipv4->prefixlen));
1280 if (info->metric > MAX_WIDE_PATH_METRIC)
1281 te_ipreach->te_metric = htonl(MAX_WIDE_PATH_METRIC);
1282 else
1283 te_ipreach->te_metric = htonl(info->metric);
1284 te_ipreach->control = ipv4->prefixlen & 0x3f;
1285 memcpy(&te_ipreach->prefix_start, &ipv4->prefix.s_addr,
1286 PSIZE(ipv4->prefixlen));
1287 listnode_add(tlv_data->te_ipv4_reachs, te_ipreach);
1288 }
1289 }
1290 }
1291
1292 static void
lsp_build_ext_reach_ipv6(struct isis_lsp * lsp,struct isis_area * area,struct tlvs * tlv_data)1293 lsp_build_ext_reach_ipv6(struct isis_lsp *lsp, struct isis_area *area,
1294 struct tlvs *tlv_data)
1295 {
1296 struct route_table *er_table;
1297 struct route_node *rn;
1298 struct prefix_ipv6 *ipv6;
1299 struct isis_ext_info *info;
1300 struct ipv6_reachability *ip6reach;
1301
1302 er_table = get_ext_reach(area, AF_INET6, lsp->level);
1303 if (!er_table)
1304 return;
1305
1306 for (rn = route_top(er_table); rn; rn = route_next(rn))
1307 {
1308 if (!rn->info)
1309 continue;
1310
1311 ipv6 = (struct prefix_ipv6*)&rn->p;
1312 info = rn->info;
1313
1314 if (tlv_data->ipv6_reachs == NULL)
1315 {
1316 tlv_data->ipv6_reachs = list_new();
1317 tlv_data->ipv6_reachs->del = free_tlv;
1318 }
1319 ip6reach = XCALLOC(MTYPE_ISIS_TLV, sizeof(*ip6reach));
1320 if (info->metric > MAX_WIDE_PATH_METRIC)
1321 ip6reach->metric = htonl(MAX_WIDE_PATH_METRIC);
1322 else
1323 ip6reach->metric = htonl(info->metric);
1324 ip6reach->control_info = DISTRIBUTION_EXTERNAL;
1325 ip6reach->prefix_len = ipv6->prefixlen;
1326 memcpy(ip6reach->prefix, ipv6->prefix.s6_addr, sizeof(ip6reach->prefix));
1327 listnode_add(tlv_data->ipv6_reachs, ip6reach);
1328 }
1329 }
1330
1331 static void
lsp_build_ext_reach(struct isis_lsp * lsp,struct isis_area * area,struct tlvs * tlv_data)1332 lsp_build_ext_reach (struct isis_lsp *lsp, struct isis_area *area,
1333 struct tlvs *tlv_data)
1334 {
1335 lsp_build_ext_reach_ipv4(lsp, area, tlv_data);
1336 lsp_build_ext_reach_ipv6(lsp, area, tlv_data);
1337 }
1338
1339 /*
1340 * Builds the LSP data part. This func creates a new frag whenever
1341 * area->lsp_frag_threshold is exceeded.
1342 */
1343 static void
lsp_build(struct isis_lsp * lsp,struct isis_area * area)1344 lsp_build (struct isis_lsp *lsp, struct isis_area *area)
1345 {
1346 struct is_neigh *is_neigh;
1347 struct te_is_neigh *te_is_neigh;
1348 struct listnode *node, *ipnode;
1349 int level = lsp->level;
1350 struct isis_circuit *circuit;
1351 struct prefix_ipv4 *ipv4;
1352 struct ipv4_reachability *ipreach;
1353 struct te_ipv4_reachability *te_ipreach;
1354 struct isis_adjacency *nei;
1355 #ifdef HAVE_IPV6
1356 struct prefix_ipv6 *ipv6, ip6prefix;
1357 struct ipv6_reachability *ip6reach;
1358 #endif /* HAVE_IPV6 */
1359 struct tlvs tlv_data;
1360 struct isis_lsp *lsp0 = lsp;
1361 struct in_addr *routerid;
1362 uint32_t expected = 0, found = 0;
1363 uint32_t metric;
1364 u_char zero_id[ISIS_SYS_ID_LEN + 1];
1365 int retval = ISIS_OK;
1366 char buf[BUFSIZ];
1367
1368 lsp_debug("ISIS (%s): Constructing local system LSP for level %d", area->area_tag, level);
1369
1370 /*
1371 * Building the zero lsp
1372 */
1373 memset (zero_id, 0, ISIS_SYS_ID_LEN + 1);
1374
1375 /* Reset stream endp. Stream is always there and on every LSP refresh only
1376 * TLV part of it is overwritten. So we must seek past header we will not
1377 * touch. */
1378 stream_reset (lsp->pdu);
1379 stream_forward_endp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
1380
1381 /*
1382 * Add the authentication info if its present
1383 */
1384 lsp_auth_add (lsp);
1385
1386 /*
1387 * First add the tlvs related to area
1388 */
1389
1390 /* Area addresses */
1391 if (lsp->tlv_data.area_addrs == NULL)
1392 lsp->tlv_data.area_addrs = list_new ();
1393 list_add_list (lsp->tlv_data.area_addrs, area->area_addrs);
1394 if (listcount (lsp->tlv_data.area_addrs) > 0)
1395 tlv_add_area_addrs (lsp->tlv_data.area_addrs, lsp->pdu);
1396
1397 /* Protocols Supported */
1398 if (area->ip_circuits > 0
1399 #ifdef HAVE_IPV6
1400 || area->ipv6_circuits > 0
1401 #endif /* HAVE_IPV6 */
1402 )
1403 {
1404 lsp->tlv_data.nlpids = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct nlpids));
1405 lsp->tlv_data.nlpids->count = 0;
1406 if (area->ip_circuits > 0)
1407 {
1408 lsp_debug("ISIS (%s): Found IPv4 circuit, adding IPv4 to NLPIDs", area->area_tag);
1409 lsp->tlv_data.nlpids->count++;
1410 lsp->tlv_data.nlpids->nlpids[0] = NLPID_IP;
1411 }
1412 #ifdef HAVE_IPV6
1413 if (area->ipv6_circuits > 0)
1414 {
1415 lsp_debug("ISIS (%s): Found IPv6 circuit, adding IPv6 to NLPIDs", area->area_tag);
1416 lsp->tlv_data.nlpids->count++;
1417 lsp->tlv_data.nlpids->nlpids[lsp->tlv_data.nlpids->count - 1] =
1418 NLPID_IPV6;
1419 }
1420 #endif /* HAVE_IPV6 */
1421 tlv_add_nlpid (lsp->tlv_data.nlpids, lsp->pdu);
1422 }
1423
1424 /* Dynamic Hostname */
1425 if (area->dynhostname)
1426 {
1427 const char *hostname = unix_hostname();
1428 size_t hostname_len = strlen(hostname);
1429
1430 lsp->tlv_data.hostname = XMALLOC (MTYPE_ISIS_TLV,
1431 sizeof (struct hostname));
1432
1433 strncpy((char *)lsp->tlv_data.hostname->name, hostname,
1434 sizeof(lsp->tlv_data.hostname->name));
1435 if (hostname_len <= MAX_TLV_LEN)
1436 lsp->tlv_data.hostname->namelen = hostname_len;
1437 else
1438 lsp->tlv_data.hostname->namelen = MAX_TLV_LEN;
1439
1440 lsp_debug("ISIS (%s): Adding dynamic hostname '%.*s'", area->area_tag,
1441 lsp->tlv_data.hostname->namelen, lsp->tlv_data.hostname->name);
1442 tlv_add_dynamic_hostname (lsp->tlv_data.hostname, lsp->pdu);
1443 }
1444 else
1445 {
1446 lsp_debug("ISIS (%s): Not adding dynamic hostname (disabled)", area->area_tag);
1447 }
1448
1449 /* IPv4 address and TE router ID TLVs. In case of the first one we don't
1450 * follow "C" vendor, but "J" vendor behavior - one IPv4 address is put into
1451 * LSP and this address is same as router id. */
1452 if (isis->router_id != 0)
1453 {
1454 inet_ntop(AF_INET, &isis->router_id, buf, sizeof(buf));
1455 lsp_debug("ISIS (%s): Adding router ID %s as IPv4 tlv.", area->area_tag, buf);
1456 if (lsp->tlv_data.ipv4_addrs == NULL)
1457 {
1458 lsp->tlv_data.ipv4_addrs = list_new ();
1459 lsp->tlv_data.ipv4_addrs->del = free_tlv;
1460 }
1461
1462 routerid = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct in_addr));
1463 routerid->s_addr = isis->router_id;
1464 listnode_add (lsp->tlv_data.ipv4_addrs, routerid);
1465 tlv_add_in_addr (routerid, lsp->pdu, IPV4_ADDR);
1466
1467 /* Exactly same data is put into TE router ID TLV, but only if new style
1468 * TLV's are in use. */
1469 if (area->newmetric)
1470 {
1471 lsp_debug("ISIS (%s): Adding router ID also as TE router ID tlv.", area->area_tag);
1472 lsp->tlv_data.router_id = XMALLOC (MTYPE_ISIS_TLV,
1473 sizeof (struct in_addr));
1474 lsp->tlv_data.router_id->id.s_addr = isis->router_id;
1475 tlv_add_in_addr (&lsp->tlv_data.router_id->id, lsp->pdu,
1476 TE_ROUTER_ID);
1477 }
1478 }
1479 else
1480 {
1481 lsp_debug("ISIS (%s): Router ID is unset. Not adding tlv.", area->area_tag);
1482 }
1483
1484 memset (&tlv_data, 0, sizeof (struct tlvs));
1485
1486 #ifdef TOPOLOGY_GENERATE
1487 /* If topology exists (and we create topology for level 1 only), create
1488 * (hardcoded) link to topology. */
1489 if (area->topology && level == IS_LEVEL_1)
1490 {
1491 if (tlv_data.is_neighs == NULL)
1492 {
1493 tlv_data.is_neighs = list_new ();
1494 tlv_data.is_neighs->del = free_tlv;
1495 }
1496 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
1497
1498 memcpy (&is_neigh->neigh_id, area->topology_baseis, ISIS_SYS_ID_LEN);
1499 is_neigh->neigh_id[ISIS_SYS_ID_LEN - 1] = (1 & 0xFF);
1500 is_neigh->neigh_id[ISIS_SYS_ID_LEN - 2] = ((1 >> 8) & 0xFF);
1501 is_neigh->metrics.metric_default = 0x01;
1502 is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
1503 is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
1504 is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
1505 listnode_add (tlv_data.is_neighs, is_neigh);
1506 }
1507 #endif /* TOPOLOGY_GENERATE */
1508
1509 lsp_debug("ISIS (%s): Adding circuit specific information.", area->area_tag);
1510
1511 /*
1512 * Then build lists of tlvs related to circuits
1513 */
1514 for (ALL_LIST_ELEMENTS_RO (area->circuit_list, node, circuit))
1515 {
1516 if (!circuit->interface)
1517 lsp_debug("ISIS (%s): Processing %s circuit %p with unknown interface",
1518 area->area_tag, circuit_type2string(circuit->circ_type), circuit);
1519 else
1520 lsp_debug("ISIS (%s): Processing %s circuit %s",
1521 area->area_tag, circuit_type2string(circuit->circ_type), circuit->interface->name);
1522
1523 if (circuit->state != C_STATE_UP)
1524 {
1525 lsp_debug("ISIS (%s): Circuit is not up, ignoring.", area->area_tag);
1526 continue;
1527 }
1528
1529 /*
1530 * Add IPv4 internal reachability of this circuit
1531 */
1532 if (circuit->ip_router && circuit->ip_addrs &&
1533 circuit->ip_addrs->count > 0)
1534 {
1535 lsp_debug("ISIS (%s): Circuit has IPv4 active, adding respective TLVs.", area->area_tag);
1536 if (area->oldmetric)
1537 {
1538 if (tlv_data.ipv4_int_reachs == NULL)
1539 {
1540 tlv_data.ipv4_int_reachs = list_new ();
1541 tlv_data.ipv4_int_reachs->del = free_tlv;
1542 }
1543 for (ALL_LIST_ELEMENTS_RO (circuit->ip_addrs, ipnode, ipv4))
1544 {
1545 ipreach =
1546 XMALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv4_reachability));
1547 ipreach->metrics.metric_default = circuit->metric[level - 1];
1548 ipreach->metrics.metric_expense = METRICS_UNSUPPORTED;
1549 ipreach->metrics.metric_error = METRICS_UNSUPPORTED;
1550 ipreach->metrics.metric_delay = METRICS_UNSUPPORTED;
1551 masklen2ip (ipv4->prefixlen, &ipreach->mask);
1552 ipreach->prefix.s_addr = ((ipreach->mask.s_addr) &
1553 (ipv4->prefix.s_addr));
1554 inet_ntop(AF_INET, &ipreach->prefix.s_addr, buf, sizeof(buf));
1555 lsp_debug("ISIS (%s): Adding old-style IP reachability for %s/%d",
1556 area->area_tag, buf, ipv4->prefixlen);
1557 listnode_add (tlv_data.ipv4_int_reachs, ipreach);
1558 }
1559 }
1560 if (area->newmetric)
1561 {
1562 if (tlv_data.te_ipv4_reachs == NULL)
1563 {
1564 tlv_data.te_ipv4_reachs = list_new ();
1565 tlv_data.te_ipv4_reachs->del = free_tlv;
1566 }
1567 for (ALL_LIST_ELEMENTS_RO (circuit->ip_addrs, ipnode, ipv4))
1568 {
1569 /* FIXME All this assumes that we have no sub TLVs. */
1570 te_ipreach = XCALLOC (MTYPE_ISIS_TLV,
1571 sizeof (struct te_ipv4_reachability) +
1572 ((ipv4->prefixlen + 7)/8) - 1);
1573
1574 if (area->oldmetric)
1575 te_ipreach->te_metric = htonl (circuit->metric[level - 1]);
1576 else
1577 te_ipreach->te_metric = htonl (circuit->te_metric[level - 1]);
1578
1579 te_ipreach->control = (ipv4->prefixlen & 0x3F);
1580 memcpy (&te_ipreach->prefix_start, &ipv4->prefix.s_addr,
1581 (ipv4->prefixlen + 7)/8);
1582 inet_ntop(AF_INET, &ipv4->prefix.s_addr, buf, sizeof(buf));
1583 lsp_debug("ISIS (%s): Adding te-style IP reachability for %s/%d",
1584 area->area_tag, buf, ipv4->prefixlen);
1585 listnode_add (tlv_data.te_ipv4_reachs, te_ipreach);
1586 }
1587 }
1588 }
1589
1590 #ifdef HAVE_IPV6
1591 /*
1592 * Add IPv6 reachability of this circuit
1593 */
1594 if (circuit->ipv6_router && circuit->ipv6_non_link &&
1595 circuit->ipv6_non_link->count > 0)
1596 {
1597
1598 if (tlv_data.ipv6_reachs == NULL)
1599 {
1600 tlv_data.ipv6_reachs = list_new ();
1601 tlv_data.ipv6_reachs->del = free_tlv;
1602 }
1603 for (ALL_LIST_ELEMENTS_RO (circuit->ipv6_non_link, ipnode, ipv6))
1604 {
1605 ip6reach =
1606 XCALLOC (MTYPE_ISIS_TLV, sizeof (struct ipv6_reachability));
1607
1608 if (area->oldmetric)
1609 ip6reach->metric =
1610 htonl (circuit->metric[level - 1]);
1611 else
1612 ip6reach->metric = htonl (circuit->te_metric[level - 1]);
1613
1614 ip6reach->control_info = 0;
1615 ip6reach->prefix_len = ipv6->prefixlen;
1616 memcpy(&ip6prefix, ipv6, sizeof(ip6prefix));
1617 apply_mask_ipv6(&ip6prefix);
1618
1619 inet_ntop(AF_INET6, &ip6prefix.prefix.s6_addr, buf, sizeof(buf));
1620 lsp_debug("ISIS (%s): Adding IPv6 reachability for %s/%d",
1621 area->area_tag, buf, ipv6->prefixlen);
1622
1623 memcpy (ip6reach->prefix, ip6prefix.prefix.s6_addr,
1624 sizeof (ip6reach->prefix));
1625 listnode_add (tlv_data.ipv6_reachs, ip6reach);
1626 }
1627 }
1628 #endif /* HAVE_IPV6 */
1629
1630 switch (circuit->circ_type)
1631 {
1632 case CIRCUIT_T_BROADCAST:
1633 if (level & circuit->is_type)
1634 {
1635 if (area->oldmetric)
1636 {
1637 if (tlv_data.is_neighs == NULL)
1638 {
1639 tlv_data.is_neighs = list_new ();
1640 tlv_data.is_neighs->del = free_tlv;
1641 }
1642 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
1643 if (level == IS_LEVEL_1)
1644 memcpy (is_neigh->neigh_id,
1645 circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
1646 else
1647 memcpy (is_neigh->neigh_id,
1648 circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
1649 is_neigh->metrics.metric_default = circuit->metric[level - 1];
1650 is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
1651 is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
1652 is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
1653 if (!memcmp (is_neigh->neigh_id, zero_id,
1654 ISIS_SYS_ID_LEN + 1))
1655 {
1656 XFREE (MTYPE_ISIS_TLV, is_neigh);
1657 lsp_debug("ISIS (%s): No DIS for circuit, not adding old-style IS neighbor.",
1658 area->area_tag);
1659 }
1660 else
1661 {
1662 listnode_add (tlv_data.is_neighs, is_neigh);
1663 lsp_debug("ISIS (%s): Adding DIS %s.%02x as old-style neighbor",
1664 area->area_tag, sysid_print(is_neigh->neigh_id),
1665 LSP_PSEUDO_ID(is_neigh->neigh_id));
1666 }
1667 }
1668 if (area->newmetric)
1669 {
1670 if (tlv_data.te_is_neighs == NULL)
1671 {
1672 tlv_data.te_is_neighs = list_new ();
1673 tlv_data.te_is_neighs->del = free_tlv;
1674 }
1675 te_is_neigh = XCALLOC (MTYPE_ISIS_TLV,
1676 sizeof (struct te_is_neigh));
1677 if (level == IS_LEVEL_1)
1678 memcpy (te_is_neigh->neigh_id,
1679 circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
1680 else
1681 memcpy (te_is_neigh->neigh_id,
1682 circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
1683 if (area->oldmetric)
1684 metric = circuit->metric[level - 1];
1685 else
1686 metric = circuit->te_metric[level - 1];
1687 SET_TE_METRIC(te_is_neigh, metric);
1688 if (!memcmp (te_is_neigh->neigh_id, zero_id,
1689 ISIS_SYS_ID_LEN + 1))
1690 {
1691 XFREE (MTYPE_ISIS_TLV, te_is_neigh);
1692 lsp_debug("ISIS (%s): No DIS for circuit, not adding te-style IS neighbor.",
1693 area->area_tag);
1694 }
1695 else
1696 {
1697 /* Check if MPLS_TE is activate */
1698 if (IS_MPLS_TE(isisMplsTE) && HAS_LINK_PARAMS(circuit->interface))
1699 /* Add SubTLVs & Adjust real size of SubTLVs */
1700 te_is_neigh->sub_tlvs_length = add_te_subtlvs(te_is_neigh->sub_tlvs, circuit->mtc);
1701 else
1702 /* Or keep only TE metric with no SubTLVs if MPLS_TE is off */
1703 te_is_neigh->sub_tlvs_length = 0;
1704
1705 listnode_add (tlv_data.te_is_neighs, te_is_neigh);
1706 lsp_debug("ISIS (%s): Adding DIS %s.%02x as te-style neighbor",
1707 area->area_tag, sysid_print(te_is_neigh->neigh_id),
1708 LSP_PSEUDO_ID(te_is_neigh->neigh_id));
1709 }
1710 }
1711 }
1712 else
1713 {
1714 lsp_debug("ISIS (%s): Circuit is not active for current level. Not adding IS neighbors",
1715 area->area_tag);
1716 }
1717 break;
1718 case CIRCUIT_T_P2P:
1719 nei = circuit->u.p2p.neighbor;
1720 if (nei && (level & nei->circuit_t))
1721 {
1722 if (area->oldmetric)
1723 {
1724 if (tlv_data.is_neighs == NULL)
1725 {
1726 tlv_data.is_neighs = list_new ();
1727 tlv_data.is_neighs->del = free_tlv;
1728 }
1729 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
1730 memcpy (is_neigh->neigh_id, nei->sysid, ISIS_SYS_ID_LEN);
1731 is_neigh->metrics.metric_default = circuit->metric[level - 1];
1732 is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
1733 is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
1734 is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
1735 listnode_add (tlv_data.is_neighs, is_neigh);
1736 lsp_debug("ISIS (%s): Adding old-style is reach for %s", area->area_tag,
1737 sysid_print(is_neigh->neigh_id));
1738 }
1739 if (area->newmetric)
1740 {
1741 uint32_t metric;
1742
1743 if (tlv_data.te_is_neighs == NULL)
1744 {
1745 tlv_data.te_is_neighs = list_new ();
1746 tlv_data.te_is_neighs->del = free_tlv;
1747 }
1748 te_is_neigh = XCALLOC (MTYPE_ISIS_TLV,
1749 sizeof (struct te_is_neigh));
1750 memcpy (te_is_neigh->neigh_id, nei->sysid, ISIS_SYS_ID_LEN);
1751 metric = circuit->te_metric[level - 1];
1752 SET_TE_METRIC(te_is_neigh, metric);
1753 /* Check if MPLS_TE is activate */
1754 if (IS_MPLS_TE(isisMplsTE) && HAS_LINK_PARAMS(circuit->interface))
1755 /* Update Local and Remote IP address for MPLS TE circuit parameters */
1756 /* NOTE sure that it is the pertinent place for that updates */
1757 /* Local IP address could be updated in isis_circuit.c - isis_circuit_add_addr() */
1758 /* But, where update remote IP address ? in isis_pdu.c - process_p2p_hello() ? */
1759
1760 /* Add SubTLVs & Adjust real size of SubTLVs */
1761 te_is_neigh->sub_tlvs_length = add_te_subtlvs(te_is_neigh->sub_tlvs, circuit->mtc);
1762 else
1763 /* Or keep only TE metric with no SubTLVs if MPLS_TE is off */
1764 te_is_neigh->sub_tlvs_length = 0;
1765 listnode_add (tlv_data.te_is_neighs, te_is_neigh);
1766 lsp_debug("ISIS (%s): Adding te-style is reach for %s", area->area_tag,
1767 sysid_print(te_is_neigh->neigh_id));
1768 }
1769 }
1770 else
1771 {
1772 lsp_debug("ISIS (%s): No adjacency for given level on this circuit. Not adding IS neighbors",
1773 area->area_tag);
1774 }
1775 break;
1776 case CIRCUIT_T_LOOPBACK:
1777 break;
1778 default:
1779 zlog_warn ("lsp_area_create: unknown circuit type");
1780 }
1781 }
1782
1783 lsp_build_ext_reach(lsp, area, &tlv_data);
1784
1785 lsp_debug("ISIS (%s): LSP construction is complete. Serializing...", area->area_tag);
1786
1787 while (tlv_data.ipv4_int_reachs && listcount (tlv_data.ipv4_int_reachs))
1788 {
1789 if (lsp->tlv_data.ipv4_int_reachs == NULL)
1790 lsp->tlv_data.ipv4_int_reachs = list_new ();
1791 lsp_tlv_fit (lsp, &tlv_data.ipv4_int_reachs,
1792 &lsp->tlv_data.ipv4_int_reachs,
1793 IPV4_REACH_LEN, area->lsp_frag_threshold,
1794 tlv_add_ipv4_int_reachs);
1795 if (tlv_data.ipv4_int_reachs && listcount (tlv_data.ipv4_int_reachs))
1796 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
1797 lsp0, area, level);
1798 }
1799
1800 while (tlv_data.ipv4_ext_reachs && listcount (tlv_data.ipv4_ext_reachs))
1801 {
1802 if (lsp->tlv_data.ipv4_ext_reachs == NULL)
1803 lsp->tlv_data.ipv4_ext_reachs = list_new ();
1804 lsp_tlv_fit (lsp, &tlv_data.ipv4_ext_reachs,
1805 &lsp->tlv_data.ipv4_ext_reachs,
1806 IPV4_REACH_LEN, area->lsp_frag_threshold,
1807 tlv_add_ipv4_ext_reachs);
1808 if (tlv_data.ipv4_ext_reachs && listcount (tlv_data.ipv4_ext_reachs))
1809 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
1810 lsp0, area, level);
1811 }
1812
1813 /* FIXME: We pass maximum te_ipv4_reachability length to the lsp_tlv_fit()
1814 * for now. lsp_tlv_fit() needs to be fixed to deal with variable length
1815 * TLVs (sub TLVs!). */
1816 while (tlv_data.te_ipv4_reachs && listcount (tlv_data.te_ipv4_reachs))
1817 {
1818 if (lsp->tlv_data.te_ipv4_reachs == NULL)
1819 lsp->tlv_data.te_ipv4_reachs = list_new ();
1820 lsp_tlv_fit (lsp, &tlv_data.te_ipv4_reachs,
1821 &lsp->tlv_data.te_ipv4_reachs,
1822 TE_IPV4_REACH_LEN, area->lsp_frag_threshold,
1823 tlv_add_te_ipv4_reachs);
1824 if (tlv_data.te_ipv4_reachs && listcount (tlv_data.te_ipv4_reachs))
1825 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
1826 lsp0, area, level);
1827 }
1828
1829 #ifdef HAVE_IPV6
1830 while (tlv_data.ipv6_reachs && listcount (tlv_data.ipv6_reachs))
1831 {
1832 if (lsp->tlv_data.ipv6_reachs == NULL)
1833 lsp->tlv_data.ipv6_reachs = list_new ();
1834 lsp_tlv_fit (lsp, &tlv_data.ipv6_reachs,
1835 &lsp->tlv_data.ipv6_reachs,
1836 IPV6_REACH_LEN, area->lsp_frag_threshold,
1837 tlv_add_ipv6_reachs);
1838 if (tlv_data.ipv6_reachs && listcount (tlv_data.ipv6_reachs))
1839 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
1840 lsp0, area, level);
1841 }
1842 #endif /* HAVE_IPV6 */
1843
1844 while (tlv_data.is_neighs && listcount (tlv_data.is_neighs))
1845 {
1846 if (lsp->tlv_data.is_neighs == NULL)
1847 lsp->tlv_data.is_neighs = list_new ();
1848 lsp_tlv_fit (lsp, &tlv_data.is_neighs,
1849 &lsp->tlv_data.is_neighs,
1850 IS_NEIGHBOURS_LEN, area->lsp_frag_threshold,
1851 tlv_add_is_neighs);
1852 if (tlv_data.is_neighs && listcount (tlv_data.is_neighs))
1853 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
1854 lsp0, area, level);
1855 }
1856
1857 while (tlv_data.te_is_neighs && listcount (tlv_data.te_is_neighs))
1858 {
1859 if (lsp->tlv_data.te_is_neighs == NULL)
1860 lsp->tlv_data.te_is_neighs = list_new ();
1861 lsp_tlv_fit (lsp, &tlv_data.te_is_neighs, &lsp->tlv_data.te_is_neighs,
1862 IS_NEIGHBOURS_LEN, area->lsp_frag_threshold,
1863 tlv_add_te_is_neighs);
1864 if (tlv_data.te_is_neighs && listcount (tlv_data.te_is_neighs))
1865 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
1866 lsp0, area, level);
1867 }
1868 lsp->lsp_header->pdu_len = htons (stream_get_endp (lsp->pdu));
1869
1870 free_tlvs (&tlv_data);
1871
1872 /* Validate the LSP */
1873 retval = parse_tlvs (area->area_tag, STREAM_DATA (lsp->pdu) +
1874 ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN,
1875 stream_get_endp (lsp->pdu) -
1876 ISIS_FIXED_HDR_LEN - ISIS_LSP_HDR_LEN,
1877 &expected, &found, &tlv_data, NULL);
1878 assert (retval == ISIS_OK);
1879
1880 return;
1881 }
1882
1883 /*
1884 * 7.3.7 and 7.3.9 Generation on non-pseudonode LSPs
1885 */
1886 int
lsp_generate(struct isis_area * area,int level)1887 lsp_generate (struct isis_area *area, int level)
1888 {
1889 struct isis_lsp *oldlsp, *newlsp;
1890 u_int32_t seq_num = 0;
1891 u_char lspid[ISIS_SYS_ID_LEN + 2];
1892 u_int16_t rem_lifetime, refresh_time;
1893
1894 if ((area == NULL) || (area->is_type & level) != level)
1895 return ISIS_ERROR;
1896
1897 memset (&lspid, 0, ISIS_SYS_ID_LEN + 2);
1898 memcpy (&lspid, isis->sysid, ISIS_SYS_ID_LEN);
1899
1900 /* only builds the lsp if the area shares the level */
1901 oldlsp = lsp_search (lspid, area->lspdb[level - 1]);
1902 if (oldlsp)
1903 {
1904 /* FIXME: we should actually initiate a purge */
1905 seq_num = ntohl (oldlsp->lsp_header->seq_num);
1906 lsp_search_and_destroy (oldlsp->lsp_header->lsp_id,
1907 area->lspdb[level - 1]);
1908 }
1909 rem_lifetime = lsp_rem_lifetime (area, level);
1910 newlsp = lsp_new (area, lspid, rem_lifetime, seq_num,
1911 area->is_type | area->overload_bit | area->attached_bit,
1912 0, level);
1913 newlsp->area = area;
1914 newlsp->own_lsp = 1;
1915
1916 lsp_insert (newlsp, area->lspdb[level - 1]);
1917 /* build_lsp_data (newlsp, area); */
1918 lsp_build (newlsp, area);
1919 /* time to calculate our checksum */
1920 lsp_seqnum_update (newlsp);
1921 newlsp->last_generated = time(NULL);
1922 lsp_set_all_srmflags (newlsp);
1923
1924 refresh_time = lsp_refresh_time (newlsp, rem_lifetime);
1925
1926 THREAD_TIMER_OFF (area->t_lsp_refresh[level - 1]);
1927 area->lsp_regenerate_pending[level - 1] = 0;
1928 if (level == IS_LEVEL_1)
1929 THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
1930 lsp_l1_refresh, area, refresh_time);
1931 else if (level == IS_LEVEL_2)
1932 THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
1933 lsp_l2_refresh, area, refresh_time);
1934
1935 if (isis->debugs & DEBUG_UPDATE_PACKETS)
1936 {
1937 zlog_debug ("ISIS-Upd (%s): Building L%d LSP %s, len %d, "
1938 "seq 0x%08x, cksum 0x%04x, lifetime %us refresh %us",
1939 area->area_tag, level,
1940 rawlspid_print (newlsp->lsp_header->lsp_id),
1941 ntohl (newlsp->lsp_header->pdu_len),
1942 ntohl (newlsp->lsp_header->seq_num),
1943 ntohs (newlsp->lsp_header->checksum),
1944 ntohs (newlsp->lsp_header->rem_lifetime),
1945 refresh_time);
1946 }
1947 sched_debug("ISIS (%s): Built L%d LSP. Set triggered regenerate to non-pending.",
1948 area->area_tag, level);
1949
1950 return ISIS_OK;
1951 }
1952
1953 /*
1954 * Search own LSPs, update holding time and set SRM
1955 */
1956 static int
lsp_regenerate(struct isis_area * area,int level)1957 lsp_regenerate (struct isis_area *area, int level)
1958 {
1959 dict_t *lspdb;
1960 struct isis_lsp *lsp, *frag;
1961 struct listnode *node;
1962 u_char lspid[ISIS_SYS_ID_LEN + 2];
1963 u_int16_t rem_lifetime, refresh_time;
1964
1965 if ((area == NULL) || (area->is_type & level) != level)
1966 return ISIS_ERROR;
1967
1968 lspdb = area->lspdb[level - 1];
1969
1970 memset (lspid, 0, ISIS_SYS_ID_LEN + 2);
1971 memcpy (lspid, isis->sysid, ISIS_SYS_ID_LEN);
1972
1973 lsp = lsp_search (lspid, lspdb);
1974
1975 if (!lsp)
1976 {
1977 zlog_err ("ISIS-Upd (%s): lsp_regenerate: no L%d LSP found!",
1978 area->area_tag, level);
1979 return ISIS_ERROR;
1980 }
1981
1982 lsp_clear_data (lsp);
1983 lsp_build (lsp, area);
1984 lsp->lsp_header->lsp_bits = lsp_bits_generate (level, area->overload_bit,
1985 area->attached_bit);
1986 rem_lifetime = lsp_rem_lifetime (area, level);
1987 lsp->lsp_header->rem_lifetime = htons (rem_lifetime);
1988 lsp_seqnum_update (lsp);
1989
1990 lsp->last_generated = time (NULL);
1991 lsp_set_all_srmflags (lsp);
1992 for (ALL_LIST_ELEMENTS_RO (lsp->lspu.frags, node, frag))
1993 {
1994 frag->lsp_header->lsp_bits = lsp_bits_generate (level,
1995 area->overload_bit,
1996 area->attached_bit);
1997 /* Set the lifetime values of all the fragments to the same value,
1998 * so that no fragment expires before the lsp is refreshed.
1999 */
2000 frag->lsp_header->rem_lifetime = htons (rem_lifetime);
2001 lsp_set_all_srmflags (frag);
2002 }
2003
2004 refresh_time = lsp_refresh_time (lsp, rem_lifetime);
2005 if (level == IS_LEVEL_1)
2006 THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
2007 lsp_l1_refresh, area, refresh_time);
2008 else if (level == IS_LEVEL_2)
2009 THREAD_TIMER_ON (master, area->t_lsp_refresh[level - 1],
2010 lsp_l2_refresh, area, refresh_time);
2011 area->lsp_regenerate_pending[level - 1] = 0;
2012
2013 if (isis->debugs & DEBUG_UPDATE_PACKETS)
2014 {
2015 zlog_debug ("ISIS-Upd (%s): Refreshing our L%d LSP %s, len %d, "
2016 "seq 0x%08x, cksum 0x%04x, lifetime %us refresh %us",
2017 area->area_tag, level,
2018 rawlspid_print (lsp->lsp_header->lsp_id),
2019 ntohl (lsp->lsp_header->pdu_len),
2020 ntohl (lsp->lsp_header->seq_num),
2021 ntohs (lsp->lsp_header->checksum),
2022 ntohs (lsp->lsp_header->rem_lifetime),
2023 refresh_time);
2024 }
2025 sched_debug("ISIS (%s): Rebuilt L%d LSP. Set triggered regenerate to non-pending.",
2026 area->area_tag, level);
2027
2028 return ISIS_OK;
2029 }
2030
2031 /*
2032 * Something has changed or periodic refresh -> regenerate LSP
2033 */
2034 static int
lsp_l1_refresh(struct thread * thread)2035 lsp_l1_refresh (struct thread *thread)
2036 {
2037 struct isis_area *area;
2038
2039 area = THREAD_ARG (thread);
2040 assert (area);
2041
2042 area->t_lsp_refresh[0] = NULL;
2043 area->lsp_regenerate_pending[0] = 0;
2044
2045 if ((area->is_type & IS_LEVEL_1) == 0)
2046 return ISIS_ERROR;
2047
2048 sched_debug("ISIS (%s): LSP L1 refresh timer expired. Refreshing LSP...", area->area_tag);
2049 return lsp_regenerate (area, IS_LEVEL_1);
2050 }
2051
2052 static int
lsp_l2_refresh(struct thread * thread)2053 lsp_l2_refresh (struct thread *thread)
2054 {
2055 struct isis_area *area;
2056
2057 area = THREAD_ARG (thread);
2058 assert (area);
2059
2060 area->t_lsp_refresh[1] = NULL;
2061 area->lsp_regenerate_pending[1] = 0;
2062
2063 if ((area->is_type & IS_LEVEL_2) == 0)
2064 return ISIS_ERROR;
2065
2066 sched_debug("ISIS (%s): LSP L2 refresh timer expired. Refreshing LSP...", area->area_tag);
2067 return lsp_regenerate (area, IS_LEVEL_2);
2068 }
2069
2070 int
lsp_regenerate_schedule(struct isis_area * area,int level,int all_pseudo)2071 lsp_regenerate_schedule (struct isis_area *area, int level, int all_pseudo)
2072 {
2073 struct isis_lsp *lsp;
2074 u_char id[ISIS_SYS_ID_LEN + 2];
2075 time_t now, diff;
2076 long timeout;
2077 struct listnode *cnode;
2078 struct isis_circuit *circuit;
2079 int lvl;
2080
2081 if (area == NULL)
2082 return ISIS_ERROR;
2083
2084 sched_debug("ISIS (%s): Scheduling regeneration of %s LSPs, %sincluding PSNs",
2085 area->area_tag, circuit_t2string(level), all_pseudo ? "" : "not ");
2086
2087 memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
2088 LSP_PSEUDO_ID (id) = LSP_FRAGMENT (id) = 0;
2089 now = time (NULL);
2090
2091 for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; lvl++)
2092 {
2093 if (!((level & lvl) && (area->is_type & lvl)))
2094 continue;
2095
2096 sched_debug("ISIS (%s): Checking whether L%d needs to be scheduled",
2097 area->area_tag, lvl);
2098
2099 if (area->lsp_regenerate_pending[lvl - 1])
2100 {
2101 struct timeval remain = thread_timer_remain(area->t_lsp_refresh[lvl - 1]);
2102 sched_debug("ISIS (%s): Regeneration is already pending, nothing todo."
2103 " (Due in %lld.%03lld seconds)", area->area_tag,
2104 (long long)remain.tv_sec, (long long)remain.tv_usec / 1000);
2105 continue;
2106 }
2107
2108 lsp = lsp_search (id, area->lspdb[lvl - 1]);
2109 if (!lsp)
2110 {
2111 sched_debug("ISIS (%s): We do not have any LSPs to regenerate, nothing todo.",
2112 area->area_tag);
2113 continue;
2114 }
2115
2116 /*
2117 * Throttle avoidance
2118 */
2119 sched_debug("ISIS (%s): Will schedule regen timer. Last run was: %lld, Now is: %lld",
2120 area->area_tag, (long long)lsp->last_generated, (long long)now);
2121 THREAD_TIMER_OFF (area->t_lsp_refresh[lvl - 1]);
2122 diff = now - lsp->last_generated;
2123 if (diff < area->lsp_gen_interval[lvl - 1])
2124 {
2125 timeout = 1000 * (area->lsp_gen_interval[lvl - 1] - diff);
2126 sched_debug("ISIS (%s): Scheduling in %ld ms to match configured lsp_gen_interval",
2127 area->area_tag, timeout);
2128 }
2129 else
2130 {
2131 /*
2132 * lsps are not regenerated if lsp_regenerate function is called
2133 * directly. However if the lsp_regenerate call is queued for
2134 * later execution it works.
2135 */
2136 timeout = 100;
2137 sched_debug("ISIS (%s): Last generation was more than lsp_gen_interval ago."
2138 " Scheduling for execution in %ld ms.", area->area_tag, timeout);
2139 }
2140
2141 area->lsp_regenerate_pending[lvl - 1] = 1;
2142 if (lvl == IS_LEVEL_1)
2143 {
2144 THREAD_TIMER_MSEC_ON(master, area->t_lsp_refresh[lvl - 1],
2145 lsp_l1_refresh, area, timeout);
2146 }
2147 else if (lvl == IS_LEVEL_2)
2148 {
2149 THREAD_TIMER_MSEC_ON(master, area->t_lsp_refresh[lvl - 1],
2150 lsp_l2_refresh, area, timeout);
2151 }
2152 }
2153
2154 if (all_pseudo)
2155 {
2156 for (ALL_LIST_ELEMENTS_RO (area->circuit_list, cnode, circuit))
2157 lsp_regenerate_schedule_pseudo (circuit, level);
2158 }
2159
2160 return ISIS_OK;
2161 }
2162
2163 /*
2164 * Funcs for pseudonode LSPs
2165 */
2166
2167 /*
2168 * 7.3.8 and 7.3.10 Generation of level 1 and 2 pseudonode LSPs
2169 */
2170 static void
lsp_build_pseudo(struct isis_lsp * lsp,struct isis_circuit * circuit,int level)2171 lsp_build_pseudo (struct isis_lsp *lsp, struct isis_circuit *circuit,
2172 int level)
2173 {
2174 struct isis_adjacency *adj;
2175 struct is_neigh *is_neigh;
2176 struct te_is_neigh *te_is_neigh;
2177 struct es_neigh *es_neigh;
2178 struct list *adj_list;
2179 struct listnode *node;
2180 struct isis_area *area = circuit->area;
2181
2182 lsp_debug("ISIS (%s): Constructing pseudo LSP %s for interface %s level %d",
2183 area->area_tag, rawlspid_print(lsp->lsp_header->lsp_id),
2184 circuit->interface->name, level);
2185
2186 lsp->level = level;
2187 /* RFC3787 section 4 SHOULD not set overload bit in pseudo LSPs */
2188 lsp->lsp_header->lsp_bits = lsp_bits_generate (level, 0,
2189 circuit->area->attached_bit);
2190
2191 /*
2192 * add self to IS neighbours
2193 */
2194 if (circuit->area->oldmetric)
2195 {
2196 if (lsp->tlv_data.is_neighs == NULL)
2197 {
2198 lsp->tlv_data.is_neighs = list_new ();
2199 lsp->tlv_data.is_neighs->del = free_tlv;
2200 }
2201 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
2202
2203 memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN);
2204 listnode_add (lsp->tlv_data.is_neighs, is_neigh);
2205 lsp_debug("ISIS (%s): Adding %s.%02x as old-style neighbor (self)",
2206 area->area_tag, sysid_print(is_neigh->neigh_id),
2207 LSP_PSEUDO_ID(is_neigh->neigh_id));
2208 }
2209 if (circuit->area->newmetric)
2210 {
2211 if (lsp->tlv_data.te_is_neighs == NULL)
2212 {
2213 lsp->tlv_data.te_is_neighs = list_new ();
2214 lsp->tlv_data.te_is_neighs->del = free_tlv;
2215 }
2216 te_is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct te_is_neigh));
2217
2218 memcpy (&te_is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN);
2219 listnode_add (lsp->tlv_data.te_is_neighs, te_is_neigh);
2220 lsp_debug("ISIS (%s): Adding %s.%02x as te-style neighbor (self)",
2221 area->area_tag, sysid_print(te_is_neigh->neigh_id),
2222 LSP_PSEUDO_ID(te_is_neigh->neigh_id));
2223 }
2224
2225 adj_list = list_new ();
2226 isis_adj_build_up_list (circuit->u.bc.adjdb[level - 1], adj_list);
2227
2228 for (ALL_LIST_ELEMENTS_RO (adj_list, node, adj))
2229 {
2230 if (adj->level & level)
2231 {
2232 if ((level == IS_LEVEL_1 && adj->sys_type == ISIS_SYSTYPE_L1_IS) ||
2233 (level == IS_LEVEL_1 && adj->sys_type == ISIS_SYSTYPE_L2_IS &&
2234 adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
2235 (level == IS_LEVEL_2 && adj->sys_type == ISIS_SYSTYPE_L2_IS))
2236 {
2237 /* an IS neighbour -> add it */
2238 if (circuit->area->oldmetric)
2239 {
2240 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
2241
2242 memcpy (&is_neigh->neigh_id, adj->sysid, ISIS_SYS_ID_LEN);
2243 listnode_add (lsp->tlv_data.is_neighs, is_neigh);
2244 lsp_debug("ISIS (%s): Adding %s.%02x as old-style neighbor (peer)",
2245 area->area_tag, sysid_print(is_neigh->neigh_id),
2246 LSP_PSEUDO_ID(is_neigh->neigh_id));
2247 }
2248 if (circuit->area->newmetric)
2249 {
2250 te_is_neigh = XCALLOC (MTYPE_ISIS_TLV,
2251 sizeof (struct te_is_neigh));
2252 memcpy (&te_is_neigh->neigh_id, adj->sysid, ISIS_SYS_ID_LEN);
2253 listnode_add (lsp->tlv_data.te_is_neighs, te_is_neigh);
2254 lsp_debug("ISIS (%s): Adding %s.%02x as te-style neighbor (peer)",
2255 area->area_tag, sysid_print(te_is_neigh->neigh_id),
2256 LSP_PSEUDO_ID(te_is_neigh->neigh_id));
2257 }
2258 }
2259 else if (level == IS_LEVEL_1 && adj->sys_type == ISIS_SYSTYPE_ES)
2260 {
2261 /* an ES neigbour add it, if we are building level 1 LSP */
2262 /* FIXME: the tlv-format is hard to use here */
2263 if (lsp->tlv_data.es_neighs == NULL)
2264 {
2265 lsp->tlv_data.es_neighs = list_new ();
2266 lsp->tlv_data.es_neighs->del = free_tlv;
2267 }
2268 es_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct es_neigh));
2269
2270 memcpy (&es_neigh->first_es_neigh, adj->sysid, ISIS_SYS_ID_LEN);
2271 listnode_add (lsp->tlv_data.es_neighs, es_neigh);
2272 lsp_debug("ISIS (%s): Adding %s as ES neighbor (peer)",
2273 area->area_tag, sysid_print(es_neigh->first_es_neigh));
2274 }
2275 else
2276 {
2277 lsp_debug("ISIS (%s): Ignoring neighbor %s, level does not match",
2278 area->area_tag, sysid_print(adj->sysid));
2279 }
2280 }
2281 else
2282 {
2283 lsp_debug("ISIS (%s): Ignoring neighbor %s, level does not intersect",
2284 area->area_tag, sysid_print(adj->sysid));
2285 }
2286 }
2287 list_delete (adj_list);
2288
2289 lsp_debug("ISIS (%s): Pseudo LSP construction is complete.", area->area_tag);
2290
2291 /* Reset endp of stream to overwrite only TLV part of it. */
2292 stream_reset (lsp->pdu);
2293 stream_forward_endp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
2294
2295 /*
2296 * Add the authentication info if it's present
2297 */
2298 lsp_auth_add (lsp);
2299
2300 if (lsp->tlv_data.is_neighs && listcount (lsp->tlv_data.is_neighs) > 0)
2301 tlv_add_is_neighs (lsp->tlv_data.is_neighs, lsp->pdu);
2302
2303 if (lsp->tlv_data.te_is_neighs && listcount (lsp->tlv_data.te_is_neighs) > 0)
2304 tlv_add_te_is_neighs (lsp->tlv_data.te_is_neighs, lsp->pdu);
2305
2306 if (lsp->tlv_data.es_neighs && listcount (lsp->tlv_data.es_neighs) > 0)
2307 tlv_add_is_neighs (lsp->tlv_data.es_neighs, lsp->pdu);
2308
2309 lsp->lsp_header->pdu_len = htons (stream_get_endp (lsp->pdu));
2310
2311 /* Recompute authentication and checksum information */
2312 lsp_auth_update (lsp);
2313 fletcher_checksum(STREAM_DATA (lsp->pdu) + 12,
2314 ntohs (lsp->lsp_header->pdu_len) - 12, 12);
2315
2316 return;
2317 }
2318
2319 int
lsp_generate_pseudo(struct isis_circuit * circuit,int level)2320 lsp_generate_pseudo (struct isis_circuit *circuit, int level)
2321 {
2322 dict_t *lspdb = circuit->area->lspdb[level - 1];
2323 struct isis_lsp *lsp;
2324 u_char lsp_id[ISIS_SYS_ID_LEN + 2];
2325 u_int16_t rem_lifetime, refresh_time;
2326
2327 if ((circuit->is_type & level) != level ||
2328 (circuit->state != C_STATE_UP) ||
2329 (circuit->circ_type != CIRCUIT_T_BROADCAST) ||
2330 (circuit->u.bc.is_dr[level - 1] == 0))
2331 return ISIS_ERROR;
2332
2333 memcpy (lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
2334 LSP_FRAGMENT (lsp_id) = 0;
2335 LSP_PSEUDO_ID (lsp_id) = circuit->circuit_id;
2336
2337 /*
2338 * If for some reason have a pseudo LSP in the db already -> regenerate
2339 */
2340 if (lsp_search (lsp_id, lspdb))
2341 return lsp_regenerate_schedule_pseudo (circuit, level);
2342
2343 rem_lifetime = lsp_rem_lifetime (circuit->area, level);
2344 /* RFC3787 section 4 SHOULD not set overload bit in pseudo LSPs */
2345 lsp = lsp_new (circuit->area, lsp_id, rem_lifetime, 1,
2346 circuit->area->is_type | circuit->area->attached_bit,
2347 0, level);
2348 lsp->area = circuit->area;
2349
2350 lsp_build_pseudo (lsp, circuit, level);
2351
2352 lsp->own_lsp = 1;
2353 lsp_insert (lsp, lspdb);
2354 lsp_set_all_srmflags (lsp);
2355
2356 refresh_time = lsp_refresh_time (lsp, rem_lifetime);
2357 THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
2358 circuit->lsp_regenerate_pending[level - 1] = 0;
2359 if (level == IS_LEVEL_1)
2360 THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
2361 lsp_l1_refresh_pseudo, circuit, refresh_time);
2362 else if (level == IS_LEVEL_2)
2363 THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
2364 lsp_l2_refresh_pseudo, circuit, refresh_time);
2365
2366 if (isis->debugs & DEBUG_UPDATE_PACKETS)
2367 {
2368 zlog_debug ("ISIS-Upd (%s): Building L%d Pseudo LSP %s, len %d, "
2369 "seq 0x%08x, cksum 0x%04x, lifetime %us, refresh %us",
2370 circuit->area->area_tag, level,
2371 rawlspid_print (lsp->lsp_header->lsp_id),
2372 ntohl (lsp->lsp_header->pdu_len),
2373 ntohl (lsp->lsp_header->seq_num),
2374 ntohs (lsp->lsp_header->checksum),
2375 ntohs (lsp->lsp_header->rem_lifetime),
2376 refresh_time);
2377 }
2378
2379 return ISIS_OK;
2380 }
2381
2382 static int
lsp_regenerate_pseudo(struct isis_circuit * circuit,int level)2383 lsp_regenerate_pseudo (struct isis_circuit *circuit, int level)
2384 {
2385 dict_t *lspdb = circuit->area->lspdb[level - 1];
2386 struct isis_lsp *lsp;
2387 u_char lsp_id[ISIS_SYS_ID_LEN + 2];
2388 u_int16_t rem_lifetime, refresh_time;
2389
2390 if ((circuit->is_type & level) != level ||
2391 (circuit->state != C_STATE_UP) ||
2392 (circuit->circ_type != CIRCUIT_T_BROADCAST) ||
2393 (circuit->u.bc.is_dr[level - 1] == 0))
2394 return ISIS_ERROR;
2395
2396 memcpy (lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
2397 LSP_PSEUDO_ID (lsp_id) = circuit->circuit_id;
2398 LSP_FRAGMENT (lsp_id) = 0;
2399
2400 lsp = lsp_search (lsp_id, lspdb);
2401
2402 if (!lsp)
2403 {
2404 zlog_err ("lsp_regenerate_pseudo: no l%d LSP %s found!",
2405 level, rawlspid_print (lsp_id));
2406 return ISIS_ERROR;
2407 }
2408 lsp_clear_data (lsp);
2409
2410 lsp_build_pseudo (lsp, circuit, level);
2411
2412 /* RFC3787 section 4 SHOULD not set overload bit in pseudo LSPs */
2413 lsp->lsp_header->lsp_bits = lsp_bits_generate (level, 0,
2414 circuit->area->attached_bit);
2415 rem_lifetime = lsp_rem_lifetime (circuit->area, level);
2416 lsp->lsp_header->rem_lifetime = htons (rem_lifetime);
2417 lsp_inc_seqnum (lsp, 0);
2418 lsp->last_generated = time (NULL);
2419 lsp_set_all_srmflags (lsp);
2420
2421 refresh_time = lsp_refresh_time (lsp, rem_lifetime);
2422 if (level == IS_LEVEL_1)
2423 THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
2424 lsp_l1_refresh_pseudo, circuit, refresh_time);
2425 else if (level == IS_LEVEL_2)
2426 THREAD_TIMER_ON (master, circuit->u.bc.t_refresh_pseudo_lsp[level - 1],
2427 lsp_l2_refresh_pseudo, circuit, refresh_time);
2428
2429 if (isis->debugs & DEBUG_UPDATE_PACKETS)
2430 {
2431 zlog_debug ("ISIS-Upd (%s): Refreshing L%d Pseudo LSP %s, len %d, "
2432 "seq 0x%08x, cksum 0x%04x, lifetime %us, refresh %us",
2433 circuit->area->area_tag, level,
2434 rawlspid_print (lsp->lsp_header->lsp_id),
2435 ntohl (lsp->lsp_header->pdu_len),
2436 ntohl (lsp->lsp_header->seq_num),
2437 ntohs (lsp->lsp_header->checksum),
2438 ntohs (lsp->lsp_header->rem_lifetime),
2439 refresh_time);
2440 }
2441
2442 return ISIS_OK;
2443 }
2444
2445 /*
2446 * Something has changed or periodic refresh -> regenerate pseudo LSP
2447 */
2448 static int
lsp_l1_refresh_pseudo(struct thread * thread)2449 lsp_l1_refresh_pseudo (struct thread *thread)
2450 {
2451 struct isis_circuit *circuit;
2452 u_char id[ISIS_SYS_ID_LEN + 2];
2453
2454 circuit = THREAD_ARG (thread);
2455
2456 circuit->u.bc.t_refresh_pseudo_lsp[0] = NULL;
2457 circuit->lsp_regenerate_pending[0] = 0;
2458
2459 if ((circuit->u.bc.is_dr[0] == 0) ||
2460 (circuit->is_type & IS_LEVEL_1) == 0)
2461 {
2462 memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
2463 LSP_PSEUDO_ID (id) = circuit->circuit_id;
2464 LSP_FRAGMENT (id) = 0;
2465 lsp_purge_pseudo (id, circuit, IS_LEVEL_1);
2466 return ISIS_ERROR;
2467 }
2468
2469 return lsp_regenerate_pseudo (circuit, IS_LEVEL_1);
2470 }
2471
2472 static int
lsp_l2_refresh_pseudo(struct thread * thread)2473 lsp_l2_refresh_pseudo (struct thread *thread)
2474 {
2475 struct isis_circuit *circuit;
2476 u_char id[ISIS_SYS_ID_LEN + 2];
2477
2478 circuit = THREAD_ARG (thread);
2479
2480 circuit->u.bc.t_refresh_pseudo_lsp[1] = NULL;
2481 circuit->lsp_regenerate_pending[1] = 0;
2482
2483 if ((circuit->u.bc.is_dr[1] == 0) ||
2484 (circuit->is_type & IS_LEVEL_2) == 0)
2485 {
2486 memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
2487 LSP_PSEUDO_ID (id) = circuit->circuit_id;
2488 LSP_FRAGMENT (id) = 0;
2489 lsp_purge_pseudo (id, circuit, IS_LEVEL_2);
2490 return ISIS_ERROR;
2491 }
2492
2493 return lsp_regenerate_pseudo (circuit, IS_LEVEL_2);
2494 }
2495
2496 int
lsp_regenerate_schedule_pseudo(struct isis_circuit * circuit,int level)2497 lsp_regenerate_schedule_pseudo (struct isis_circuit *circuit, int level)
2498 {
2499 struct isis_lsp *lsp;
2500 u_char lsp_id[ISIS_SYS_ID_LEN + 2];
2501 time_t now, diff;
2502 long timeout;
2503 int lvl;
2504 struct isis_area *area = circuit->area;
2505
2506 if (circuit == NULL ||
2507 circuit->circ_type != CIRCUIT_T_BROADCAST ||
2508 circuit->state != C_STATE_UP)
2509 return ISIS_OK;
2510
2511 sched_debug("ISIS (%s): Scheduling regeneration of %s pseudo LSP for interface %s",
2512 area->area_tag, circuit_t2string(level), circuit->interface->name);
2513
2514 memcpy (lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
2515 LSP_PSEUDO_ID (lsp_id) = circuit->circuit_id;
2516 LSP_FRAGMENT (lsp_id) = 0;
2517 now = time (NULL);
2518
2519 for (lvl = IS_LEVEL_1; lvl <= IS_LEVEL_2; lvl++)
2520 {
2521 sched_debug("ISIS (%s): Checking whether L%d pseudo LSP needs to be scheduled",
2522 area->area_tag, lvl);
2523
2524 if (!((level & lvl) && (circuit->is_type & lvl)))
2525 {
2526 sched_debug("ISIS (%s): Level is not active on circuit",
2527 area->area_tag);
2528 continue;
2529 }
2530
2531 if (circuit->u.bc.is_dr[lvl - 1] == 0)
2532 {
2533 sched_debug("ISIS (%s): This IS is not DR, nothing to do.",
2534 area->area_tag);
2535 continue;
2536 }
2537
2538 if (circuit->lsp_regenerate_pending[lvl - 1])
2539 {
2540 struct timeval remain =
2541 thread_timer_remain(circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
2542 sched_debug("ISIS (%s): Regenerate is already pending, nothing todo."
2543 " (Due in %lld.%03lld seconds)", area->area_tag,
2544 (long long)remain.tv_sec, (long long)remain.tv_usec/1000);
2545 continue;
2546 }
2547
2548 lsp = lsp_search (lsp_id, circuit->area->lspdb[lvl - 1]);
2549 if (!lsp)
2550 {
2551 sched_debug("ISIS (%s): Pseudonode LSP does not exist yet, nothing to regenerate.",
2552 area->area_tag);
2553 continue;
2554 }
2555
2556 /*
2557 * Throttle avoidance
2558 */
2559 sched_debug("ISIS (%s): Will schedule PSN regen timer. Last run was: %lld, Now is: %lld",
2560 area->area_tag, (long long)lsp->last_generated, (long long) now);
2561 THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1]);
2562 diff = now - lsp->last_generated;
2563 if (diff < circuit->area->lsp_gen_interval[lvl - 1])
2564 {
2565 timeout = 1000 * (circuit->area->lsp_gen_interval[lvl - 1] - diff);
2566 sched_debug("ISIS (%s): Sechduling in %ld ms to match configured lsp_gen_interval",
2567 area->area_tag, timeout);
2568 }
2569 else
2570 {
2571 timeout = 100;
2572 sched_debug("ISIS (%s): Last generation was more than lsp_gen_interval ago."
2573 " Scheduling for execution in %ld ms.", area->area_tag, timeout);
2574 }
2575
2576 circuit->lsp_regenerate_pending[lvl - 1] = 1;
2577
2578 if (lvl == IS_LEVEL_1)
2579 {
2580 THREAD_TIMER_MSEC_ON(master,
2581 circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1],
2582 lsp_l1_refresh_pseudo, circuit, timeout);
2583 }
2584 else if (lvl == IS_LEVEL_2)
2585 {
2586 THREAD_TIMER_MSEC_ON(master,
2587 circuit->u.bc.t_refresh_pseudo_lsp[lvl - 1],
2588 lsp_l2_refresh_pseudo, circuit, timeout);
2589 }
2590 }
2591
2592 return ISIS_OK;
2593 }
2594
2595 /*
2596 * Walk through LSPs for an area
2597 * - set remaining lifetime
2598 * - set LSPs with SRMflag set for sending
2599 */
2600 int
lsp_tick(struct thread * thread)2601 lsp_tick (struct thread *thread)
2602 {
2603 struct isis_area *area;
2604 struct isis_circuit *circuit;
2605 struct isis_lsp *lsp;
2606 struct list *lsp_list;
2607 struct listnode *lspnode, *cnode;
2608 dnode_t *dnode, *dnode_next;
2609 int level;
2610 u_int16_t rem_lifetime;
2611
2612 lsp_list = list_new ();
2613
2614 area = THREAD_ARG (thread);
2615 assert (area);
2616 area->t_tick = NULL;
2617 THREAD_TIMER_ON (master, area->t_tick, lsp_tick, area, 1);
2618
2619 /*
2620 * Build a list of LSPs with (any) SRMflag set
2621 * and removed the ones that have aged out
2622 */
2623 for (level = 0; level < ISIS_LEVELS; level++)
2624 {
2625 if (area->lspdb[level] && dict_count (area->lspdb[level]) > 0)
2626 {
2627 for (dnode = dict_first (area->lspdb[level]);
2628 dnode != NULL; dnode = dnode_next)
2629 {
2630 dnode_next = dict_next (area->lspdb[level], dnode);
2631 lsp = dnode_get (dnode);
2632
2633 /*
2634 * The lsp rem_lifetime is kept at 0 for MaxAge or
2635 * ZeroAgeLifetime depending on explicit purge or
2636 * natural age out. So schedule spf only once when
2637 * the first time rem_lifetime becomes 0.
2638 */
2639 rem_lifetime = ntohs(lsp->lsp_header->rem_lifetime);
2640 lsp_set_time (lsp);
2641
2642 /*
2643 * Schedule may run spf which should be done only after
2644 * the lsp rem_lifetime becomes 0 for the first time.
2645 * ISO 10589 - 7.3.16.4 first paragraph.
2646 */
2647 if (rem_lifetime == 1 && lsp->lsp_header->seq_num != 0)
2648 {
2649 /* 7.3.16.4 a) set SRM flags on all */
2650 lsp_set_all_srmflags (lsp);
2651 /* 7.3.16.4 b) retain only the header FIXME */
2652 /* 7.3.16.4 c) record the time to purge FIXME */
2653 /* run/schedule spf */
2654 /* isis_spf_schedule is called inside lsp_destroy() below;
2655 * so it is not needed here. */
2656 /* isis_spf_schedule (lsp->area, lsp->level); */
2657 }
2658
2659 if (lsp->age_out == 0)
2660 {
2661 zlog_debug ("ISIS-Upd (%s): L%u LSP %s seq 0x%08x aged out",
2662 area->area_tag,
2663 lsp->level,
2664 rawlspid_print (lsp->lsp_header->lsp_id),
2665 ntohl (lsp->lsp_header->seq_num));
2666 #ifdef TOPOLOGY_GENERATE
2667 if (lsp->from_topology)
2668 THREAD_TIMER_OFF (lsp->t_lsp_top_ref);
2669 #endif /* TOPOLOGY_GENERATE */
2670 lsp_destroy (lsp);
2671 lsp = NULL;
2672 dict_delete_free (area->lspdb[level], dnode);
2673 }
2674 else if (flags_any_set (lsp->SRMflags))
2675 listnode_add (lsp_list, lsp);
2676 }
2677
2678 /*
2679 * Send LSPs on circuits indicated by the SRMflags
2680 */
2681 if (listcount (lsp_list) > 0)
2682 {
2683 for (ALL_LIST_ELEMENTS_RO (area->circuit_list, cnode, circuit))
2684 {
2685 int diff = time (NULL) - circuit->lsp_queue_last_cleared;
2686 if (circuit->lsp_queue == NULL ||
2687 diff < MIN_LSP_TRANS_INTERVAL)
2688 continue;
2689 for (ALL_LIST_ELEMENTS_RO (lsp_list, lspnode, lsp))
2690 {
2691 if (circuit->upadjcount[lsp->level - 1] &&
2692 ISIS_CHECK_FLAG (lsp->SRMflags, circuit))
2693 {
2694 /* Add the lsp only if it is not already in lsp
2695 * queue */
2696 if (! listnode_lookup (circuit->lsp_queue, lsp))
2697 {
2698 listnode_add (circuit->lsp_queue, lsp);
2699 thread_add_event (master, send_lsp, circuit, 0);
2700 }
2701 }
2702 }
2703 }
2704 list_delete_all_node (lsp_list);
2705 }
2706 }
2707 }
2708
2709 list_delete (lsp_list);
2710
2711 return ISIS_OK;
2712 }
2713
2714 void
lsp_purge_pseudo(u_char * id,struct isis_circuit * circuit,int level)2715 lsp_purge_pseudo (u_char * id, struct isis_circuit *circuit, int level)
2716 {
2717 struct isis_lsp *lsp;
2718 u_int16_t seq_num;
2719 u_int8_t lsp_bits;
2720
2721 lsp = lsp_search (id, circuit->area->lspdb[level - 1]);
2722 if (!lsp)
2723 return;
2724
2725 /* store old values */
2726 seq_num = lsp->lsp_header->seq_num;
2727 lsp_bits = lsp->lsp_header->lsp_bits;
2728
2729 /* reset stream */
2730 lsp_clear_data (lsp);
2731 stream_reset (lsp->pdu);
2732
2733 /* update header */
2734 lsp->lsp_header->pdu_len = htons (ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
2735 memcpy (lsp->lsp_header->lsp_id, id, ISIS_SYS_ID_LEN + 2);
2736 lsp->lsp_header->checksum = 0;
2737 lsp->lsp_header->seq_num = seq_num;
2738 lsp->lsp_header->rem_lifetime = 0;
2739 lsp->lsp_header->lsp_bits = lsp_bits;
2740 lsp->level = level;
2741 lsp->age_out = lsp->area->max_lsp_lifetime[level-1];
2742 stream_forward_endp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
2743
2744 /*
2745 * Add and update the authentication info if its present
2746 */
2747 lsp_auth_add (lsp);
2748 lsp->lsp_header->pdu_len = htons (stream_get_endp (lsp->pdu));
2749 lsp_auth_update (lsp);
2750 fletcher_checksum(STREAM_DATA (lsp->pdu) + 12,
2751 ntohs (lsp->lsp_header->pdu_len) - 12, 12);
2752
2753 lsp_set_all_srmflags (lsp);
2754
2755 return;
2756 }
2757
2758 /*
2759 * Purge own LSP that is received and we don't have.
2760 * -> Do as in 7.3.16.4
2761 */
2762 void
lsp_purge_non_exist(int level,struct isis_link_state_hdr * lsp_hdr,struct isis_area * area)2763 lsp_purge_non_exist (int level,
2764 struct isis_link_state_hdr *lsp_hdr,
2765 struct isis_area *area)
2766 {
2767 struct isis_lsp *lsp;
2768
2769 /*
2770 * We need to create the LSP to be purged
2771 */
2772 lsp = XCALLOC (MTYPE_ISIS_LSP, sizeof (struct isis_lsp));
2773 lsp->area = area;
2774 lsp->level = level;
2775 lsp->pdu = stream_new(LLC_LEN + area->lsp_mtu);
2776 lsp->isis_header = (struct isis_fixed_hdr *) STREAM_DATA (lsp->pdu);
2777 fill_fixed_hdr (lsp->isis_header, (lsp->level == IS_LEVEL_1) ? L1_LINK_STATE
2778 : L2_LINK_STATE);
2779 lsp->lsp_header = (struct isis_link_state_hdr *) (STREAM_DATA (lsp->pdu) +
2780 ISIS_FIXED_HDR_LEN);
2781 memcpy (lsp->lsp_header, lsp_hdr, ISIS_LSP_HDR_LEN);
2782 stream_forward_endp (lsp->pdu, ISIS_FIXED_HDR_LEN + ISIS_LSP_HDR_LEN);
2783
2784 /*
2785 * Set the remaining lifetime to 0
2786 */
2787 lsp->lsp_header->rem_lifetime = 0;
2788
2789 /*
2790 * Add and update the authentication info if its present
2791 */
2792 lsp_auth_add (lsp);
2793 lsp_auth_update (lsp);
2794
2795 /*
2796 * Update the PDU length to header plus any authentication TLV.
2797 */
2798 lsp->lsp_header->pdu_len = htons (stream_get_endp (lsp->pdu));
2799
2800 /*
2801 * Put the lsp into LSPdb
2802 */
2803 lsp_insert (lsp, area->lspdb[lsp->level - 1]);
2804
2805 /*
2806 * Send in to whole area
2807 */
2808 lsp_set_all_srmflags (lsp);
2809
2810 return;
2811 }
2812
lsp_set_all_srmflags(struct isis_lsp * lsp)2813 void lsp_set_all_srmflags (struct isis_lsp *lsp)
2814 {
2815 struct listnode *node;
2816 struct isis_circuit *circuit;
2817
2818 assert (lsp);
2819
2820 ISIS_FLAGS_CLEAR_ALL(lsp->SRMflags);
2821
2822 if (lsp->area)
2823 {
2824 struct list *circuit_list = lsp->area->circuit_list;
2825 for (ALL_LIST_ELEMENTS_RO (circuit_list, node, circuit))
2826 {
2827 ISIS_SET_FLAG(lsp->SRMflags, circuit);
2828 }
2829 }
2830 }
2831
2832 #ifdef TOPOLOGY_GENERATE
2833 static int
top_lsp_refresh(struct thread * thread)2834 top_lsp_refresh (struct thread *thread)
2835 {
2836 struct isis_lsp *lsp;
2837 u_int16_t rem_lifetime;
2838
2839 lsp = THREAD_ARG (thread);
2840 assert (lsp);
2841
2842 lsp->t_lsp_top_ref = NULL;
2843
2844 lsp_seqnum_update (lsp);
2845
2846 lsp_set_all_srmflags (lsp);
2847 if (isis->debugs & DEBUG_UPDATE_PACKETS)
2848 {
2849 zlog_debug ("ISIS-Upd (): refreshing Topology L1 %s",
2850 rawlspid_print (lsp->lsp_header->lsp_id));
2851 }
2852 /* Refresh dynamic hostname in the cache. */
2853 isis_dynhn_insert (lsp->lsp_header->lsp_id, lsp->tlv_data.hostname,
2854 IS_LEVEL_1);
2855
2856 lsp->lsp_header->lsp_bits = lsp_bits_generate (lsp->level,
2857 lsp->area->overload_bit,
2858 lsp->area->attached_bit);
2859 rem_lifetime = lsp_rem_lifetime (lsp->area, IS_LEVEL_1);
2860 lsp->lsp_header->rem_lifetime = htons (rem_lifetime);
2861
2862 /* refresh_time = lsp_refresh_time (lsp, rem_lifetime); */
2863 THREAD_TIMER_ON (master, lsp->t_lsp_top_ref, top_lsp_refresh, lsp,
2864 lsp->area->lsp_refresh[0]);
2865
2866 return ISIS_OK;
2867 }
2868
2869 void
generate_topology_lsps(struct isis_area * area)2870 generate_topology_lsps (struct isis_area *area)
2871 {
2872 struct listnode *node;
2873 int i, max = 0;
2874 struct arc *arc;
2875 u_char lspid[ISIS_SYS_ID_LEN + 2];
2876 struct isis_lsp *lsp;
2877 u_int16_t rem_lifetime, refresh_time;
2878
2879 /* first we find the maximal node */
2880 for (ALL_LIST_ELEMENTS_RO (area->topology, node, arc))
2881 {
2882 if (arc->from_node > max)
2883 max = arc->from_node;
2884 if (arc->to_node > max)
2885 max = arc->to_node;
2886 }
2887
2888 for (i = 1; i < (max + 1); i++)
2889 {
2890 memcpy (lspid, area->topology_baseis, ISIS_SYS_ID_LEN);
2891 LSP_PSEUDO_ID (lspid) = 0x00;
2892 LSP_FRAGMENT (lspid) = 0x00;
2893 lspid[ISIS_SYS_ID_LEN - 1] = (i & 0xFF);
2894 lspid[ISIS_SYS_ID_LEN - 2] = ((i >> 8) & 0xFF);
2895
2896 rem_lifetime = lsp_rem_lifetime (area, IS_LEVEL_1);
2897 lsp = lsp_new (area, lspid, rem_lifetime, 1,
2898 IS_LEVEL_1 | area->overload_bit | area->attached_bit,
2899 0, 1);
2900 if (!lsp)
2901 return;
2902 lsp->from_topology = 1;
2903
2904 /* Creating LSP data based on topology info. */
2905 build_topology_lsp_data (lsp, area, i);
2906 /* Checksum is also calculated here. */
2907 lsp_seqnum_update (lsp);
2908 /* Take care of inserting dynamic hostname into cache. */
2909 isis_dynhn_insert (lspid, lsp->tlv_data.hostname, IS_LEVEL_1);
2910
2911 refresh_time = lsp_refresh_time (lsp, rem_lifetime);
2912 THREAD_TIMER_ON (master, lsp->t_lsp_top_ref, top_lsp_refresh, lsp,
2913 refresh_time);
2914 lsp_set_all_srmflags (lsp);
2915 lsp_insert (lsp, area->lspdb[0]);
2916 }
2917 }
2918
2919 void
remove_topology_lsps(struct isis_area * area)2920 remove_topology_lsps (struct isis_area *area)
2921 {
2922 struct isis_lsp *lsp;
2923 dnode_t *dnode, *dnode_next;
2924
2925 dnode = dict_first (area->lspdb[0]);
2926 while (dnode != NULL)
2927 {
2928 dnode_next = dict_next (area->lspdb[0], dnode);
2929 lsp = dnode_get (dnode);
2930 if (lsp->from_topology)
2931 {
2932 THREAD_TIMER_OFF (lsp->t_lsp_top_ref);
2933 lsp_destroy (lsp);
2934 dict_delete (area->lspdb[0], dnode);
2935 }
2936 dnode = dnode_next;
2937 }
2938 }
2939
2940 void
build_topology_lsp_data(struct isis_lsp * lsp,struct isis_area * area,int lsp_top_num)2941 build_topology_lsp_data (struct isis_lsp *lsp, struct isis_area *area,
2942 int lsp_top_num)
2943 {
2944 struct listnode *node;
2945 struct arc *arc;
2946 struct is_neigh *is_neigh;
2947 struct te_is_neigh *te_is_neigh;
2948 char buff[200];
2949 struct tlvs tlv_data;
2950 struct isis_lsp *lsp0 = lsp;
2951
2952 /* Add area addresses. FIXME: Is it needed at all? */
2953 if (lsp->tlv_data.area_addrs == NULL)
2954 lsp->tlv_data.area_addrs = list_new ();
2955 list_add_list (lsp->tlv_data.area_addrs, area->area_addrs);
2956
2957 if (lsp->tlv_data.nlpids == NULL)
2958 lsp->tlv_data.nlpids = XMALLOC (MTYPE_ISIS_TLV, sizeof (struct nlpids));
2959 lsp->tlv_data.nlpids->count = 1;
2960 lsp->tlv_data.nlpids->nlpids[0] = NLPID_IP;
2961
2962 if (area->dynhostname)
2963 {
2964 lsp->tlv_data.hostname = XMALLOC (MTYPE_ISIS_TLV,
2965 sizeof (struct hostname));
2966 memset (buff, 0x00, 200);
2967 sprintf (buff, "%s%d", area->topology_basedynh ? area->topology_basedynh :
2968 "feedme", lsp_top_num);
2969 memcpy (lsp->tlv_data.hostname->name, buff, strlen (buff));
2970 lsp->tlv_data.hostname->namelen = strlen (buff);
2971 }
2972
2973 if (lsp->tlv_data.nlpids)
2974 tlv_add_nlpid (lsp->tlv_data.nlpids, lsp->pdu);
2975 if (lsp->tlv_data.hostname)
2976 tlv_add_dynamic_hostname (lsp->tlv_data.hostname, lsp->pdu);
2977 if (lsp->tlv_data.area_addrs && listcount (lsp->tlv_data.area_addrs) > 0)
2978 tlv_add_area_addrs (lsp->tlv_data.area_addrs, lsp->pdu);
2979
2980 memset (&tlv_data, 0, sizeof (struct tlvs));
2981 if (tlv_data.is_neighs == NULL)
2982 {
2983 tlv_data.is_neighs = list_new ();
2984 tlv_data.is_neighs->del = free_tlv;
2985 }
2986
2987 /* Add reachability for this IS for simulated 1. */
2988 if (lsp_top_num == 1)
2989 {
2990 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
2991
2992 memcpy (&is_neigh->neigh_id, isis->sysid, ISIS_SYS_ID_LEN);
2993 LSP_PSEUDO_ID (is_neigh->neigh_id) = 0x00;
2994 /* Metric MUST NOT be 0, unless it's not alias TLV. */
2995 is_neigh->metrics.metric_default = 0x01;
2996 is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
2997 is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
2998 is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
2999 listnode_add (tlv_data.is_neighs, is_neigh);
3000 }
3001
3002 /* Add IS reachabilities. */
3003 for (ALL_LIST_ELEMENTS_RO (area->topology, node, arc))
3004 {
3005 int to_lsp = 0;
3006
3007 if ((lsp_top_num != arc->from_node) && (lsp_top_num != arc->to_node))
3008 continue;
3009
3010 if (lsp_top_num == arc->from_node)
3011 to_lsp = arc->to_node;
3012 else
3013 to_lsp = arc->from_node;
3014
3015 if (area->oldmetric)
3016 {
3017 is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct is_neigh));
3018
3019 memcpy (&is_neigh->neigh_id, area->topology_baseis, ISIS_SYS_ID_LEN);
3020 is_neigh->neigh_id[ISIS_SYS_ID_LEN - 1] = (to_lsp & 0xFF);
3021 is_neigh->neigh_id[ISIS_SYS_ID_LEN - 2] = ((to_lsp >> 8) & 0xFF);
3022 is_neigh->metrics.metric_default = arc->distance;
3023 is_neigh->metrics.metric_delay = METRICS_UNSUPPORTED;
3024 is_neigh->metrics.metric_expense = METRICS_UNSUPPORTED;
3025 is_neigh->metrics.metric_error = METRICS_UNSUPPORTED;
3026 listnode_add (tlv_data.is_neighs, is_neigh);
3027 }
3028
3029 if (area->newmetric)
3030 {
3031 if (tlv_data.te_is_neighs == NULL)
3032 {
3033 tlv_data.te_is_neighs = list_new ();
3034 tlv_data.te_is_neighs->del = free_tlv;
3035 }
3036 te_is_neigh = XCALLOC (MTYPE_ISIS_TLV, sizeof (struct te_is_neigh));
3037 memcpy (&te_is_neigh->neigh_id, area->topology_baseis,
3038 ISIS_SYS_ID_LEN);
3039 te_is_neigh->neigh_id[ISIS_SYS_ID_LEN - 1] = (to_lsp & 0xFF);
3040 te_is_neigh->neigh_id[ISIS_SYS_ID_LEN - 2] = ((to_lsp >> 8) & 0xFF);
3041 SET_TE_METRIC(te_is_neigh, arc->distance);
3042 listnode_add (tlv_data.te_is_neighs, te_is_neigh);
3043 }
3044 }
3045
3046 while (tlv_data.is_neighs && listcount (tlv_data.is_neighs))
3047 {
3048 if (lsp->tlv_data.is_neighs == NULL)
3049 lsp->tlv_data.is_neighs = list_new ();
3050 lsp_tlv_fit (lsp, &tlv_data.is_neighs, &lsp->tlv_data.is_neighs,
3051 IS_NEIGHBOURS_LEN, area->lsp_frag_threshold,
3052 tlv_add_is_neighs);
3053 if (tlv_data.is_neighs && listcount (tlv_data.is_neighs))
3054 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
3055 lsp0, area, IS_LEVEL_1);
3056 }
3057
3058 while (tlv_data.te_is_neighs && listcount (tlv_data.te_is_neighs))
3059 {
3060 if (lsp->tlv_data.te_is_neighs == NULL)
3061 lsp->tlv_data.te_is_neighs = list_new ();
3062 lsp_tlv_fit (lsp, &tlv_data.te_is_neighs, &lsp->tlv_data.te_is_neighs,
3063 IS_NEIGHBOURS_LEN, area->lsp_frag_threshold,
3064 tlv_add_te_is_neighs);
3065 if (tlv_data.te_is_neighs && listcount (tlv_data.te_is_neighs))
3066 lsp = lsp_next_frag (LSP_FRAGMENT (lsp->lsp_header->lsp_id) + 1,
3067 lsp0, area, IS_LEVEL_1);
3068 }
3069
3070 free_tlvs (&tlv_data);
3071 return;
3072 }
3073 #endif /* TOPOLOGY_GENERATE */
3074