More updates from Hannes Gredler.
[obnox/wireshark/wip.git] / packet-isis-lsp.c
1 /* packet-isis-lsp.c
2  * Routines for decoding isis lsp packets and their CLVs
3  *
4  * $Id: packet-isis-lsp.c,v 1.15 2001/06/07 19:13:35 guy Exp $
5  * Stuart Stanley <stuarts@mxmail.net>
6  *
7  * Ethereal - Network traffic analyzer
8  * By Gerald Combs <gerald@zing.org>
9  * Copyright 1998 Gerald Combs
10  *
11  * 
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  * 
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  * 
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
25  *
26  *
27  */
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #ifdef HAVE_SYS_TYPES_H
34 # include <sys/types.h>
35 #endif
36
37 #include <stdio.h>
38 #include <string.h>
39 #include <glib.h>
40
41 #ifdef HAVE_NET_INET_H
42 #include <net/inet.h>
43 #endif
44
45 #include "packet.h"
46 #include "packet-osi.h"
47 #include "packet-ipv6.h"
48 #include "packet-isis.h"
49 #include "packet-isis-clv.h"
50 #include "packet-isis-lsp.h"
51 #include "resolv.h"
52
53 /* lsp packets */
54 static int proto_isis_lsp = -1;
55 static int hf_isis_lsp_pdu_length = -1;
56 static int hf_isis_lsp_remaining_life = -1;
57 static int hf_isis_lsp_sequence_number = -1;
58 static int hf_isis_lsp_checksum = -1;
59 static int hf_isis_lsp_clv_ipv4_int_addr = -1;
60 static int hf_isis_lsp_clv_ipv6_int_addr = -1;
61 static int hf_isis_lsp_clv_te_router_id = -1;
62
63 static gint ett_isis_lsp = -1;
64 static gint ett_isis_lsp_clv_area_addr = -1;
65 static gint ett_isis_lsp_clv_is_neighbors = -1;
66 static gint ett_isis_lsp_clv_ext_is_reachability = -1; /* CLV 22 */
67         static gint ett_isis_lsp_part_of_clv_ext_is_reachability = -1;
68         static gint ett_isis_lsp_subclv_admin_group = -1;
69         static gint ett_isis_lsp_subclv_unrsv_bw = -1;
70 static gint ett_isis_lsp_clv_unknown = -1;
71 static gint ett_isis_lsp_clv_partition_dis = -1;
72 static gint ett_isis_lsp_clv_prefix_neighbors = -1;
73 static gint ett_isis_lsp_clv_nlpid = -1;
74 static gint ett_isis_lsp_clv_hostname = -1;
75 static gint ett_isis_lsp_clv_te_router_id = -1;
76 static gint ett_isis_lsp_clv_auth = -1;
77 static gint ett_isis_lsp_clv_ipv4_int_addr = -1;
78 static gint ett_isis_lsp_clv_ipv6_int_addr = -1; /* CLV 232 */
79 static gint ett_isis_lsp_clv_ip_reachability = -1;
80 static gint ett_isis_lsp_clv_ext_ip_reachability = -1; /* CLV 135 */
81         static gint ett_isis_lsp_part_of_clv_ext_ip_reachability = -1;
82 static gint ett_isis_lsp_clv_ipv6_reachability = -1; /* CLV 236 */
83         static gint ett_isis_lsp_part_of_clv_ipv6_reachability = -1;
84
85 static const char *isis_lsp_attached_bits[] = {
86         "error", "expense", "delay", "default" };
87
88 static const value_string isis_lsp_istype_vals[] = {
89         { ISIS_LSP_TYPE_UNUSED0,        "Unused 0x0 (invalid)"},
90         { ISIS_LSP_TYPE_LEVEL_1,        "Level 1 IS"},
91         { ISIS_LSP_TYPE_UNUSED2,        "Unused 0x2 (invalid)"},
92         { ISIS_LSP_TYPE_LEVEL_2,        "Level 2 IS"},
93         { 0, NULL } };
94
95 /* 
96  * Predclare dissectors for use in clv dissection.
97  */
98 static void dissect_lsp_area_address_clv(const u_char *pd, int offset, 
99                 guint length, int id_length, frame_data *fd, proto_tree *tree);
100 static void dissect_lsp_l1_is_neighbors_clv(const u_char *pd, int offset, 
101                 guint length, int id_length, frame_data *fd, proto_tree *tree);
102 static void dissect_lsp_l1_es_neighbors_clv(const u_char *pd, int offset, 
103                 guint length, int id_length, frame_data *fd, proto_tree *tree);
104 static void dissect_lsp_l2_is_neighbors_clv(const u_char *pd, int offset, 
105                 guint length, int id_length, frame_data *fd, proto_tree *tree);
106 static void dissect_lsp_ext_is_reachability_clv(const u_char *pd, int offset, 
107                 guint length, int id_length, frame_data *fd, proto_tree *tree);
108 static void dissect_lsp_partition_dis_clv(const u_char *pd, int offset, 
109                 guint length, int id_length, frame_data *fd, proto_tree *tree);
110 static void dissect_lsp_prefix_neighbors_clv(const u_char *pd, int offset, 
111                 guint length, int id_length, frame_data *fd, proto_tree *tree);
112 static void dissect_lsp_ip_reachability_clv(const u_char *pd, int offset,
113                 guint length, int id_length, frame_data *fd, proto_tree *tree);
114 static void dissect_lsp_ext_ip_reachability_clv(const u_char *pd, int offset,
115                 guint length, int id_length, frame_data *fd, proto_tree *tree);
116 static void dissect_lsp_ipv6_reachability_clv(const u_char *pd, int offset,
117                 guint length, int id_length, frame_data *fd, proto_tree *tree);
118 static void dissect_lsp_nlpid_clv(const u_char *pd, int offset,
119                 guint length, int id_length, frame_data *fd, proto_tree *tree);
120 static void dissect_lsp_hostname_clv(const u_char *pd, int offset,
121                 guint length, int id_length, frame_data *fd, proto_tree *tree);
122 static void dissect_lsp_te_router_id_clv(const u_char *pd, int offset,
123                 guint length, int id_length, frame_data *fd, proto_tree *tree);
124 static void dissect_lsp_ip_int_addr_clv(const u_char *pd, int offset,
125                 guint length, int id_length, frame_data *fd, proto_tree *tree);
126 static void dissect_lsp_ipv6_int_addr_clv(const u_char *pd, int offset,
127                 guint length, int id_length, frame_data *fd, proto_tree *tree);
128 static void dissect_lsp_l1_auth_clv(const u_char *pd, int offset,
129                 guint length, int id_length, frame_data *fd, proto_tree *tree);
130 static void dissect_lsp_l2_auth_clv(const u_char *pd, int offset,
131                 guint length, int id_length, frame_data *fd, proto_tree *tree);
132
133 static const isis_clv_handle_t clv_l1_lsp_opts[] = {
134         {
135                 ISIS_CLV_L1_LSP_AREA_ADDRESS,
136                 "Area address(es)",
137                 &ett_isis_lsp_clv_area_addr,
138                 dissect_lsp_area_address_clv
139         },
140         {
141                 ISIS_CLV_L1_LSP_IS_NEIGHBORS,
142                 "IS Neighbor(s)",
143                 &ett_isis_lsp_clv_is_neighbors,
144                 dissect_lsp_l1_is_neighbors_clv
145         },
146         {
147                 ISIS_CLV_L1_LSP_ES_NEIGHBORS,
148                 "ES Neighbor(s)",
149                 &ett_isis_lsp_clv_is_neighbors,
150                 dissect_lsp_l1_es_neighbors_clv
151         },
152         {
153                 ISIS_CLV_L1_LSP_EXT_IS_REACHABLE,
154                 "Extended IS reachability",
155                 &ett_isis_lsp_clv_ext_is_reachability,
156                 dissect_lsp_ext_is_reachability_clv
157         },
158         {
159                 ISIS_CLV_L1_LSP_IP_INT_REACHABLE,
160                 "IP Internal reachability",
161                 &ett_isis_lsp_clv_ip_reachability,
162                 dissect_lsp_ip_reachability_clv
163         },
164         {
165                 ISIS_CLV_L1_LSP_EXT_IP_REACHABLE,
166                 "Extended IP Reachability",
167                 &ett_isis_lsp_clv_ext_ip_reachability,
168                 dissect_lsp_ext_ip_reachability_clv
169         },
170         {
171                 ISIS_CLV_L1_LSP_IPv6_REACHABLE,
172                 "IPv6 reachability",
173                 &ett_isis_lsp_clv_ipv6_reachability,
174                 dissect_lsp_ipv6_reachability_clv
175         },
176         {
177                 ISIS_CLV_L1_LSP_NLPID,
178                 "Protocols supported",
179                 &ett_isis_lsp_clv_nlpid,
180                 dissect_lsp_nlpid_clv
181         },
182         {
183                 ISIS_CLV_L1_LSP_HOSTNAME,
184                 "Hostname",
185                 &ett_isis_lsp_clv_hostname,
186                 dissect_lsp_hostname_clv
187         },
188         {
189                 ISIS_CLV_L1_LSP_TE_ROUTER_ID,
190                 "Traffic Engineering Router ID",
191                 &ett_isis_lsp_clv_te_router_id,
192                 dissect_lsp_te_router_id_clv
193         },
194         {
195                 ISIS_CLV_L1_LSP_IP_INTERFACE_ADDR,
196                 "IP Interface address(es)",
197                 &ett_isis_lsp_clv_ipv4_int_addr,
198                 dissect_lsp_ip_int_addr_clv
199         },
200         {
201                 ISIS_CLV_L1_LSP_IPv6_INTERFACE_ADDR,
202                 "IPv6 Interface address(es)",
203                 &ett_isis_lsp_clv_ipv6_int_addr,
204                 dissect_lsp_ipv6_int_addr_clv
205         },
206         {
207                 ISIS_CLV_L1_LSP_AUTHENTICATION_NS,
208                 "Authentication(non-spec)",
209                 &ett_isis_lsp_clv_auth,
210                 dissect_lsp_l1_auth_clv
211         },
212         {
213                 ISIS_CLV_L1_LSP_AUTHENTICATION,
214                 "Authentication",
215                 &ett_isis_lsp_clv_auth,
216                 dissect_lsp_l1_auth_clv
217         },
218         {
219                 0,
220                 "",
221                 NULL,
222                 NULL
223         }
224 };
225
226 static const isis_clv_handle_t clv_l2_lsp_opts[] = {
227         {
228                 ISIS_CLV_L1_LSP_AREA_ADDRESS,
229                 "Area address(es)",
230                 &ett_isis_lsp_clv_area_addr,
231                 dissect_lsp_area_address_clv
232         },
233         {
234                 ISIS_CLV_L2_LSP_IS_NEIGHBORS,
235                 "IS Neighbor(s)",
236                 &ett_isis_lsp_clv_is_neighbors,
237                 dissect_lsp_l2_is_neighbors_clv
238         },
239         {
240                 ISIS_CLV_L2_LSP_EXT_IS_REACHABLE,
241                 "Extended IS reachability",
242                 &ett_isis_lsp_clv_ext_is_reachability,
243                 dissect_lsp_ext_is_reachability_clv
244         },
245         {
246                 ISIS_CLV_L2_LSP_PARTITION_DIS,
247                 "Parition Designated Level 2 IS",
248                 &ett_isis_lsp_clv_partition_dis,
249                 dissect_lsp_partition_dis_clv
250         },
251         {
252                 ISIS_CLV_L2_LSP_PREFIX_NEIGHBORS,
253                 "Prefix neighbors",
254                 &ett_isis_lsp_clv_prefix_neighbors,
255                 dissect_lsp_prefix_neighbors_clv
256         },
257         {
258                 ISIS_CLV_L2_LSP_IP_INT_REACHABLE,
259                 "IP Internal reachability",
260                 &ett_isis_lsp_clv_ip_reachability,
261                 dissect_lsp_ip_reachability_clv
262         },
263         {
264                 ISIS_CLV_L2_LSP_NLPID,
265                 "Protocols supported",
266                 &ett_isis_lsp_clv_nlpid,
267                 dissect_lsp_nlpid_clv
268         },
269         {
270                 ISIS_CLV_L2_LSP_HOSTNAME,
271                 "Hostname",
272                 &ett_isis_lsp_clv_hostname,
273                 dissect_lsp_hostname_clv
274         },
275         {
276                 ISIS_CLV_L2_LSP_TE_ROUTER_ID,
277                 "Traffic Engineering Router ID",
278                 &ett_isis_lsp_clv_te_router_id,
279                 dissect_lsp_te_router_id_clv
280         },
281         {
282                 ISIS_CLV_L2_LSP_IP_EXT_REACHABLE,
283                 "IP external reachability",
284                 &ett_isis_lsp_clv_ip_reachability,
285                 dissect_lsp_ip_reachability_clv
286         },
287         {
288                 ISIS_CLV_L2_LSP_EXT_IP_REACHABLE,
289                 "Extended IP Reachability",
290                 &ett_isis_lsp_clv_ext_ip_reachability,
291                 dissect_lsp_ext_ip_reachability_clv
292         },
293         {
294                 ISIS_CLV_L2_LSP_IPv6_REACHABLE,
295                 "IPv6 reachability",
296                 &ett_isis_lsp_clv_ipv6_reachability,
297                 dissect_lsp_ipv6_reachability_clv
298         },
299         {
300                 ISIS_CLV_L2_LSP_IP_INTERFACE_ADDR,
301                 "IP Interface address(es)",
302                 &ett_isis_lsp_clv_ipv4_int_addr,
303                 dissect_lsp_ip_int_addr_clv
304         },
305         {
306                 ISIS_CLV_L2_LSP_IPv6_INTERFACE_ADDR,
307                 "IPv6 Interface address(es)",
308                 &ett_isis_lsp_clv_ipv6_int_addr,
309                 dissect_lsp_ipv6_int_addr_clv
310         },
311         {
312                 ISIS_CLV_L2_LSP_AUTHENTICATION_NS,
313                 "Authentication(non spec)",
314                 &ett_isis_lsp_clv_auth,
315                 dissect_lsp_l2_auth_clv
316         },
317         {
318                 ISIS_CLV_L2_LSP_AUTHENTICATION,
319                 "Authentication",
320                 &ett_isis_lsp_clv_auth,
321                 dissect_lsp_l2_auth_clv
322         },
323         {
324                 0,
325                 "",
326                 NULL,
327                 NULL
328         }
329 };
330
331
332 /*
333  * Name: dissect_metric()
334  * 
335  * Description:
336  *      Display a metric prefix portion.  ISIS has the concept of multple
337  *      metric per prefix (default, delay, expense, and error).  This
338  *      routine assists other dissectors by adding a single one of
339  *      these to the display tree..  
340  *
341  *      The 8th(msbit) bit in the metric octet is the "supported" bit.  The
342  *              "default" support is required, so we support a "force_supported"
343  *              flag that tells us that it MUST be zero (zero==supported,
344  *              so it really should be a "not supported" in the boolean sense)
345  *              and to display a protocol failure accordingly.  Notably,
346  *              Cisco IOS 12(6) blows this!
347  *      The 7th bit must be zero (reserved).
348  *
349  * Input:
350  *      u_char * : packet data
351  *      int : offset into packet data where we are.
352  *      guint : length of clv we are decoding
353  *      frame_data * : frame data (complete frame)
354  *      proto_tree * : protocol display tree to fill out.  May be NULL
355  *      int : force supported.  True is the supported bit MUST be zero.
356  * 
357  * Output:
358  *      void, but we will add to proto tree if !NULL.
359  */
360 static void 
361 dissect_metric(proto_tree *tree, int offset, guint8 value, 
362                 char *pstr, int force_supported ) {
363         int s;
364
365         if ( !tree ) return;
366
367         s = ISIS_LSP_CLV_METRIC_SUPPORTED(value);
368         proto_tree_add_text ( tree, NullTVB, offset, 1, 
369                 "%s Metric: %s%s %s%d:%d", pstr,
370                 s ? "Not supported" : "Supported",
371                 (s && force_supported) ? "(but is required to be)":"",
372                 ISIS_LSP_CLV_METRIC_RESERVED(value) ? "(reserved bit != 0)":"",
373                 ISIS_LSP_CLV_METRIC_VALUE(value), value );
374 }
375         
376
377 /*
378  * Name: dissect_lsp_ip_reachabillity_clv()
379  *
380  * Description:
381  *      Decode an IP reachability CLV.  This can be either internal or
382  *      external (the clv format does not change and which type we are
383  *      displaying is put there by the dispatcher).  All of these
384  *      are a metric block followed by an IP addr and mask.
385  *
386  * Input:
387  *      u_char * : packet data
388  *      int : current offset into packet data
389  *      guint : length of this clv
390  *      int : length of IDs in packet.
391  *      frame_data * : frame data
392  *      proto_tree * : proto tree to build on (may be null)
393  *
394  * Output:
395  *      void, will modify proto_tree if not null.
396  */
397 static void 
398 dissect_lsp_ip_reachability_clv(const u_char *pd, int offset, 
399                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
400         proto_item      *ti;
401         proto_tree      *ntree = NULL;
402         guint32         src, mask;
403
404         while ( length > 0 ) {
405                 if (length<12) {
406                         isis_dissect_unknown(offset, length, tree, fd,
407                                 "short IP reachability (%d vs 12)", length );
408                         return;
409                 }
410                 /* 
411                  * Gotta build a sub-tree for all our pieces
412                  */
413                 if ( tree ) {
414                         memcpy(&src, &pd[offset+4], 4);
415                         memcpy(&mask, &pd[offset+8], 4);
416                         ti = proto_tree_add_text ( tree, NullTVB, offset, 12, 
417                                 "IPv4 prefix: %s : %s",
418                                 ip_to_str((guint8*)&src),
419                                 ip_to_str((guint8*)&mask) );
420                         ntree = proto_item_add_subtree(ti, 
421                                 ett_isis_lsp_clv_ip_reachability);
422
423                         proto_tree_add_text (ntree, NullTVB, offset, 1,
424                                 "Default Metric: %d, %s, Distribution: %s",
425                                 ISIS_LSP_CLV_METRIC_VALUE(pd[offset]),
426                                 ISIS_LSP_CLV_METRIC_IE(pd[offset]) ? "External" : "Internal",
427                                 ISIS_LSP_CLV_METRIC_UPDOWN(pd[offset]) ? "down" : "up");
428
429
430                         if (ISIS_LSP_CLV_METRIC_SUPPORTED(pd[offset+1])) {
431                           proto_tree_add_text (ntree, NullTVB, offset+1, 1, "Delay Metric:   Not supported");
432                                                } else {
433                           proto_tree_add_text (ntree, NullTVB, offset+1, 1, "Delay Metric:   %d, %s",
434                                                ISIS_LSP_CLV_METRIC_VALUE(pd[offset+1]),
435                                                ISIS_LSP_CLV_METRIC_IE(pd[offset+1]) ? "External" : "Internal");
436                                                }
437
438                         if (ISIS_LSP_CLV_METRIC_SUPPORTED(pd[offset+2])) {
439                           proto_tree_add_text (ntree, NullTVB, offset+2, 1, "Expense Metric: Not supported");
440                         } else {
441                           proto_tree_add_text (ntree, NullTVB, offset+2, 1, "Exense Metric:  %d, %s",
442                                                ISIS_LSP_CLV_METRIC_VALUE(pd[offset+2]),
443                                                ISIS_LSP_CLV_METRIC_IE(pd[offset+2]) ? "External" : "Internal");
444                         }
445
446                         if (ISIS_LSP_CLV_METRIC_SUPPORTED(pd[offset+3])) {
447                           proto_tree_add_text (ntree, NullTVB, offset+3, 1, "Error Metric:   Not supported");
448                         } else {
449                           proto_tree_add_text (ntree, NullTVB, offset+3, 1, "Error Metric:   %d, %s",
450                                                ISIS_LSP_CLV_METRIC_VALUE(pd[offset+3]),
451                                                ISIS_LSP_CLV_METRIC_IE(pd[offset+3]) ? "External" : "Internal");
452                         }
453                 }
454                 offset += 12;
455                 length -= 12;
456         }
457 }
458
459 /*
460  * Name: dissect_lsp_ext_ip_reachability_clv()
461  *
462  * Description: Decode an Extended IP Reachability CLV - code 135.
463  *
464  *   The extended IP reachability TLV is an extended version
465  *   of the IP reachability TLVs (codes 128 and 130). It encodes 
466  *   the metric as a 32-bit unsigned interger and allows to add 
467  *   sub-CLV(s).
468  *
469  * Input:
470  *   u_char * : packet data
471  *   int : current offset into packet data
472  *   guint : length of this clv
473  *   int : length of IDs in packet.
474  *   frame_data * : frame data
475  *   proto_tree * : proto tree to build on (may be null)
476  *
477  * Output:
478  *   void, will modify proto_tree if not null.
479  */
480 static void 
481 dissect_lsp_ext_ip_reachability_clv(const u_char *pd, int offset, 
482                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
483         proto_item *pi = NULL;
484         proto_tree *subtree = NULL;
485         guint8     ctrl_info;
486         guint8     bit_length, byte_length;
487         guint8     prefix [4];
488         guint8     len;
489
490         if (!tree) return;
491
492         while (length > 0) {
493                 memset (prefix, 0, 4);
494                 ctrl_info = pd[offset+4];
495                 bit_length = ctrl_info & 0x3f;
496                 byte_length = (bit_length + 7) / 8;
497                 memcpy (prefix, &pd[offset+5], byte_length);
498                 pi = proto_tree_add_text (tree, NullTVB, offset, 0,
499                         "IPv4 prefix: %s /%d", 
500                         ip_to_str (prefix),
501                         bit_length );
502                 subtree = proto_item_add_subtree (pi, 
503                         ett_isis_lsp_part_of_clv_ext_ip_reachability);
504
505                 proto_tree_add_text (subtree, NullTVB, offset, 4,
506                         "Metric: %d", pntohl (&pd[offset]) );
507
508                 proto_tree_add_text (subtree, NullTVB, offset+4, 1,
509                         "Distribution: %s",
510                         ((ctrl_info & 0x80) == 0) ? "up" : "down" );
511
512                 proto_tree_add_text (subtree, NullTVB, offset+4, 1,
513                         "Sub_CLV(s): %s",
514                         ((ctrl_info & 0x40) == 0) ? "no" : "yes" );
515
516                 len = 5 + byte_length;
517                 if ((ctrl_info & 0x40) != 0)
518                         len += 1 + pd[offset+len] ;
519                 proto_item_set_len (pi, len);
520                 offset += len;
521                 length -= len;
522         }
523 }
524
525 /*
526  * Name: dissect_lsp_ipv6_reachability_clv()
527  *
528  * Description: Decode an IPv6 reachability CLV - code 236.
529  *
530  * Input:
531  *   u_char * : packet data
532  *   int : current offset into packet data
533  *   guint : length of this clv
534  *   int : length of IDs in packet.
535  *   frame_data * : frame data
536  *   proto_tree * : proto tree to build on (may be null)
537  *
538  * Output:
539  *   void, will modify proto_tree if not null.
540  */
541 static void 
542 dissect_lsp_ipv6_reachability_clv(const u_char *pd, int offset, 
543                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
544         proto_item        *ti;
545         proto_tree        *ntree = NULL;
546         guint8            bit_length, byte_length;
547         struct e_in6_addr prefix;
548         guint8            ctrl_info;
549         guint32           metric;
550         guint8            len;
551
552         if (!tree) return;
553         
554         memset (prefix.s6_addr, 0, 16);
555
556         while (length > 0) {
557                 bit_length = pd[offset+5];
558                 byte_length = (bit_length + 7) / 8;
559                 memcpy (prefix.s6_addr, &pd[offset+6], byte_length);
560                 ti = proto_tree_add_text (tree, NullTVB, offset, 0,
561                         "IP prefix: %s /%d", 
562                         ip6_to_str (&prefix),
563                         bit_length );
564                 ntree = proto_item_add_subtree (ti, ett_isis_lsp_part_of_clv_ipv6_reachability);
565
566                 metric = pntohl (&pd[offset]);
567                 proto_tree_add_text (ntree, NullTVB, offset, 4,
568                         "Metric: %d", metric);
569
570                 ctrl_info = pd[offset+4];
571                 proto_tree_add_text (ntree, NullTVB, offset+4, 1,
572                         "Distribution: %s, %s",
573                         ((ctrl_info & 0x80) == 0) ? "up" : "down",
574                         ((ctrl_info & 0x40) == 0) ? "internal" : "external" );
575
576                 proto_tree_add_text (ntree, NullTVB, offset+4, 1,
577                         "Reserved bits: 0x%x",
578                         (ctrl_info & 0x1f) );
579                 proto_tree_add_text (ntree, NullTVB, offset+4, 1,
580                         "Sub_CLV(s): %s",
581                         ((ctrl_info & 0x20) == 0) ? "no" : "yes" );
582
583                 len = 6 + byte_length;
584                 if ((ctrl_info & 0x20) != 0)
585                         len += 1 + pd[offset+len] ;
586                 proto_item_set_len (ti, len);
587                 offset += len;
588                 length -= len;
589         }
590 }
591
592 /*
593  * Name: dissect_lsp_nlpid_clv()
594  *
595  * Description:
596  *      Decode for a lsp packets NLPID clv.  Calls into the
597  *      clv common one.
598  *
599  * Input:
600  *      u_char * : packet data
601  *      int : current offset into packet data
602  *      guint : length of this clv
603  *      int : length of IDs in packet.
604  *      frame_data * : frame data
605  *      proto_tree * : proto tree to build on (may be null)
606  *
607  * Output:
608  *      void, will modify proto_tree if not null.
609  */
610 static void 
611 dissect_lsp_nlpid_clv(const u_char *pd, int offset, 
612                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
613         isis_dissect_nlpid_clv(pd, offset, length, fd, tree );
614 }
615
616 /*
617  * Name: dissect_lsp_hostname_clv()
618  *
619  * Description:
620  *      Decode for a lsp packets hostname clv.  Calls into the
621  *      clv common one.
622  *
623  * Input:
624  *      u_char * : packet data
625  *      int : current offset into packet data
626  *      guint : length of this clv
627  *      int : length of IDs in packet.
628  *      frame_data * : frame data
629  *      proto_tree * : proto tree to build on (may be null)
630  *
631  * Output:
632  *      void, will modify proto_tree if not null.
633  */
634 static void 
635 dissect_lsp_hostname_clv(const u_char *pd, int offset, 
636                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
637         isis_dissect_hostname_clv(pd, offset, length, fd, tree );
638 }
639
640
641 /*
642  * Name: dissect_lsp_te_router_id_clv()
643  *
644  * Description:
645  *      Decode for a lsp packets Traffic Engineering ID clv.  Calls into the
646  *      clv common one.
647  *
648  * Input:
649  *      u_char * : packet data
650  *      int : current offset into packet data
651  *      guint : length of this clv
652  *      int : length of IDs in packet.
653  *      frame_data * : frame data
654  *      proto_tree * : proto tree to build on (may be null)
655  *
656  * Output:
657  *      void, will modify proto_tree if not null.
658  */
659 static void
660 dissect_lsp_te_router_id_clv(const u_char *pd, int offset,
661                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
662         isis_dissect_te_router_id_clv(pd, offset, length, fd, tree,
663                 hf_isis_lsp_clv_te_router_id );
664 }
665
666
667
668
669 /*
670  * Name: dissect_lsp_ip_int_addr_clv()
671  *
672  * Description:
673  *      Decode for a lsp packets ip interface addr clv.  Calls into the
674  *      clv common one.
675  *
676  * Input:
677  *      u_char * : packet data
678  *      int : current offset into packet data
679  *      guint : length of this clv
680  *      int : length of IDs in packet.
681  *      frame_data * : frame data
682  *      proto_tree * : proto tree to build on (may be null)
683  *
684  * Output:
685  *      void, will modify proto_tree if not null.
686  */
687 static void 
688 dissect_lsp_ip_int_addr_clv(const u_char *pd, int offset,
689                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
690         isis_dissect_ip_int_clv(pd, offset, length, fd, tree, 
691                 hf_isis_lsp_clv_ipv4_int_addr );
692 }
693
694 /*
695  * Name: dissect_lsp_ipv6_int_addr_clv()
696  *
697  * Description: Decode an IPv6 interface addr CLV - code 232.
698  *
699  *   Calls into the clv common one.
700  *
701  * Input:
702  *   u_char * : packet data
703  *   int : current offset into packet data
704  *   guint : length of this clv
705  *   int : length of IDs in packet.
706  *   frame_data * : frame data
707  *   proto_tree * : proto tree to build on (may be null)
708  *
709  * Output:
710  *   void, will modify proto_tree if not null.
711  */
712 static void 
713 dissect_lsp_ipv6_int_addr_clv(const u_char *pd, int offset, 
714                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
715         isis_dissect_ipv6_int_clv(pd, offset, length, fd, tree, 
716                 hf_isis_lsp_clv_ipv6_int_addr );
717 }
718
719 /*
720  * Name: dissect_lsp_L1_auth_clv()
721  *
722  * Description:
723  *      Decode for a lsp packets authenticaion clv.  Calls into the
724  *      clv common one.  An auth inside a L1 LSP is a per area password
725  *
726  * Input:
727  *      u_char * : packet data
728  *      int : current offset into packet data
729  *      guint : length of this clv
730  *      int : length of IDs in packet.
731  *      frame_data * : frame data
732  *      proto_tree * : proto tree to build on (may be null)
733  *
734  * Output:
735  *      void, will modify proto_tree if not null.
736  */
737 static void 
738 dissect_lsp_l1_auth_clv(const u_char *pd, int offset, 
739                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
740         isis_dissect_authentication_clv(pd, offset, length, fd, tree, 
741                 "Per area authentication" );
742 }
743
744 /*
745  * Name: dissect_lsp_L2_auth_clv()
746  *
747  * Description:
748  *      Decode for a lsp packets authenticaion clv.  Calls into the
749  *      clv common one.  An auth inside a L2 LSP is a per domain password
750  *
751  * Input:
752  *      u_char * : packet data
753  *      int : current offset into packet data
754  *      guint : length of this clv
755  *      int : length of IDs in packet.
756  *      frame_data * : frame data
757  *      proto_tree * : proto tree to build on (may be null)
758  *
759  * Output:
760  *      void, will modify proto_tree if not null.
761  */
762 static void 
763 dissect_lsp_l2_auth_clv(const u_char *pd, int offset, 
764                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
765         isis_dissect_authentication_clv(pd, offset, length, fd, tree, 
766                 "Per domain authentication" );
767 }
768
769 /*
770  * Name: dissect_lsp_area_address_clv()
771  *
772  * Description:
773  *      Decode for a lsp packet's area address clv.  Call into clv common
774  *      one.
775  *
776  * Input:
777  *      u_char * : packet data
778  *      int : offset into packet data where we are.
779  *      guint : length of clv we are decoding
780  *      int : length of IDs in packet.
781  *      frame_data * : frame data (complete frame)
782  *      proto_tree * : protocol display tree to fill out.  May be NULL
783  *
784  * Output:
785  *      void, but we will add to proto tree if !NULL.
786  */
787 static void 
788 dissect_lsp_area_address_clv(const u_char *pd, int offset, 
789                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
790         isis_dissect_area_address_clv(pd, offset, length, fd, tree );
791 }
792
793 /*
794  * Name: dissect_lsp_eis_neighbors_clv_inner()
795  *
796  * Description:
797  *      Real work horse for showing neighbors.  This means we decode the
798  *      first octet as either virtual/!virtual (if show_virtual param is
799  *      set), or as a must == 0 reserved value.
800  *
801  *      Once past that, we decode n neighbor elements.  Each neighbor
802  *      is comprised of a metric block (is dissect_metric) and the
803  *      addresses.
804  *
805  * Input:
806  *      u_char * : packet data
807  *      int : offset into packet data where we are.
808  *      guint : length of clv we are decoding
809  *      int : length of IDs in packet.
810  *      frame_data * : frame data (complete frame)
811  *      proto_tree * : protocol display tree to fill out.  May be NULL
812  *      int : set to decode first octet as virtual vs reserved == 0
813  *      int : set to indicate EIS instead of IS (6 octet per addr instead of 7)
814  *
815  * Output:
816  *      void, but we will add to proto tree if !NULL.
817  */
818 static void 
819 dissect_lsp_eis_neighbors_clv_inner(const u_char *pd, int offset, 
820                 guint length, int id_length, frame_data *fd, proto_tree *tree,
821                 int show_virtual, int is_eis) {
822         proto_item      *ti;
823         proto_tree      *ntree = NULL;
824         int             tlen;
825
826         if (!is_eis) {
827                 id_length++;    /* IDs are one octet longer in IS neighbours */
828                 if ( tree ) {
829                         if ( show_virtual ) {
830                                 /* virtual path flag */
831                                 proto_tree_add_text ( tree, NullTVB, offset, 1, 
832                                    &pd[offset] ? "IsNotVirtual" : "IsVirtual" );
833                         } else {
834                                 proto_tree_add_text ( tree, NullTVB, offset, 1, 
835                                         "Reserved value 0x%02x, must == 0",
836                                         pd[offset]  );
837                         }
838                 }
839                 offset++;
840                 length--;
841         }
842         tlen = 4 + id_length;
843
844         while ( length > 0 ) {
845                 if (length<tlen) {
846                         isis_dissect_unknown(offset, length, tree, fd,
847                                 "short E/IS reachability (%d vs %d)", length,
848                                 tlen );
849                         return;
850                 }
851                 /* 
852                  * Gotta build a sub-tree for all our pieces
853                  */
854                 if ( tree ) {
855                         if ( is_eis ) {
856                                 ti = proto_tree_add_text ( tree, NullTVB, offset, tlen, 
857                                         "ES Neighbor: %s",
858                                 print_system_id( pd + offset + 4, id_length ) );
859                         } else {
860                                 ti = proto_tree_add_text ( tree, NullTVB, offset, tlen, 
861                                         "IS Neighbor:  %s",
862                                 print_system_id( pd + offset + 4, id_length ) );
863                         }
864                         ntree = proto_item_add_subtree(ti, 
865                                 ett_isis_lsp_clv_is_neighbors);
866
867
868
869                         proto_tree_add_text (ntree, NullTVB, offset, 1,
870                                              "Default Metric: %d, %s",
871                                              ISIS_LSP_CLV_METRIC_VALUE(pd[offset]),
872                                              ISIS_LSP_CLV_METRIC_IE(pd[offset]) ? "External" : "Internal");
873                                             
874                         if (ISIS_LSP_CLV_METRIC_SUPPORTED(pd[offset+1])) {
875                           proto_tree_add_text (ntree, NullTVB, offset+1, 1, "Delay Metric:   Not supported");
876                         } else {
877                           proto_tree_add_text (ntree, NullTVB, offset+1, 1, "Delay Metric:   %d, %s",
878                                              ISIS_LSP_CLV_METRIC_VALUE(pd[offset+1]),
879                                              ISIS_LSP_CLV_METRIC_IE(pd[offset+1]) ? "External" : "Internal");
880                         }
881
882
883                         if (ISIS_LSP_CLV_METRIC_SUPPORTED(pd[offset+2])) {
884                           proto_tree_add_text (ntree, NullTVB, offset+2, 1, "Expense Metric: Not supported");
885                         } else {
886                           proto_tree_add_text (ntree, NullTVB, offset+2, 1, "Expense Metric: %d, %s",
887                                                ISIS_LSP_CLV_METRIC_VALUE(pd[offset+2]),
888                                                ISIS_LSP_CLV_METRIC_IE(pd[offset+2]) ? "External" : "Internal");
889                         }
890
891                         if (ISIS_LSP_CLV_METRIC_SUPPORTED(pd[offset+3])) {
892                           proto_tree_add_text (ntree, NullTVB, offset+3, 1, "Error Metric:   Not supported");
893                         } else {
894                           proto_tree_add_text (ntree, NullTVB, offset+3, 1, "Error Metric:   %d, %s",
895                                                ISIS_LSP_CLV_METRIC_VALUE(pd[offset+3]),
896                                                ISIS_LSP_CLV_METRIC_IE(pd[offset+3]) ? "External" : "Internal");
897                         }
898          
899                         
900 /* this is redundant information
901                         Proto_tree_add_text ( ntree, NullTVB, offset + 4, id_length, 
902                                 "Neighbour ID: %s",
903                                 print_system_id( pd + offset + 4, id_length ) );
904 */
905                 }
906                 offset += tlen;
907                 length -= tlen;
908         }
909 }
910
911 /*
912  * Name: dissect_lsp_l1_is_neighbors_clv()
913  *
914  * Description:
915  *      Dispatch a l1 intermediate system neighbor by calling
916  *      the inner function with show virtual set to TRUE and is es set to FALSE.
917  *
918  * Input:
919  *      u_char * : packet data
920  *      int : offset into packet data where we are.
921  *      guint : length of clv we are decoding
922  *      int : length of IDs in packet.
923  *      frame_data * : frame data (complete frame)
924  *      proto_tree * : protocol display tree to fill out.  May be NULL
925  *
926  * Output:
927  *      void, but we will add to proto tree if !NULL.
928  */
929 static void 
930 dissect_lsp_l1_is_neighbors_clv(const u_char *pd, int offset, 
931                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
932         dissect_lsp_eis_neighbors_clv_inner( pd, offset, length, id_length,
933                 fd, tree, TRUE, FALSE );
934 }
935
936 /*
937  * Name: dissect_lsp_l1_es_neighbors_clv()
938  *
939  * Description:
940  *      Dispatch a l1 end or intermediate system neighbor by calling
941  *      the inner function with show virtual set to TRUE and es set to TRUE.
942  *
943  * Input:
944  *      u_char * : packet data
945  *      int : offset into packet data where we are.
946  *      guint : length of clv we are decoding
947  *      int : length of IDs in packet.
948  *      frame_data * : frame data (complete frame)
949  *      proto_tree * : protocol display tree to fill out.  May be NULL
950  *
951  * Output:
952  *      void, but we will add to proto tree if !NULL.
953  */
954 static void 
955 dissect_lsp_l1_es_neighbors_clv(const u_char *pd, int offset, 
956                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
957         dissect_lsp_eis_neighbors_clv_inner( pd, offset, length, id_length,
958                 fd, tree, TRUE, TRUE);
959 }
960
961 /*
962  * Name: dissect_lsp_l2_is_neighbors_clv()
963  *
964  * Description:
965  *      Dispatch a l2 intermediate system neighbor by calling
966  *      the inner function with show virtual set to FALSE, and is es set
967  *      to FALSE
968  *
969  * Input:
970  *      u_char * : packet data
971  *      int : offset into packet data where we are.
972  *      guint : length of clv we are decoding
973  *      int : length of IDs in packet.
974  *      frame_data * : frame data (complete frame)
975  *      proto_tree * : protocol display tree to fill out.  May be NULL
976  *
977  * Output:
978  *      void, but we will add to proto tree if !NULL.
979  */
980 static void 
981 dissect_lsp_l2_is_neighbors_clv(const u_char *pd, int offset, 
982                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
983         dissect_lsp_eis_neighbors_clv_inner(pd, offset, length, id_length,
984                 fd, tree, FALSE, FALSE);
985 }
986
987 /*
988  * Name: dissect_subclv_admin_group ()
989  *
990  * Description: Called by function dissect_lsp_ext_is_reachability_clv().
991  *
992  *   This function is called by dissect_lsp_ext_is_reachability_clv()
993  *   for dissect the administrive group sub-CLV (code 3).
994  *
995  * Input:
996  *   u_char * : packet data
997  *   int : offset into packet data where we are (beginning of the sub_clv value).
998  *   proto_tree * : protocol display tree to fill out.
999  *
1000  * Output:
1001  *   void
1002  */
1003 static void
1004 dissect_subclv_admin_group (const u_char *pd, int offset, proto_tree  *tree) {
1005         proto_item *ti;
1006         proto_tree *ntree;
1007         guint32    clv_value;
1008         guint32    mask;
1009         int        i;
1010
1011         ti = proto_tree_add_text (tree, NullTVB, offset-2, 6, "Administrative group(s):");
1012         ntree = proto_item_add_subtree (ti, ett_isis_lsp_subclv_admin_group);
1013
1014         clv_value = pntohl (&pd[offset]);
1015         mask = 1;
1016         for (i = 0 ; i < 32 ; i++) {
1017                 if ( (clv_value & mask) != 0 ) {
1018                         proto_tree_add_text (ntree, NullTVB, offset, 4, "group %d", i);
1019                 }
1020                 mask <<= 1;
1021         }
1022 }
1023
1024 /*
1025  * Name: dissect_subclv_max_bw ()
1026  *
1027  * Description: Called by function dissect_lsp_ext_is_reachability_clv().
1028  *
1029  *   This function is called by dissect_lsp_ext_is_reachability_clv()
1030  *   for dissect the maximum link bandwidth sub-CLV (code 9).
1031  *
1032  * Input:
1033  *   u_char * : packet data
1034  *   int : offset into packet data where we are (beginning of the sub_clv value).
1035  *   proto_tree * : protocol display tree to fill out.
1036  *
1037  * Output:
1038  *   void
1039  */
1040 static void
1041 dissect_subclv_max_bw (const u_char *pd, int offset, proto_tree *tree) {
1042         guint32 ui;
1043         gfloat  bw;
1044
1045         ui = pntohl (&pd[offset]);
1046         memcpy (&bw, &ui, 4);
1047         proto_tree_add_text (tree, NullTVB, offset-2, 6,
1048                 "Maximum link bandwidth : %.2f Mbps", bw*8/1000000 );
1049 }
1050
1051 /*
1052  * Name: dissect_subclv_rsv_bw ()
1053  *
1054  * Description: Called by function dissect_lsp_ext_is_reachability_clv().
1055  *
1056  *   This function is called by dissect_lsp_ext_is_reachability_clv()
1057  *   for dissect the reservable link bandwidth sub-CLV (code 10).
1058  *
1059  * Input:
1060  *   u_char * : packet data
1061  *   int : offset into packet data where we are (beginning of the sub_clv value).
1062  *   proto_tree * : protocol display tree to fill out.
1063  *
1064  * Output:
1065  *   void
1066  */
1067 static void
1068 dissect_subclv_rsv_bw (const u_char *pd, int offset, proto_tree *tree) {
1069         guint32 ui;
1070         gfloat  bw;
1071
1072         ui = pntohl (&pd[offset]);
1073         memcpy (&bw, &ui, 4);
1074         proto_tree_add_text (tree, NullTVB, offset-2, 6,
1075                 "Reservable link bandwidth: %.2f Mbps", bw*8/1000000 );
1076 }
1077
1078 /*
1079  * Name: dissect_subclv_unrsv_bw ()
1080  *
1081  * Description: Called by function dissect_lsp_ext_is_reachability_clv().
1082  *
1083  *   This function is called by dissect_lsp_ext_is_reachability_clv()
1084  *   for dissect the unreserved bandwidth sub-CLV (code 11).
1085  *
1086  * Input:
1087  *   u_char * : packet data
1088  *   int : offset into packet data where we are (beginning of the sub_clv value).
1089  *   proto_tree * : protocol display tree to fill out.
1090  *
1091  * Output:
1092  *   void
1093  */
1094 static void
1095 dissect_subclv_unrsv_bw (const u_char *pd, int offset, proto_tree *tree) {
1096         proto_item *ti;
1097         proto_tree *ntree;
1098         guint32    ui;
1099         gfloat     bw;
1100         int        i;
1101
1102         ti = proto_tree_add_text (tree, NullTVB, offset-2, 34, "Unreserved bandwidth:");
1103         ntree = proto_item_add_subtree (ti, ett_isis_lsp_subclv_unrsv_bw);
1104
1105         for (i = 0 ; i < 8 ; i++) {
1106                 ui = pntohl (&pd[offset]);
1107                 memcpy (&bw, &ui, 4);
1108                 proto_tree_add_text (ntree, NullTVB, offset+4*i, 4,
1109                         "priority level %d: %.2f Mbps", i, bw*8/1000000 );
1110         }
1111 }
1112
1113 /*
1114  * Name: dissect_lsp_ext_is_reachability_clv()
1115  *
1116  * Description: Decode a Extended IS Reachability CLV - code 22
1117  *
1118  *   The extended IS reachability TLV is an extended version
1119  *   of the IS reachability TLV (code 2). It encodes the metric
1120  *   as a 24-bit unsigned interger and allows to add sub-CLV(s).
1121  *
1122  * Input:
1123  *   u_char * : packet data
1124  *   int : offset into packet data where we are.
1125  *   guint : length of clv we are decoding
1126  *   int : length of IDs in packet.
1127  *   frame_data * : frame data (complete frame)
1128  *   proto_tree * : protocol display tree to fill out.  May be NULL
1129  *
1130  * Output:
1131  *   void, but we will add to proto tree if !NULL.
1132  */
1133 static void 
1134 dissect_lsp_ext_is_reachability_clv(const u_char *pd, int offset, 
1135                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
1136         proto_item *ti;
1137         proto_tree *ntree = NULL;
1138         guint8     subclvs_len;
1139         guint8     len, i;
1140         guint8     clv_code, clv_len;
1141
1142         if (!tree) return;
1143
1144         while (length > 0) {
1145                 ti = proto_tree_add_text (tree, NullTVB, offset, 0,
1146                         "IS neighbor: %s",
1147                         print_system_id (&pd[offset], 7) );
1148                 ntree = proto_item_add_subtree (ti, 
1149                         ett_isis_lsp_part_of_clv_ext_is_reachability );
1150                 
1151                 proto_tree_add_text (ntree, NullTVB, offset+7, 3,
1152                         "Metric: %d", pntoh24 (&pd[offset+7]) );
1153
1154                 subclvs_len = pd[offset+10];
1155                 if (subclvs_len == 0) {
1156                         proto_tree_add_text (ntree, NullTVB, offset+10, 1, "No sub-CLV");
1157                 }
1158                 else {
1159                         i = 0;
1160                         while (i < subclvs_len) {
1161                                 clv_code = pd[offset+11+i];
1162                                 clv_len  = pd[offset+12+i];
1163                                 switch (clv_code) {
1164                                 case 3 :
1165                                         dissect_subclv_admin_group (pd, offset+13+i, ntree);
1166                                         break;
1167                                 case 6 :
1168                                         proto_tree_add_text (ntree, NullTVB, offset+11+i, 6,
1169                                                 "IPv4 interface address: %s", ip_to_str (&pd[offset+13+i]) );
1170                                         break;
1171                                 case 8 :
1172                                         proto_tree_add_text (ntree, NullTVB, offset+11+i, 6,
1173                                                 "IPv4 neighbor address: %s", ip_to_str (&pd[offset+13+i]) );
1174                                         break;
1175                                 case 9 :
1176                                         dissect_subclv_max_bw (pd, offset+13+i, ntree);
1177                                         break;
1178                                 case 10:
1179                                         dissect_subclv_rsv_bw (pd, offset+13+i, ntree);
1180                                         break;
1181                                 case 11:
1182                                         dissect_subclv_unrsv_bw (pd, offset+13+i, ntree);
1183                                         break;
1184                                 case 18:
1185                                         proto_tree_add_text (ntree, NullTVB, offset+11+i, 5,
1186                                                 "Traffic engineering default metric: %d", 
1187                                                 pntoh24 (&pd[offset+13+i]) );
1188                                         break;
1189                                 case 250:
1190                                 case 251:
1191                                 case 252:
1192                                 case 253:
1193                                 case 254:
1194                                         proto_tree_add_text (ntree, NullTVB, offset+11+i, clv_len+2,
1195                                                 "Unknown Cisco specific extensions: code %d, length %d",
1196                                                 clv_code, clv_len );
1197                                         break;
1198                                 default :
1199                                         proto_tree_add_text (ntree, NullTVB, offset+11+i, clv_len+2,
1200                                                 "Unknown sub-CLV: code %d, length %d", clv_code, clv_len );
1201                                         break;
1202                                 }
1203                                 i += clv_len + 2;
1204                         }
1205                 }
1206
1207                 len = 11 + subclvs_len;
1208                 proto_item_set_len (ti, len);
1209                 offset += len;
1210                 length -= len;
1211         }
1212 }
1213
1214 /*
1215  * Name: dissect_lsp_partition_dis_clv()
1216  *
1217  * Description:
1218  *      This CLV is used to indicate which system is the designated
1219  *      IS for partition repair.  This means just putting out the
1220  *      "id_length"-octet IS.
1221  *
1222  * Input:
1223  *      u_char * : packet data
1224  *      int : offset into packet data where we are.
1225  *      guint : length of clv we are decoding
1226  *      int : length of IDs in packet.
1227  *      frame_data * : frame data (complete frame)
1228  *      proto_tree * : protocol display tree to fill out.  May be NULL
1229  *
1230  * Output:
1231  *      void, but we will add to proto tree if !NULL.
1232  */
1233 static void 
1234 dissect_lsp_partition_dis_clv(const u_char *pd, int offset, 
1235                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
1236
1237         if ( length < id_length ) {
1238                 isis_dissect_unknown(offset, length, tree, fd,
1239                                 "short lsp parition DIS(%d vs %d)", length,
1240                                 id_length );
1241                 return;
1242         }
1243         /* 
1244          * Gotta build a sub-tree for all our pieces
1245          */
1246         if ( tree ) {
1247                 proto_tree_add_text ( tree, NullTVB, offset, id_length, 
1248                         "Partition designated L2 IS: %s",
1249                         print_system_id( pd + offset, id_length ) );
1250         }
1251         length -= id_length;
1252         offset += id_length;
1253         if ( length > 0 ){
1254                 isis_dissect_unknown(offset, length, tree, fd,
1255                                 "Long lsp parition DIS, %d left over", length );
1256                 return;
1257         }
1258 }
1259
1260 /*
1261  * Name: dissect_lsp_prefix_neighbors_clv()
1262  *
1263  * Description:
1264  *      The prefix CLV describes what other (OSI) networks we can reach
1265  *      and what their cost is.  It is built from a metric block
1266  *      (see dissect_metric) followed by n addresses.
1267  *
1268  * Input:
1269  *      u_char * : packet data
1270  *      int : offset into packet data where we are.
1271  *      guint : length of clv we are decoding
1272  *      int : length of IDs in packet.
1273  *      frame_data * : frame data (complete frame)
1274  *      proto_tree * : protocol display tree to fill out.  May be NULL
1275  *
1276  * Output:
1277  *      void, but we will add to proto tree if !NULL.
1278  */
1279 static void 
1280 dissect_lsp_prefix_neighbors_clv(const u_char *pd, int offset, 
1281                 guint length, int id_length, frame_data *fd, proto_tree *tree) {
1282         char *sbuf;
1283         int mylen;
1284
1285         if ( length < 4 ) {
1286                 isis_dissect_unknown(offset, length, tree, fd,
1287                         "Short lsp prefix neighbors (%d vs 4)", length );
1288                 return;
1289         }
1290         if ( tree ) {
1291                 dissect_metric ( tree, offset, pd[offset], "Default", TRUE );
1292                 dissect_metric ( tree, offset + 1, pd[offset+1], 
1293                         "Delay", FALSE );
1294                 dissect_metric ( tree, offset + 2, pd[offset+2], 
1295                         "Expense", FALSE );
1296                 dissect_metric ( tree, offset + 3, pd[offset+3], 
1297                         "Error", FALSE );
1298         }
1299         offset += 4;
1300         length -= 4;
1301         while ( length > 0 ) {
1302                 mylen = pd[offset];
1303                 length--;
1304                 if (length<=0) {
1305                         isis_dissect_unknown(offset, length, tree, fd,
1306                                 "Zero payload space after length in prefix neighbor" );
1307                         return;
1308                 }
1309                 if ( mylen > length) {
1310                         isis_dissect_unknown(offset, length, tree, fd,
1311                                 "Interal length of prefix neighbor too long (%d vs %d)", 
1312                                 mylen, length );
1313                         return;
1314                 }
1315
1316                 /* 
1317                  * Lets turn the area address into "standard" 0000.0000.etc
1318                  * format string.  
1319                  */
1320                 sbuf =  print_area( pd + offset + 1, mylen );
1321                 /* and spit it out */
1322                 if ( tree ) {
1323                         proto_tree_add_text ( tree, NullTVB, offset, mylen + 1, 
1324                                 "Area address (%d): %s", mylen, sbuf );
1325                 }
1326                 offset += mylen + 1;
1327                 length -= mylen;        /* length already adjusted for len fld*/
1328         }
1329 }
1330
1331 /*
1332  * Name: isis_lsp_decode_lsp_id()
1333  *
1334  * Description: 
1335  *      Display a LSP id into the display tree.
1336  *
1337  * Input:
1338  *      char * : title string
1339  *      proto_tree * : tree to display into. REQUIRED
1340  *      u_char * : packet data
1341  *      int : offset into packet data where we are.
1342  *      int : length of IDs in packet.
1343  *
1344  * Output:
1345  *      void, but we will add to proto tree
1346  */
1347 void
1348 isis_lsp_decode_lsp_id(char *tstr, proto_tree *tree, const u_char *pd,
1349                 int offset, int id_length ) {
1350         proto_tree_add_text(tree, NullTVB, offset, id_length + 2,
1351                 "%s: %s.%02x-%02x", tstr,
1352                         print_system_id( pd + offset, id_length ),
1353                         pd[offset + id_length],
1354                         pd[offset + id_length + 1] );
1355 }
1356
1357 /*
1358  * Name: isis_dissect_isis_lsp()
1359  *
1360  * Description:
1361  *      Print out the LSP part of the main header and then call the CLV
1362  *      de-mangler with the right list of valid CLVs.
1363  *
1364  * Input:
1365  *      int : LSP type, a la packet-isis.h ISIS_TYPE_* values
1366  *      int : header length of packet.
1367  *      int : length of IDs in packet.
1368  *      u_char * : packet data
1369  *      int offset : our offset into packet data.
1370  *      frame_data * : frame data
1371  *      proto_tree * : protocol display tree to add to.  May be NULL.
1372  *
1373  * Output:
1374  *      void, but we will add to proto tree if !NULL.
1375  */
1376 void 
1377 isis_dissect_isis_lsp(int lsp_type, int header_length, int id_length,
1378                 const u_char *pd, int offset, frame_data *fd, proto_tree *tree){
1379         proto_item      *ti;
1380         proto_tree      *lsp_tree = NULL;
1381         int             hlen;
1382         guint16         pdu_length;
1383         char            sbuf[128];
1384         int             inx, q, some, value, len;
1385
1386         OLD_CHECK_DISPLAY_AS_DATA(proto_isis_lsp, pd, offset, fd, tree);
1387
1388         hlen = 2+2+id_length+2+4+2+1;
1389
1390         if (!BYTES_ARE_IN_FRAME(offset, hlen)) {
1391                 isis_dissect_unknown(offset, hlen, tree, fd,
1392                         "not enough capture data for header (%d vs %d)",
1393                         hlen, END_OF_FRAME);
1394                 return;
1395         }
1396         
1397         if (tree) {
1398                 ti = proto_tree_add_item(tree, proto_isis_lsp, NullTVB,
1399                         offset, END_OF_FRAME, FALSE);
1400                 lsp_tree = proto_item_add_subtree(ti, ett_isis_lsp);
1401         }
1402
1403         pdu_length = pntohs(&pd[offset]);
1404         if (tree) {
1405                 proto_tree_add_uint(lsp_tree, hf_isis_lsp_pdu_length, NullTVB,
1406                         offset, 2, pdu_length);
1407         }
1408         offset += 2;
1409
1410         if (tree) {
1411                 proto_tree_add_uint(lsp_tree, hf_isis_lsp_remaining_life, NullTVB,
1412                         offset, 2, pntohs(&pd[offset]));
1413         }
1414         offset += 2;
1415
1416         if (tree) {
1417                 isis_lsp_decode_lsp_id("LSP ID", lsp_tree, pd, offset,
1418                         id_length );
1419         }
1420         offset += id_length + 2;
1421
1422         if (tree) {
1423                 proto_tree_add_uint(lsp_tree, hf_isis_lsp_sequence_number, NullTVB,
1424                         offset, 4, 
1425                         pntohl(&pd[offset]));
1426         }
1427         offset += 4;
1428
1429         if (tree) {
1430                 /* XXX -> we could validate the cksum here! */
1431                 proto_tree_add_uint(lsp_tree, hf_isis_lsp_checksum, NullTVB,
1432                         offset, 2, pntohs(&pd[offset]));
1433         }
1434         offset += 2;
1435
1436         if (tree) {
1437                 /*
1438                  * We need to build our type block values. 
1439                  */
1440                 sbuf[0] = 0;
1441                 some = 0;
1442                 value = ISIS_LSP_ATT(pd[offset]);
1443                 inx = 0;
1444                 for ( q = (1<<ISIS_LSP_ATT_SHIFT); q > 0; q = q >> 1 ){
1445                         if (q & value) { 
1446                                 if (some++) {
1447                                         strcat(sbuf, ", ");
1448                                 }
1449                                 strcat ( sbuf, isis_lsp_attached_bits[inx] );
1450                         }
1451                         inx++;
1452                 }
1453                 if (!some) { 
1454                         strcat ( sbuf, "default-only" );
1455                 }
1456                 proto_tree_add_text(lsp_tree, NullTVB, offset + 18, 1, 
1457                         "Type block(0x%02x): P:%d, Supported metric(s): %s, OL:%d, istype:%s",
1458                         pd[offset],
1459                         ISIS_LSP_PARTITION(pd[offset]) ? 1 : 0,
1460                         sbuf,
1461                         ISIS_LSP_HIPPITY(pd[offset]) ? 1 : 0,
1462                         val_to_str(ISIS_LSP_IS_TYPE(pd[offset]),
1463                                 isis_lsp_istype_vals, "Unknown (0x%x)")
1464                         );
1465         }
1466         offset += 1;
1467
1468         len = pdu_length - header_length;
1469         if (len < 0) {
1470                 isis_dissect_unknown(offset, header_length, tree, fd,
1471                         "packet header length %d went beyond packet",
1472                          header_length );
1473                 return;
1474         }
1475         /*
1476          * Now, we need to decode our CLVs.  We need to pass in
1477          * our list of valid ones!
1478          */
1479         if (lsp_type == ISIS_TYPE_L1_LSP){
1480                 isis_dissect_clvs ( clv_l1_lsp_opts, len, id_length, pd,
1481                         offset, fd, lsp_tree, ett_isis_lsp_clv_unknown );
1482         } else {
1483                 isis_dissect_clvs ( clv_l2_lsp_opts, len, id_length, pd,
1484                         offset, fd, lsp_tree, ett_isis_lsp_clv_unknown );
1485         }
1486 }
1487 /*
1488  * Name: proto_register_isis_lsp()
1489  *
1490  * Description: 
1491  *      Register our protocol sub-sets with protocol manager.
1492  *      NOTE: this procedure is autolinked by the makefile process that
1493  *              builds register.c
1494  *
1495  * Input:
1496  *      u_char * : packet data
1497  *      int : offset into packet data where we are.
1498  *      guint : length of clv we are decoding
1499  *      frame_data * : frame data (complete frame)
1500  *      proto_tree * : protocol display tree to fill out.  May be NULL
1501  *
1502  * Output:
1503  *      void, but we will add to proto tree if !NULL.
1504  */
1505 void 
1506 proto_register_isis_lsp(void) {
1507         static hf_register_info hf[] = {
1508                 { &hf_isis_lsp_pdu_length,
1509                 { "PDU length",         "isis_lsp.pdu_length", FT_UINT16, 
1510                   BASE_DEC, NULL, 0x0, "" }},
1511
1512                 { &hf_isis_lsp_remaining_life,
1513                 { "Remaining life",     "isis_lsp.remaining_life", FT_UINT16, 
1514                   BASE_DEC, NULL, 0x0, "" }},
1515
1516                 { &hf_isis_lsp_sequence_number,
1517                 { "Sequence number",           "isis_lsp.sequence_number", 
1518                   FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
1519
1520                 { &hf_isis_lsp_checksum,
1521                 { "Checksum",           "isis_lsp.checksum",FT_UINT16, 
1522                   BASE_HEX, NULL, 0x0, "" }},
1523
1524                 { &hf_isis_lsp_clv_ipv4_int_addr,
1525                 { "IPv4 interface address", "isis_lsp.clv_ipv4_int_addr", FT_IPv4,
1526                    BASE_NONE, NULL, 0x0, "" }},
1527
1528                 { &hf_isis_lsp_clv_ipv6_int_addr,
1529                 { "IPv6 interface address", "isis_lsp.clv_ipv6_int_addr", FT_IPv6,
1530                    BASE_NONE, NULL, 0x0, "" }},
1531
1532                 { &hf_isis_lsp_clv_te_router_id,
1533                 { "Traffic Engineering Router ID", "isis_lsp.clv_te_router_id", FT_IPv4,
1534                    BASE_NONE, NULL, 0x0, "" }},
1535         };
1536         static gint *ett[] = {
1537                 &ett_isis_lsp,
1538                 &ett_isis_lsp_clv_area_addr,
1539                 &ett_isis_lsp_clv_is_neighbors,
1540                 &ett_isis_lsp_clv_ext_is_reachability, /* CLV 22 */
1541                         &ett_isis_lsp_part_of_clv_ext_is_reachability,
1542                         &ett_isis_lsp_subclv_admin_group,
1543                         &ett_isis_lsp_subclv_unrsv_bw,
1544                 &ett_isis_lsp_clv_unknown,
1545                 &ett_isis_lsp_clv_partition_dis,
1546                 &ett_isis_lsp_clv_prefix_neighbors,
1547                 &ett_isis_lsp_clv_auth,
1548                 &ett_isis_lsp_clv_nlpid,
1549                 &ett_isis_lsp_clv_hostname,
1550                 &ett_isis_lsp_clv_ipv4_int_addr,
1551                 &ett_isis_lsp_clv_ipv6_int_addr, /* CLV 232 */
1552                 &ett_isis_lsp_clv_te_router_id,
1553                 &ett_isis_lsp_clv_ip_reachability,
1554                 &ett_isis_lsp_clv_ext_ip_reachability, /* CLV 135 */
1555                         &ett_isis_lsp_part_of_clv_ext_ip_reachability,
1556                 &ett_isis_lsp_clv_ipv6_reachability, /* CLV 236 */
1557                         &ett_isis_lsp_part_of_clv_ipv6_reachability,
1558         };
1559
1560         proto_isis_lsp = proto_register_protocol(PROTO_STRING_LSP,
1561             "ISIS LSP", "isis_lsp");
1562         proto_register_field_array(proto_isis_lsp, hf, array_length(hf));
1563         proto_register_subtree_array(ett, array_length(ett));
1564 }
1565
1566