![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_tlv.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd|
Return to isis_tlv.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd |
1.1 misho 1: /*
2: * IS-IS Rout(e)ing protocol - isis_tlv.c
3: * IS-IS TLV related routines
4: *
5: * Copyright (C) 2001,2002 Sampo Saaristo
6: * Tampere University of Technology
7: * Institute of Communications Engineering
8: *
9: * This program is free software; you can redistribute it and/or modify it
10: * under the terms of the GNU General Public Licenseas published by the Free
11: * Software Foundation; either version 2 of the License, or (at your option)
12: * any later version.
13: *
14: * This program is distributed in the hope that it will be useful,but WITHOUT
15: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17: * more details.
18:
19: * You should have received a copy of the GNU General Public License along
20: * with this program; if not, write to the Free Software Foundation, Inc.,
21: * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22: */
23:
24: #include <zebra.h>
25:
26: #include "log.h"
27: #include "linklist.h"
28: #include "stream.h"
29: #include "memory.h"
30: #include "prefix.h"
31: #include "vty.h"
32: #include "if.h"
33:
34: #include "isisd/dict.h"
35: #include "isisd/isis_constants.h"
36: #include "isisd/isis_common.h"
37: #include "isisd/isis_flags.h"
38: #include "isisd/isis_circuit.h"
39: #include "isisd/isis_tlv.h"
40: #include "isisd/isisd.h"
41: #include "isisd/isis_dynhn.h"
42: #include "isisd/isis_misc.h"
43: #include "isisd/isis_pdu.h"
44: #include "isisd/isis_lsp.h"
45:
46: extern struct isis *isis;
47:
48: /*
49: * Prototypes.
50: */
51: int add_tlv (u_char, u_char, u_char *, struct stream *);
52:
53: void
54: free_tlv (void *val)
55: {
56: XFREE (MTYPE_ISIS_TLV, val);
57:
58: return;
59: }
60:
61: /*
62: * Called after parsing of a PDU. There shouldn't be any tlv's left, so this
63: * is only a caution to avoid memory leaks
64: */
65: void
66: free_tlvs (struct tlvs *tlvs)
67: {
68: if (tlvs->area_addrs)
69: list_delete (tlvs->area_addrs);
70: if (tlvs->is_neighs)
71: list_delete (tlvs->is_neighs);
72: if (tlvs->te_is_neighs)
73: list_delete (tlvs->te_is_neighs);
74: if (tlvs->es_neighs)
75: list_delete (tlvs->es_neighs);
76: if (tlvs->lsp_entries)
77: list_delete (tlvs->lsp_entries);
78: if (tlvs->lan_neighs)
79: list_delete (tlvs->lan_neighs);
80: if (tlvs->prefix_neighs)
81: list_delete (tlvs->prefix_neighs);
82: if (tlvs->ipv4_addrs)
83: list_delete (tlvs->ipv4_addrs);
84: if (tlvs->ipv4_int_reachs)
85: list_delete (tlvs->ipv4_int_reachs);
86: if (tlvs->ipv4_ext_reachs)
87: list_delete (tlvs->ipv4_ext_reachs);
88: if (tlvs->te_ipv4_reachs)
89: list_delete (tlvs->te_ipv4_reachs);
90: #ifdef HAVE_IPV6
91: if (tlvs->ipv6_addrs)
92: list_delete (tlvs->ipv6_addrs);
93: if (tlvs->ipv6_reachs)
94: list_delete (tlvs->ipv6_reachs);
95: #endif /* HAVE_IPV6 */
96:
97: return;
98: }
99:
100: /*
101: * Parses the tlvs found in the variant length part of the PDU.
102: * Caller tells with flags in "expected" which TLV's it is interested in.
103: */
104: int
105: parse_tlvs (char *areatag, u_char * stream, int size, u_int32_t * expected,
106: u_int32_t * found, struct tlvs *tlvs)
107: {
108: u_char type, length;
109: struct lan_neigh *lan_nei;
110: struct area_addr *area_addr;
111: struct is_neigh *is_nei;
112: struct te_is_neigh *te_is_nei;
113: struct es_neigh *es_nei;
114: struct lsp_entry *lsp_entry;
115: struct in_addr *ipv4_addr;
116: struct ipv4_reachability *ipv4_reach;
117: struct te_ipv4_reachability *te_ipv4_reach;
118: #ifdef HAVE_IPV6
119: struct in6_addr *ipv6_addr;
120: struct ipv6_reachability *ipv6_reach;
121: int prefix_octets;
122: #endif /* HAVE_IPV6 */
123: u_char virtual;
124: int value_len, retval = ISIS_OK;
125: u_char *pnt = stream;
126:
127: *found = 0;
128: memset (tlvs, 0, sizeof (struct tlvs));
129:
130: while (pnt < stream + size - 2)
131: {
132: type = *pnt;
133: length = *(pnt + 1);
134: pnt += 2;
135: value_len = 0;
136: if (pnt + length > stream + size)
137: {
138: zlog_warn ("ISIS-TLV (%s): TLV (type %d, length %d) exceeds packet "
139: "boundaries", areatag, type, length);
140: retval = ISIS_WARNING;
141: break;
142: }
143: switch (type)
144: {
145: case AREA_ADDRESSES:
146: /* +-------+-------+-------+-------+-------+-------+-------+-------+
147: * | Address Length |
148: * +-------+-------+-------+-------+-------+-------+-------+-------+
149: * | Area Address |
150: * +-------+-------+-------+-------+-------+-------+-------+-------+
151: * : :
152: */
153: *found |= TLVFLAG_AREA_ADDRS;
154: #ifdef EXTREME_TLV_DEBUG
155: zlog_debug ("TLV Area Adresses len %d", length);
156: #endif /* EXTREME_TLV_DEBUG */
157: if (*expected & TLVFLAG_AREA_ADDRS)
158: {
159: while (length > value_len)
160: {
161: area_addr = (struct area_addr *) pnt;
162: value_len += area_addr->addr_len + 1;
163: pnt += area_addr->addr_len + 1;
164: if (!tlvs->area_addrs)
165: tlvs->area_addrs = list_new ();
166: listnode_add (tlvs->area_addrs, area_addr);
167: }
168: }
169: else
170: {
171: pnt += length;
172: }
173: break;
174:
175: case IS_NEIGHBOURS:
176: *found |= TLVFLAG_IS_NEIGHS;
177: #ifdef EXTREME_TLV_DEBUG
178: zlog_debug ("ISIS-TLV (%s): IS Neighbours length %d",
179: areatag, length);
180: #endif /* EXTREME_TLV_DEBUG */
181: if (TLVFLAG_IS_NEIGHS & *expected)
182: {
183: /* +-------+-------+-------+-------+-------+-------+-------+-------+
184: * | Virtual Flag |
185: * +-------+-------+-------+-------+-------+-------+-------+-------+
186: */
187: virtual = *pnt; /* FIXME: what is the use for this? */
188: pnt++;
189: value_len++;
190: /* +-------+-------+-------+-------+-------+-------+-------+-------+
191: * | 0 | I/E | Default Metric |
192: * +-------+-------+-------+-------+-------+-------+-------+-------+
193: * | S | I/E | Delay Metric |
194: * +-------+-------+-------+-------+-------+-------+-------+-------+
195: * | S | I/E | Expense Metric |
196: * +-------+-------+-------+-------+-------+-------+-------+-------+
197: * | S | I/E | Error Metric |
198: * +-------+-------+-------+-------+-------+-------+-------+-------+
199: * | Neighbour ID |
200: * +---------------------------------------------------------------+
201: * : :
202: */
203: while (length > value_len)
204: {
205: is_nei = (struct is_neigh *) pnt;
206: value_len += 4 + ISIS_SYS_ID_LEN + 1;
207: pnt += 4 + ISIS_SYS_ID_LEN + 1;
208: if (!tlvs->is_neighs)
209: tlvs->is_neighs = list_new ();
210: listnode_add (tlvs->is_neighs, is_nei);
211: }
212: }
213: else
214: {
215: pnt += length;
216: }
217: break;
218:
219: case TE_IS_NEIGHBOURS:
220: /* +-------+-------+-------+-------+-------+-------+-------+-------+
221: * | Neighbour ID | 7
222: * +---------------------------------------------------------------+
223: * | TE Metric | 3
224: * +---------------------------------------------------------------+
225: * | SubTLVs Length | 1
226: * +---------------------------------------------------------------+
227: * : :
228: */
229: *found |= TLVFLAG_TE_IS_NEIGHS;
230: #ifdef EXTREME_TLV_DEBUG
231: zlog_debug ("ISIS-TLV (%s): Extended IS Neighbours length %d",
232: areatag, length);
233: #endif /* EXTREME_TLV_DEBUG */
234: if (TLVFLAG_TE_IS_NEIGHS & *expected)
235: {
236: while (length > value_len)
237: {
238: te_is_nei = (struct te_is_neigh *) pnt;
239: value_len += 11;
240: pnt += 11;
241: /* FIXME - subtlvs are handled here, for now we skip */
242: value_len += te_is_nei->sub_tlvs_length;
243: pnt += te_is_nei->sub_tlvs_length;
244:
245: if (!tlvs->te_is_neighs)
246: tlvs->te_is_neighs = list_new ();
247: listnode_add (tlvs->te_is_neighs, te_is_nei);
248: }
249: }
250: else
251: {
252: pnt += length;
253: }
254: break;
255:
256: case ES_NEIGHBOURS:
257: /* +-------+-------+-------+-------+-------+-------+-------+-------+
258: * | 0 | I/E | Default Metric |
259: * +-------+-------+-------+-------+-------+-------+-------+-------+
260: * | S | I/E | Delay Metric |
261: * +-------+-------+-------+-------+-------+-------+-------+-------+
262: * | S | I/E | Expense Metric |
263: * +-------+-------+-------+-------+-------+-------+-------+-------+
264: * | S | I/E | Error Metric |
265: * +-------+-------+-------+-------+-------+-------+-------+-------+
266: * | Neighbour ID |
267: * +---------------------------------------------------------------+
268: * | Neighbour ID |
269: * +---------------------------------------------------------------+
270: * : :
271: */
272: #ifdef EXTREME_TLV_DEBUG
273: zlog_debug ("ISIS-TLV (%s): ES Neighbours length %d",
274: areatag, length);
275: #endif /* EXTREME_TLV_DEBUG */
276: *found |= TLVFLAG_ES_NEIGHS;
277: if (*expected & TLVFLAG_ES_NEIGHS)
278: {
279: es_nei = (struct es_neigh *) pnt;
280: value_len += 4;
281: pnt += 4;
282: while (length > value_len)
283: {
284: /* FIXME FIXME FIXME - add to the list */
285: /* sys_id->id = pnt; */
286: value_len += ISIS_SYS_ID_LEN;
287: pnt += ISIS_SYS_ID_LEN;
288: /* if (!es_nei->neigh_ids) es_nei->neigh_ids = sysid; */
289: }
290: if (!tlvs->es_neighs)
291: tlvs->es_neighs = list_new ();
292: listnode_add (tlvs->es_neighs, es_nei);
293: }
294: else
295: {
296: pnt += length;
297: }
298: break;
299:
300: case LAN_NEIGHBOURS:
301: /* +-------+-------+-------+-------+-------+-------+-------+-------+
302: * | LAN Address |
303: * +-------+-------+-------+-------+-------+-------+-------+-------+
304: * : :
305: */
306: *found |= TLVFLAG_LAN_NEIGHS;
307: #ifdef EXTREME_TLV_DEBUG
308: zlog_debug ("ISIS-TLV (%s): LAN Neigbours length %d",
309: areatag, length);
310: #endif /* EXTREME_TLV_DEBUG */
311: if (TLVFLAG_LAN_NEIGHS & *expected)
312: {
313: while (length > value_len)
314: {
315: lan_nei = (struct lan_neigh *) pnt;
316: if (!tlvs->lan_neighs)
317: tlvs->lan_neighs = list_new ();
318: listnode_add (tlvs->lan_neighs, lan_nei);
319: value_len += ETH_ALEN;
320: pnt += ETH_ALEN;
321: }
322: }
323: else
324: {
325: pnt += length;
326: }
327: break;
328:
329: case PADDING:
330: #ifdef EXTREME_TLV_DEBUG
331: zlog_debug ("TLV padding %d", length);
332: #endif /* EXTREME_TLV_DEBUG */
333: pnt += length;
334: break;
335:
336: case LSP_ENTRIES:
337: /* +-------+-------+-------+-------+-------+-------+-------+-------+
338: * | Remaining Lifetime | 2
339: * +-------+-------+-------+-------+-------+-------+-------+-------+
340: * | LSP ID | id+2
341: * +-------+-------+-------+-------+-------+-------+-------+-------+
342: * | LSP Sequence Number | 4
343: * +-------+-------+-------+-------+-------+-------+-------+-------+
344: * | Checksum | 2
345: * +-------+-------+-------+-------+-------+-------+-------+-------+
346: */
347: #ifdef EXTREME_TLV_DEBUG
348: zlog_debug ("ISIS-TLV (%s): LSP Entries length %d", areatag, length);
349: #endif /* EXTREME_TLV_DEBUG */
350: *found |= TLVFLAG_LSP_ENTRIES;
351: if (TLVFLAG_LSP_ENTRIES & *expected)
352: {
353: while (length > value_len)
354: {
355: lsp_entry = (struct lsp_entry *) pnt;
356: value_len += 10 + ISIS_SYS_ID_LEN;
357: pnt += 10 + ISIS_SYS_ID_LEN;
358: if (!tlvs->lsp_entries)
359: tlvs->lsp_entries = list_new ();
360: listnode_add (tlvs->lsp_entries, lsp_entry);
361: }
362: }
363: else
364: {
365: pnt += length;
366: }
367: break;
368:
369: case CHECKSUM:
370: /* +-------+-------+-------+-------+-------+-------+-------+-------+
371: * | 16 bit fletcher CHECKSUM |
372: * +-------+-------+-------+-------+-------+-------+-------+-------+
373: * : :
374: */
375: *found |= TLVFLAG_CHECKSUM;
376: #ifdef EXTREME_TLV_DEBUG
377: zlog_debug ("ISIS-TLV (%s): Checksum length %d", areatag, length);
378: #endif /* EXTREME_TLV_DEBUG */
379: if (*expected & TLVFLAG_CHECKSUM)
380: {
381: tlvs->checksum = (struct checksum *) pnt;
382: }
383: pnt += length;
384: break;
385:
386: case PROTOCOLS_SUPPORTED:
387: /* +-------+-------+-------+-------+-------+-------+-------+-------+
388: * | NLPID |
389: * +-------+-------+-------+-------+-------+-------+-------+-------+
390: * : :
391: */
392: *found |= TLVFLAG_NLPID;
393: #ifdef EXTREME_TLV_DEBUG
394: zlog_debug ("ISIS-TLV (%s): Protocols Supported length %d",
395: areatag, length);
396: #endif /* EXTREME_TLV_DEBUG */
397: if (*expected & TLVFLAG_NLPID)
398: {
399: tlvs->nlpids = (struct nlpids *) (pnt - 1);
400: }
401: pnt += length;
402: break;
403:
404: case IPV4_ADDR:
405: /* +-------+-------+-------+-------+-------+-------+-------+-------+
406: * + IP version 4 address + 4
407: * +-------+-------+-------+-------+-------+-------+-------+-------+
408: * : :
409: */
410: *found |= TLVFLAG_IPV4_ADDR;
411: #ifdef EXTREME_TLV_DEBUG
412: zlog_debug ("ISIS-TLV (%s): IPv4 Address length %d",
413: areatag, length);
414: #endif /* EXTREME_TLV_DEBUG */
415: if (*expected & TLVFLAG_IPV4_ADDR)
416: {
417: while (length > value_len)
418: {
419: ipv4_addr = (struct in_addr *) pnt;
420: #ifdef EXTREME_TLV_DEBUG
421: zlog_debug ("ISIS-TLV (%s) : IP ADDR %s, pnt %p", areatag,
422: inet_ntoa (*ipv4_addr), pnt);
423: #endif /* EXTREME_TLV_DEBUG */
424: if (!tlvs->ipv4_addrs)
425: tlvs->ipv4_addrs = list_new ();
426: listnode_add (tlvs->ipv4_addrs, ipv4_addr);
427: value_len += 4;
428: pnt += 4;
429: }
430: }
431: else
432: {
433: pnt += length;
434: }
435: break;
436:
437: case AUTH_INFO:
438: *found |= TLVFLAG_AUTH_INFO;
439: #ifdef EXTREME_TLV_DEBUG
440: zlog_debug ("ISIS-TLV (%s): IS-IS Authentication Information",
441: areatag);
442: #endif
443: if (*expected & TLVFLAG_AUTH_INFO)
444: {
445: tlvs->auth_info.type = *pnt;
446: tlvs->auth_info.len = length-1;
447: pnt++;
448: memcpy (tlvs->auth_info.passwd, pnt, length - 1);
449: pnt += length - 1;
450: }
451: else
452: {
453: pnt += length;
454: }
455: break;
456:
457: case DYNAMIC_HOSTNAME:
458: *found |= TLVFLAG_DYN_HOSTNAME;
459: #ifdef EXTREME_TLV_DEBUG
460: zlog_debug ("ISIS-TLV (%s): Dynamic Hostname length %d",
461: areatag, length);
462: #endif /* EXTREME_TLV_DEBUG */
463: if (*expected & TLVFLAG_DYN_HOSTNAME)
464: {
465: /* the length is also included in the pointed struct */
466: tlvs->hostname = (struct hostname *) (pnt - 1);
467: }
468: pnt += length;
469: break;
470:
471: case TE_ROUTER_ID:
472: /* +---------------------------------------------------------------+
473: * + Router ID + 4
474: * +---------------------------------------------------------------+
475: */
476: *found |= TLVFLAG_TE_ROUTER_ID;
477: #ifdef EXTREME_TLV_DEBUG
478: zlog_debug ("ISIS-TLV (%s): TE Router ID %d", areatag, length);
479: #endif /* EXTREME_TLV_DEBUG */
480: if (*expected & TLVFLAG_TE_ROUTER_ID)
481: tlvs->router_id = (struct te_router_id *) (pnt);
482: pnt += length;
483: break;
484:
485: case IPV4_INT_REACHABILITY:
486: /* +-------+-------+-------+-------+-------+-------+-------+-------+
487: * | 0 | I/E | Default Metric | 1
488: * +-------+-------+-------+-------+-------+-------+-------+-------+
489: * | S | I/E | Delay Metric | 1
490: * +-------+-------+-------+-------+-------+-------+-------+-------+
491: * | S | I/E | Expense Metric | 1
492: * +-------+-------+-------+-------+-------+-------+-------+-------+
493: * | S | I/E | Error Metric | 1
494: * +-------+-------+-------+-------+-------+-------+-------+-------+
495: * | ip address | 4
496: * +---------------------------------------------------------------+
497: * | address mask | 4
498: * +---------------------------------------------------------------+
499: * : :
500: */
501: *found |= TLVFLAG_IPV4_INT_REACHABILITY;
502: #ifdef EXTREME_TLV_DEBUG
503: zlog_debug ("ISIS-TLV (%s): IPv4 internal Reachability length %d",
504: areatag, length);
505: #endif /* EXTREME_TLV_DEBUG */
506: if (*expected & TLVFLAG_IPV4_INT_REACHABILITY)
507: {
508: while (length > value_len)
509: {
510: ipv4_reach = (struct ipv4_reachability *) pnt;
511: if (!tlvs->ipv4_int_reachs)
512: tlvs->ipv4_int_reachs = list_new ();
513: listnode_add (tlvs->ipv4_int_reachs, ipv4_reach);
514: value_len += 12;
515: pnt += 12;
516: }
517: }
518: else
519: {
520: pnt += length;
521: }
522: break;
523:
524: case IPV4_EXT_REACHABILITY:
525: /* +-------+-------+-------+-------+-------+-------+-------+-------+
526: * | 0 | I/E | Default Metric | 1
527: * +-------+-------+-------+-------+-------+-------+-------+-------+
528: * | S | I/E | Delay Metric | 1
529: * +-------+-------+-------+-------+-------+-------+-------+-------+
530: * | S | I/E | Expense Metric | 1
531: * +-------+-------+-------+-------+-------+-------+-------+-------+
532: * | S | I/E | Error Metric | 1
533: * +-------+-------+-------+-------+-------+-------+-------+-------+
534: * | ip address | 4
535: * +---------------------------------------------------------------+
536: * | address mask | 4
537: * +---------------------------------------------------------------+
538: * : :
539: */
540: *found |= TLVFLAG_IPV4_EXT_REACHABILITY;
541: #ifdef EXTREME_TLV_DEBUG
542: zlog_debug ("ISIS-TLV (%s): IPv4 external Reachability length %d",
543: areatag, length);
544: #endif /* EXTREME_TLV_DEBUG */
545: if (*expected & TLVFLAG_IPV4_EXT_REACHABILITY)
546: {
547: while (length > value_len)
548: {
549: ipv4_reach = (struct ipv4_reachability *) pnt;
550: if (!tlvs->ipv4_ext_reachs)
551: tlvs->ipv4_ext_reachs = list_new ();
552: listnode_add (tlvs->ipv4_ext_reachs, ipv4_reach);
553: value_len += 12;
554: pnt += 12;
555: }
556: }
557: else
558: {
559: pnt += length;
560: }
561: break;
562:
563: case TE_IPV4_REACHABILITY:
564: /* +-------+-------+-------+-------+-------+-------+-------+-------+
565: * | TE Metric | 4
566: * +-------+-------+-------+-------+-------+-------+-------+-------+
567: * | U/D | sTLV? | Prefix Mask Len | 1
568: * +-------+-------+-------+-------+-------+-------+-------+-------+
569: * | Prefix | 0-4
570: * +---------------------------------------------------------------+
571: * | sub tlvs |
572: * +---------------------------------------------------------------+
573: * : :
574: */
575: *found |= TLVFLAG_TE_IPV4_REACHABILITY;
576: #ifdef EXTREME_TLV_DEBUG
577: zlog_debug ("ISIS-TLV (%s): IPv4 extended Reachability length %d",
578: areatag, length);
579: #endif /* EXTREME_TLV_DEBUG */
580: if (*expected & TLVFLAG_TE_IPV4_REACHABILITY)
581: {
582: while (length > value_len)
583: {
584: te_ipv4_reach = (struct te_ipv4_reachability *) pnt;
585: if (!tlvs->te_ipv4_reachs)
586: tlvs->te_ipv4_reachs = list_new ();
587: listnode_add (tlvs->te_ipv4_reachs, te_ipv4_reach);
588: /* this trickery is permitable since no subtlvs are defined */
589: value_len += 5 + ((te_ipv4_reach->control & 0x3F) ?
590: ((((te_ipv4_reach->control & 0x3F) -
591: 1) >> 3) + 1) : 0);
592: pnt += 5 + ((te_ipv4_reach->control & 0x3F) ?
593: ((((te_ipv4_reach->control & 0x3F) - 1) >> 3) + 1) : 0);
594: }
595: }
596: else
597: {
598: pnt += length;
599: }
600: break;
601:
602: #ifdef HAVE_IPV6
603: case IPV6_ADDR:
604: /* +-------+-------+-------+-------+-------+-------+-------+-------+
605: * + IP version 6 address + 16
606: * +-------+-------+-------+-------+-------+-------+-------+-------+
607: * : :
608: */
609: *found |= TLVFLAG_IPV6_ADDR;
610: #ifdef EXTREME_TLV_DEBUG
611: zlog_debug ("ISIS-TLV (%s): IPv6 Address length %d",
612: areatag, length);
613: #endif /* EXTREME_TLV_DEBUG */
614: if (*expected & TLVFLAG_IPV6_ADDR)
615: {
616: while (length > value_len)
617: {
618: ipv6_addr = (struct in6_addr *) pnt;
619: if (!tlvs->ipv6_addrs)
620: tlvs->ipv6_addrs = list_new ();
621: listnode_add (tlvs->ipv6_addrs, ipv6_addr);
622: value_len += 16;
623: pnt += 16;
624: }
625: }
626: else
627: {
628: pnt += length;
629: }
630: break;
631:
632: case IPV6_REACHABILITY:
633: /* +-------+-------+-------+-------+-------+-------+-------+-------+
634: * | Default Metric | 4
635: * +-------+-------+-------+-------+-------+-------+-------+-------+
636: * | Control Informantion |
637: * +---------------------------------------------------------------+
638: * | IPv6 Prefix Length |--+
639: * +---------------------------------------------------------------+ |
640: * | IPv6 Prefix |<-+
641: * +---------------------------------------------------------------+
642: */
643: *found |= TLVFLAG_IPV6_REACHABILITY;
644: if (*expected & TLVFLAG_IPV6_REACHABILITY)
645: {
646: while (length > value_len)
647: {
648: ipv6_reach = (struct ipv6_reachability *) pnt;
649: prefix_octets = ((ipv6_reach->prefix_len + 7) / 8);
650: value_len += prefix_octets + 6;
651: pnt += prefix_octets + 6;
652: /* FIXME: sub-tlvs */
653: if (!tlvs->ipv6_reachs)
654: tlvs->ipv6_reachs = list_new ();
655: listnode_add (tlvs->ipv6_reachs, ipv6_reach);
656: }
657: }
658: else
659: {
660: pnt += length;
661: }
662: break;
663: #endif /* HAVE_IPV6 */
664:
665: case WAY3_HELLO:
666: /* +---------------------------------------------------------------+
667: * | Adjacency state | 1
668: * +---------------------------------------------------------------+
669: * | Extended Local Circuit ID | 4
670: * +---------------------------------------------------------------+
671: * | Neighbor System ID (If known) | 0-8
672: * (probably 6)
673: * +---------------------------------------------------------------+
674: * | Neighbor Local Circuit ID (If known) | 4
675: * +---------------------------------------------------------------+
676: */
677: *found |= TLVFLAG_3WAY_HELLO;
678: if (*expected & TLVFLAG_3WAY_HELLO)
679: {
680: while (length > value_len)
681: {
682: /* FIXME: make this work */
683: /* Adjacency State (one octet):
684: 0 = Up
685: 1 = Initializing
686: 2 = Down
687: Extended Local Circuit ID (four octets)
688: Neighbor System ID if known (zero to eight octets)
689: Neighbor Extended Local Circuit ID (four octets, if Neighbor
690: System ID is present) */
691: pnt += length;
692: }
693: }
694: else
695: {
696: pnt += length;
697: }
698:
699: break;
700: case GRACEFUL_RESTART:
701: /* +-------+-------+-------+-------+-------+-------+-------+-------+
702: * | Reserved | SA | RA | RR | 1
703: * +-------+-------+-------+-------+-------+-------+-------+-------+
704: * | Remaining Time | 2
705: * +---------------------------------------------------------------+
706: * | Restarting Neighbor ID (If known) | 0-8
707: * +---------------------------------------------------------------+
708: */
709: *found |= TLVFLAG_GRACEFUL_RESTART;
710: if (*expected & TLVFLAG_GRACEFUL_RESTART)
711: {
712: /* FIXME: make this work */
713: }
714: pnt += length;
715: break;
716:
717: default:
718: zlog_warn ("ISIS-TLV (%s): unsupported TLV type %d, length %d",
719: areatag, type, length);
720:
721: retval = ISIS_WARNING;
722: pnt += length;
723: break;
724: }
725: }
726:
727: return retval;
728: }
729:
730: int
731: add_tlv (u_char tag, u_char len, u_char * value, struct stream *stream)
732: {
733:
734: if (STREAM_SIZE (stream) - stream_get_endp (stream) < (unsigned) len + 2)
735: {
736: zlog_warn ("No room for TLV of type %d", tag);
737: return ISIS_WARNING;
738: }
739:
740: stream_putc (stream, tag); /* TAG */
741: stream_putc (stream, len); /* LENGTH */
742: stream_put (stream, value, (int) len); /* VALUE */
743:
744: #ifdef EXTREME_DEBUG
745: zlog_debug ("Added TLV %d len %d", tag, len);
746: #endif /* EXTREME DEBUG */
747: return ISIS_OK;
748: }
749:
750: int
751: tlv_add_area_addrs (struct list *area_addrs, struct stream *stream)
752: {
753: struct listnode *node;
754: struct area_addr *area_addr;
755:
756: u_char value[255];
757: u_char *pos = value;
758:
759: for (ALL_LIST_ELEMENTS_RO (area_addrs, node, area_addr))
760: {
761: if (pos - value + area_addr->addr_len > 255)
762: goto err;
763: *pos = area_addr->addr_len;
764: pos++;
765: memcpy (pos, area_addr->area_addr, (int) area_addr->addr_len);
766: pos += area_addr->addr_len;
767: }
768:
769: return add_tlv (AREA_ADDRESSES, pos - value, value, stream);
770:
771: err:
772: zlog_warn ("tlv_add_area_addrs(): TLV longer than 255");
773: return ISIS_WARNING;
774: }
775:
776: int
777: tlv_add_is_neighs (struct list *is_neighs, struct stream *stream)
778: {
779: struct listnode *node;
780: struct is_neigh *is_neigh;
781: u_char value[255];
782: u_char *pos = value;
783: int retval;
784:
785: *pos = 0; /*is_neigh->virtual; */
786: pos++;
787:
788: for (ALL_LIST_ELEMENTS_RO (is_neighs, node, is_neigh))
789: {
790: if (pos - value + IS_NEIGHBOURS_LEN > 255)
791: {
792: retval = add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
793: if (retval != ISIS_OK)
794: return retval;
795: pos = value;
796: }
797: *pos = is_neigh->metrics.metric_default;
798: pos++;
799: *pos = is_neigh->metrics.metric_delay;
800: pos++;
801: *pos = is_neigh->metrics.metric_expense;
802: pos++;
803: *pos = is_neigh->metrics.metric_error;
804: pos++;
805: memcpy (pos, is_neigh->neigh_id, ISIS_SYS_ID_LEN + 1);
806: pos += ISIS_SYS_ID_LEN + 1;
807: }
808:
809: return add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
810: }
811:
812: int
813: tlv_add_te_is_neighs (struct list *te_is_neighs, struct stream *stream)
814: {
815: struct listnode *node;
816: struct te_is_neigh *te_is_neigh;
817: u_char value[255];
818: u_char *pos = value;
819: int retval;
820:
821: for (ALL_LIST_ELEMENTS_RO (te_is_neighs, node, te_is_neigh))
822: {
823: /* FIXME: This will be wrong if we are going to add TE sub TLVs. */
824: if (pos - value + IS_NEIGHBOURS_LEN > 255)
825: {
826: retval = add_tlv (TE_IS_NEIGHBOURS, pos - value, value, stream);
827: if (retval != ISIS_OK)
828: return retval;
829: pos = value;
830: }
831:
832: memcpy (pos, te_is_neigh->neigh_id, ISIS_SYS_ID_LEN + 1);
833: pos += ISIS_SYS_ID_LEN + 1;
834: memcpy (pos, te_is_neigh->te_metric, 3);
835: pos += 3;
836: /* Sub TLVs length. */
837: *pos = 0;
838: pos++;
839: }
840:
841: return add_tlv (TE_IS_NEIGHBOURS, pos - value, value, stream);
842: }
843:
844: int
845: tlv_add_lan_neighs (struct list *lan_neighs, struct stream *stream)
846: {
847: struct listnode *node;
848: u_char *snpa;
849: u_char value[255];
850: u_char *pos = value;
851: int retval;
852:
853: for (ALL_LIST_ELEMENTS_RO (lan_neighs, node, snpa))
854: {
855: if (pos - value + ETH_ALEN > 255)
856: {
857: retval = add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
858: if (retval != ISIS_OK)
859: return retval;
860: pos = value;
861: }
862: memcpy (pos, snpa, ETH_ALEN);
863: pos += ETH_ALEN;
864: }
865:
866: return add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
867: }
868:
869: int
870: tlv_add_nlpid (struct nlpids *nlpids, struct stream *stream)
871: {
872: return add_tlv (PROTOCOLS_SUPPORTED, nlpids->count, nlpids->nlpids, stream);
873: }
874:
875: int
876: tlv_add_authinfo (char auth_type, char auth_len, u_char *auth_value,
877: struct stream *stream)
878: {
879: u_char value[255];
880: u_char *pos = value;
881: *pos++ = ISIS_PASSWD_TYPE_CLEARTXT;
882: memcpy (pos, auth_value, auth_len);
883:
884: return add_tlv (AUTH_INFO, auth_len + 1, value, stream);
885: }
886:
887: int
888: tlv_add_checksum (struct checksum *checksum, struct stream *stream)
889: {
890: u_char value[255];
891: u_char *pos = value;
892: return add_tlv (CHECKSUM, pos - value, value, stream);
893: }
894:
895: int
896: tlv_add_ip_addrs (struct list *ip_addrs, struct stream *stream)
897: {
898: struct listnode *node;
899: struct prefix_ipv4 *ipv4;
900: u_char value[255];
901: u_char *pos = value;
902: int retval;
903:
904: for (ALL_LIST_ELEMENTS_RO (ip_addrs, node, ipv4))
905: {
906: if (pos - value + IPV4_MAX_BYTELEN > 255)
907: {
908: retval = add_tlv (IPV4_ADDR, pos - value, value, stream);
909: if (retval != ISIS_OK)
910: return retval;
911: pos = value;
912: }
913: *(u_int32_t *) pos = ipv4->prefix.s_addr;
914: pos += IPV4_MAX_BYTELEN;
915: }
916:
917: return add_tlv (IPV4_ADDR, pos - value, value, stream);
918: }
919:
920: /* Used to add TLV containing just one IPv4 address - either IPv4 address TLV
921: * (in case of LSP) or TE router ID TLV. */
922: int
923: tlv_add_in_addr (struct in_addr *addr, struct stream *stream, u_char tag)
924: {
925: u_char value[255];
926: u_char *pos = value;
927:
928: memcpy (pos, addr, IPV4_MAX_BYTELEN);
929: pos += IPV4_MAX_BYTELEN;
930:
931: return add_tlv (tag, pos - value, value, stream);
932: }
933:
934: int
935: tlv_add_dynamic_hostname (struct hostname *hostname, struct stream *stream)
936: {
937: return add_tlv (DYNAMIC_HOSTNAME, hostname->namelen, hostname->name,
938: stream);
939: }
940:
941: int
942: tlv_add_lsp_entries (struct list *lsps, struct stream *stream)
943: {
944: struct listnode *node;
945: struct isis_lsp *lsp;
946: u_char value[255];
947: u_char *pos = value;
948: int retval;
949:
950: for (ALL_LIST_ELEMENTS_RO (lsps, node, lsp))
951: {
952: if (pos - value + LSP_ENTRIES_LEN > 255)
953: {
954: retval = add_tlv (LSP_ENTRIES, pos - value, value, stream);
955: if (retval != ISIS_OK)
956: return retval;
957: pos = value;
958: }
959: *((u_int16_t *) pos) = lsp->lsp_header->rem_lifetime;
960: pos += 2;
961: memcpy (pos, lsp->lsp_header->lsp_id, ISIS_SYS_ID_LEN + 2);
962: pos += ISIS_SYS_ID_LEN + 2;
963: *((u_int32_t *) pos) = lsp->lsp_header->seq_num;
964: pos += 4;
965: *((u_int16_t *) pos) = lsp->lsp_header->checksum;
966: pos += 2;
967: }
968:
969: return add_tlv (LSP_ENTRIES, pos - value, value, stream);
970: }
971:
972: int
973: tlv_add_ipv4_reachs (struct list *ipv4_reachs, struct stream *stream)
974: {
975: struct listnode *node;
976: struct ipv4_reachability *reach;
977: u_char value[255];
978: u_char *pos = value;
979: int retval;
980:
981: for (ALL_LIST_ELEMENTS_RO (ipv4_reachs, node, reach))
982: {
983: if (pos - value + IPV4_REACH_LEN > 255)
984: {
985: retval =
986: add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
987: if (retval != ISIS_OK)
988: return retval;
989: pos = value;
990: }
991: *pos = reach->metrics.metric_default;
992: pos++;
993: *pos = reach->metrics.metric_delay;
994: pos++;
995: *pos = reach->metrics.metric_expense;
996: pos++;
997: *pos = reach->metrics.metric_error;
998: pos++;
999: *(u_int32_t *) pos = reach->prefix.s_addr;
1000: pos += IPV4_MAX_BYTELEN;
1001: *(u_int32_t *) pos = reach->mask.s_addr;
1002: pos += IPV4_MAX_BYTELEN;
1003: }
1004:
1005:
1006: return add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
1007: }
1008:
1009: int
1010: tlv_add_te_ipv4_reachs (struct list *te_ipv4_reachs, struct stream *stream)
1011: {
1012: struct listnode *node;
1013: struct te_ipv4_reachability *te_reach;
1014: u_char value[255];
1015: u_char *pos = value;
1016: u_char prefix_size;
1017: int retval;
1018:
1019: for (ALL_LIST_ELEMENTS_RO (te_ipv4_reachs, node, te_reach))
1020: {
1021: prefix_size = ((((te_reach->control & 0x3F) - 1) >> 3) + 1);
1022:
1023: if (pos - value + (5 + prefix_size) > 255)
1024: {
1025: retval =
1026: add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
1027: if (retval != ISIS_OK)
1028: return retval;
1029: pos = value;
1030: }
1031: *(u_int32_t *) pos = te_reach->te_metric;
1032: pos += 4;
1033: *pos = te_reach->control;
1034: pos++;
1035: memcpy (pos, &te_reach->prefix_start, prefix_size);
1036: pos += prefix_size;
1037: }
1038:
1039: return add_tlv (TE_IPV4_REACHABILITY, pos - value, value, stream);
1040: }
1041:
1042: #ifdef HAVE_IPV6
1043: int
1044: tlv_add_ipv6_addrs (struct list *ipv6_addrs, struct stream *stream)
1045: {
1046: struct listnode *node;
1047: struct prefix_ipv6 *ipv6;
1048: u_char value[255];
1049: u_char *pos = value;
1050: int retval;
1051:
1052: for (ALL_LIST_ELEMENTS_RO (ipv6_addrs, node, ipv6))
1053: {
1054: if (pos - value + IPV6_MAX_BYTELEN > 255)
1055: {
1056: retval = add_tlv (IPV6_ADDR, pos - value, value, stream);
1057: if (retval != ISIS_OK)
1058: return retval;
1059: pos = value;
1060: }
1061: memcpy (pos, ipv6->prefix.s6_addr, IPV6_MAX_BYTELEN);
1062: pos += IPV6_MAX_BYTELEN;
1063: }
1064:
1065: return add_tlv (IPV6_ADDR, pos - value, value, stream);
1066: }
1067:
1068: int
1069: tlv_add_ipv6_reachs (struct list *ipv6_reachs, struct stream *stream)
1070: {
1071: struct listnode *node;
1072: struct ipv6_reachability *ip6reach;
1073: u_char value[255];
1074: u_char *pos = value;
1075: int retval, prefix_octets;
1076:
1077: for (ALL_LIST_ELEMENTS_RO (ipv6_reachs, node, ip6reach))
1078: {
1079: if (pos - value + IPV6_MAX_BYTELEN + 6 > 255)
1080: {
1081: retval = add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
1082: if (retval != ISIS_OK)
1083: return retval;
1084: pos = value;
1085: }
1086: *(uint32_t *) pos = ip6reach->metric;
1087: pos += 4;
1088: *pos = ip6reach->control_info;
1089: pos++;
1090: prefix_octets = ((ip6reach->prefix_len + 7) / 8);
1091: *pos = ip6reach->prefix_len;
1092: pos++;
1093: memcpy (pos, ip6reach->prefix, prefix_octets);
1094: pos += prefix_octets;
1095: }
1096:
1097: return add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
1098: }
1099: #endif /* HAVE_IPV6 */
1100:
1101: int
1102: tlv_add_padding (struct stream *stream)
1103: {
1104: int fullpads, i, left;
1105:
1106: /*
1107: * How many times can we add full padding ?
1108: */
1109: fullpads = (STREAM_SIZE (stream) - stream_get_endp (stream)) / 257;
1110: for (i = 0; i < fullpads; i++)
1111: {
1112: if (!stream_putc (stream, (u_char) PADDING)) /* TAG */
1113: goto err;
1114: if (!stream_putc (stream, (u_char) 255)) /* LENGHT */
1115: goto err;
1116: stream_put (stream, NULL, 255); /* zero padding */
1117: }
1118:
1119: left = STREAM_SIZE (stream) - stream_get_endp (stream);
1120:
1121: if (left < 2)
1122: return ISIS_OK;
1123:
1124: if (left == 2)
1125: {
1126: stream_putc (stream, PADDING);
1127: stream_putc (stream, 0);
1128: return ISIS_OK;
1129: }
1130:
1131: stream_putc (stream, PADDING);
1132: stream_putc (stream, left - 2);
1133: stream_put (stream, NULL, left-2);
1134:
1135: return ISIS_OK;
1136:
1137: err:
1138: zlog_warn ("tlv_add_padding(): no room for tlv");
1139: return ISIS_WARNING;
1140: }