Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / packet-isis-hello.c
1 /* packet-isis-hello.c
2  * Routines for decoding isis hello packets and their CLVs
3  *
4  * $Id: packet-isis-hello.c,v 1.31 2002/08/02 23:35:51 jmayer Exp $
5  * Stuart Stanley <stuarts@mxmail.net>
6  *
7  * Ethereal - Network traffic analyzer
8  * By Gerald Combs <gerald@ethereal.com>
9  * Copyright 1998 Gerald Combs
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <glib.h>
33 #include <epan/packet.h>
34 #include "packet-osi.h"
35 #include "packet-isis.h"
36 #include "packet-isis-clv.h"
37 #include "packet-isis-hello.h"
38 #include "epan/resolv.h"
39
40 /* hello packets */
41 static int hf_isis_hello_circuit_reserved    = -1;
42 static int hf_isis_hello_source_id           = -1;
43 static int hf_isis_hello_holding_timer       = -1;
44 static int hf_isis_hello_pdu_length          = -1;
45 static int hf_isis_hello_priority_reserved   = -1;
46 static int hf_isis_hello_lan_id              = -1;
47 static int hf_isis_hello_local_circuit_id    = -1;
48 static int hf_isis_hello_clv_ipv4_int_addr   = -1;
49 static int hf_isis_hello_clv_ipv6_int_addr   = -1;
50 static int hf_isis_hello_clv_ptp_adj         = -1;
51 static int hf_isis_hello_clv_mt              = -1;
52
53 static gint ett_isis_hello                   = -1;
54 static gint ett_isis_hello_clv_area_addr     = -1;
55 static gint ett_isis_hello_clv_is_neighbors  = -1;
56 static gint ett_isis_hello_clv_padding       = -1;
57 static gint ett_isis_hello_clv_unknown       = -1;
58 static gint ett_isis_hello_clv_nlpid         = -1;
59 static gint ett_isis_hello_clv_auth          = -1;
60 static gint ett_isis_hello_clv_ipv4_int_addr = -1;
61 static gint ett_isis_hello_clv_ipv6_int_addr = -1;
62 static gint ett_isis_hello_clv_ptp_adj       = -1;
63 static gint ett_isis_hello_clv_mt            = -1;
64 static gint ett_isis_hello_clv_restart       = -1;
65
66 static const value_string isis_hello_circuit_type_vals[] = {
67         { ISIS_HELLO_TYPE_RESERVED,     "Reserved 0 (discard PDU)"},
68         { ISIS_HELLO_TYPE_LEVEL_1,      "Level 1 only"},
69         { ISIS_HELLO_TYPE_LEVEL_2,      "Level 2 only"},
70         { ISIS_HELLO_TYPE_LEVEL_12,     "Level 1 and 2"},
71         { 0,            NULL} };
72
73 /* 
74  * Predclare dissectors for use in clv dissection.
75  */
76 static void dissect_hello_padding_clv(tvbuff_t *tvb, 
77                 proto_tree *tree, int offset, int id_length, int length);
78 static void dissect_hello_is_neighbors_clv(tvbuff_t *tvb, 
79                 proto_tree *tree, int offset, int id_length, int length);
80 static void dissect_hello_ptp_adj_clv(tvbuff_t *tvb, 
81                 proto_tree *tree, int offset, int id_length, int length);
82 static void dissect_hello_area_address_clv(tvbuff_t *tvb, 
83                 proto_tree *tree, int offset, int id_length, int length);
84 static void dissect_hello_auth_clv(tvbuff_t *tvb, 
85                 proto_tree *tree, int offset, int id_length, int length);
86 static void dissect_hello_ipv6_int_addr_clv(tvbuff_t *tvb, 
87                 proto_tree *tree, int offset, int id_length, int length);
88 static void dissect_hello_ip_int_addr_clv(tvbuff_t *tvb, 
89                 proto_tree *tree, int offset, int id_length, int length);
90 static void dissect_hello_mt_clv(tvbuff_t *tvb, 
91                 proto_tree *tree, int offset, int id_length, int length);
92 static void dissect_hello_nlpid_clv(tvbuff_t *tvb, 
93                 proto_tree *tree, int offset, int id_length, int length);
94 static void dissect_hello_restart_clv(tvbuff_t *tvb, 
95                 proto_tree *tree, int offset, int id_length, int length);
96
97
98 static const isis_clv_handle_t clv_l1_hello_opts[] = {
99         {
100                 ISIS_CLV_L1H_AREA_ADDRESS,
101                 "Area address(es)",
102                 &ett_isis_hello_clv_area_addr,
103                 dissect_hello_area_address_clv
104         },
105         {
106                 ISIS_CLV_L1H_IS_NEIGHBORS,
107                 "IS Neighbor(s)",
108                 &ett_isis_hello_clv_is_neighbors,
109                 dissect_hello_is_neighbors_clv
110         },
111         {
112                 ISIS_CLV_L1H_PADDING,
113                 "Padding",
114                 &ett_isis_hello_clv_padding,
115                 dissect_hello_padding_clv
116         },
117         {
118                 ISIS_CLV_L1H_NLPID,
119                 "Protocols Supported",
120                 &ett_isis_hello_clv_nlpid,
121                 dissect_hello_nlpid_clv
122         },
123         {
124                 ISIS_CLV_L1H_IP_INTERFACE_ADDR,
125                 "IP Interface address(es)",
126                 &ett_isis_hello_clv_ipv4_int_addr,
127                 dissect_hello_ip_int_addr_clv
128         },
129         {
130                 ISIS_CLV_L1H_IPv6_INTERFACE_ADDR,
131                 "IPv6 Interface address(es)",
132                 &ett_isis_hello_clv_ipv6_int_addr,
133                 dissect_hello_ipv6_int_addr_clv
134         },
135         {
136                 ISIS_CLV_L1H_RESTART,
137                 "Restart Signaling",
138                 &ett_isis_hello_clv_restart,
139                 dissect_hello_restart_clv
140         },
141         {
142                 ISIS_CLV_L1H_AUTHENTICATION_NS,
143                 "Authentication(non spec)",
144                 &ett_isis_hello_clv_auth,
145                 dissect_hello_auth_clv
146         },
147         {
148                 ISIS_CLV_L1H_AUTHENTICATION,
149                 "Authentication",
150                 &ett_isis_hello_clv_auth,
151                 dissect_hello_auth_clv
152         },
153         {
154                 ISIS_CLV_L1H_MT,
155                 "Multi Topology",
156                 &ett_isis_hello_clv_mt,
157                 dissect_hello_mt_clv
158         },
159         {
160                 0,
161                 "",
162                 NULL,
163                 NULL
164         }
165 };
166
167 static const isis_clv_handle_t clv_l2_hello_opts[] = {
168         {
169                 ISIS_CLV_L2H_AREA_ADDRESS,
170                 "Area address(es)",
171                 &ett_isis_hello_clv_area_addr,
172                 dissect_hello_area_address_clv
173         },
174         {
175                 ISIS_CLV_L2H_IS_NEIGHBORS,
176                 "IS Neighbor(s)",
177                 &ett_isis_hello_clv_is_neighbors,
178                 dissect_hello_is_neighbors_clv
179         },
180         {
181                 ISIS_CLV_L2H_PADDING,
182                 "Padding",
183                 &ett_isis_hello_clv_padding,
184                 dissect_hello_padding_clv
185         },
186         {
187                 ISIS_CLV_L2H_NLPID,
188                 "Protocols Supported",
189                 &ett_isis_hello_clv_nlpid,
190                 dissect_hello_nlpid_clv
191         },
192         {
193                 ISIS_CLV_L2H_IP_INTERFACE_ADDR,
194                 "IP Interface address(es)",
195                 &ett_isis_hello_clv_ipv4_int_addr,
196                 dissect_hello_ip_int_addr_clv
197         },
198         {
199                 ISIS_CLV_L2H_IPv6_INTERFACE_ADDR,
200                 "IPv6 Interface address(es)",
201                 &ett_isis_hello_clv_ipv6_int_addr,
202                 dissect_hello_ipv6_int_addr_clv
203         },
204         {
205                 ISIS_CLV_L2H_AUTHENTICATION_NS,
206                 "Authentication(non spec)",
207                 &ett_isis_hello_clv_auth,
208                 dissect_hello_auth_clv
209         },
210         {
211                 ISIS_CLV_L2H_RESTART,
212                 "Restart Signaling",
213                 &ett_isis_hello_clv_restart,
214                 dissect_hello_restart_clv
215         },
216         {
217                 ISIS_CLV_L2H_AUTHENTICATION,
218                 "Authentication",
219                 &ett_isis_hello_clv_auth,
220                 dissect_hello_auth_clv
221         },
222         {
223                 ISIS_CLV_L2H_MT,
224                 "Multi Topology",
225                 &ett_isis_hello_clv_mt,
226                 dissect_hello_mt_clv
227         },
228         {
229                 0,
230                 "",
231                 NULL,
232                 NULL
233         }
234 };
235
236 static const isis_clv_handle_t clv_ptp_hello_opts[] = {
237         {
238                 ISIS_CLV_PTP_AREA_ADDRESS,
239                 "Area address(es)",
240                 &ett_isis_hello_clv_area_addr,
241                 dissect_hello_area_address_clv
242         },
243         {
244                 ISIS_CLV_PTP_PADDING,
245                 "Padding",
246                 &ett_isis_hello_clv_padding,
247                 dissect_hello_padding_clv
248         },
249         {
250                 ISIS_CLV_PTP_NLPID,
251                 "Protocols Supported",
252                 &ett_isis_hello_clv_nlpid,
253                 dissect_hello_nlpid_clv
254         },
255         {
256                 ISIS_CLV_PTP_IP_INTERFACE_ADDR,
257                 "IP Interface address(es)",
258                 &ett_isis_hello_clv_ipv4_int_addr,
259                 dissect_hello_ip_int_addr_clv
260         },
261         {
262                 ISIS_CLV_PTP_IPv6_INTERFACE_ADDR,
263                 "IPv6 Interface address(es)",
264                 &ett_isis_hello_clv_ipv6_int_addr,
265                 dissect_hello_ipv6_int_addr_clv
266         },
267         {
268                 ISIS_CLV_PTP_AUTHENTICATION_NS,
269                 "Authentication(non spec)",
270                 &ett_isis_hello_clv_auth,
271                 dissect_hello_auth_clv
272         },
273         {
274                 ISIS_CLV_PTP_AUTHENTICATION,
275                 "Authentication",
276                 &ett_isis_hello_clv_auth,
277                 dissect_hello_auth_clv
278         },
279         {
280                 ISIS_CLV_PTP_RESTART,
281                 "Restart Option",
282                 &ett_isis_hello_clv_restart,
283                 dissect_hello_restart_clv
284         },
285         {
286                 ISIS_CLV_PTP_ADJ,
287                 "Point-to-point Adjacency State",
288                 &ett_isis_hello_clv_ptp_adj,
289                 dissect_hello_ptp_adj_clv
290         },
291         {
292                 ISIS_CLV_PTP_MT,
293                 "Multi Topology",
294                 &ett_isis_hello_clv_mt,
295                 dissect_hello_mt_clv
296         },
297         {
298                 0,
299                 "",
300                 NULL,
301                 NULL
302         }
303 };
304
305
306 /*
307  * Name: dissect_hello_restart_clv()
308  *
309  * Description:
310  *      Decode for a restart clv - only found in IIHs
311  *      hence no call in the common clv dissector
312  *
313  */
314
315 static void 
316 dissect_hello_restart_clv(tvbuff_t *tvb, 
317                 proto_tree *tree, int offset, int id_length _U_, int length)
318 {
319         int restart_options;
320
321         if (length != 3) {
322             isis_dissect_unknown(tvb, tree, offset,
323                                  "malformed TLV (%d vs 3)",
324                                  length, 3 );
325             return;
326         }
327
328         restart_options = tvb_get_guint8(tvb, offset);
329
330         proto_tree_add_text ( tree, tvb, offset, 1,        
331                               "Restart Request bit %s, "
332                               "Restart Acknowledgement bit %s",
333                               ISIS_MASK_RESTART_RR(restart_options) ? "set" : "clear",
334                               ISIS_MASK_RESTART_RA(restart_options) ? "set" : "clear"); 
335         proto_tree_add_text ( tree, tvb, offset+1, 2,        
336                               "Remaining holding time: %us",
337                               tvb_get_ntohs(tvb, offset+1) );
338 }
339
340 /*
341  * Name: dissect_hello_nlpid_clv()
342  *
343  * Description:
344  *      Decode for a hello packets NLPID clv.  Calls into the
345  *      clv common one.
346  *
347  * Input:
348  *      tvbuff_t * : tvbuffer for packet data
349  *      proto_tree * : proto tree to build on (may be null)
350  *      int : current offset into packet data
351  *      int : length of IDs in packet.
352  *      int : length of this clv
353  *
354  * Output:
355  *      void, will modify proto_tree if not null.
356  */
357 static void 
358 dissect_hello_nlpid_clv(tvbuff_t *tvb, 
359         proto_tree *tree, int offset, int id_length _U_, int length)
360 {
361         isis_dissect_nlpid_clv(tvb, tree, offset, length);
362 }
363
364 /*
365  * Name: dissect_hello_mt_clv()
366  *
367  * Description:
368  *      Decode for a hello packets Multi Topology clv.  Calls into the
369  *      clv common one.
370  *
371  * Input:
372  *      tvbuff_t * : tvbuffer for packet data
373  *      proto_tree * : proto tree to build on (may be null)
374  *      int : current offset into packet data
375  *      int : length of IDs in packet.
376  *      int : length of this clv
377  *
378  * Output:
379  *      void, will modify proto_tree if not null.
380  */
381
382 static void 
383 dissect_hello_mt_clv(tvbuff_t *tvb, 
384         proto_tree *tree, int offset, int id_length _U_, int length)
385 {
386         isis_dissect_mt_clv(tvb, tree, offset, length,
387                 hf_isis_hello_clv_mt );
388 }
389
390 /*
391  * Name: dissect_hello_ip_int_addr_clv()
392  *
393  * Description:
394  *      Decode for a hello packets ip interface addr clv.  Calls into the
395  *      clv common one.
396  *
397  * Input:
398  *      tvbuff_t * : tvbuffer for packet data
399  *      proto_tree * : proto tree to build on (may be null)
400  *      int : current offset into packet data
401  *      int : length of IDs in packet.
402  *      int : length of this clv
403  *
404  * Output:
405  *      void, will modify proto_tree if not null.
406  */
407 static void 
408 dissect_hello_ip_int_addr_clv(tvbuff_t *tvb, 
409         proto_tree *tree, int offset, int id_length _U_, int length)
410 {
411         isis_dissect_ip_int_clv(tvb, tree, offset, length,
412                 hf_isis_hello_clv_ipv4_int_addr );
413 }
414
415 /*
416  * Name: dissect_hello_ipv6_int_addr_clv()
417  *
418  * Description:
419  *      Decode for a hello packets ipv6 interface addr clv.  Calls into the
420  *      clv common one.
421  *
422  * Input:
423  *      tvbuff_t * : tvbuffer for packet data
424  *      proto_tree * : proto tree to build on (may be null)
425  *      int : current offset into packet data
426  *      int : length of IDs in packet.
427  *      int : length of this clv
428  *
429  * Output:
430  *      void, will modify proto_tree if not null.
431  */
432 static void 
433 dissect_hello_ipv6_int_addr_clv(tvbuff_t *tvb, 
434         proto_tree *tree, int offset, int id_length _U_, int length)
435 {
436         isis_dissect_ipv6_int_clv(tvb, tree, offset, length,
437                 hf_isis_hello_clv_ipv6_int_addr );
438 }
439
440 /*
441  * Name: dissect_hello_auth_clv()
442  *
443  * Description:
444  *      Decode for a hello packets authenticaion clv.  Calls into the
445  *      clv common one.  An auth inside a hello packet is a perlink
446  *      password.
447  *
448  * Input:
449  *      tvbuff_t * : tvbuffer for packet data
450  *      proto_tree * : proto tree to build on (may be null)
451  *      int : current offset into packet data
452  *      int : length of IDs in packet.
453  *      int : length of this clv
454  *
455  * Output:
456  *      void, will modify proto_tree if not null.
457  */
458 static void 
459 dissect_hello_auth_clv(tvbuff_t *tvb, 
460         proto_tree *tree, int offset, int id_length _U_, int length)
461 {
462         isis_dissect_authentication_clv(tvb, tree, offset,
463                 length, "authentication" );
464 }
465
466 /*
467  * Name: dissect_hello_area_address_clv()
468  *
469  * Description:
470  *      Decode for a hello packets area address clv.  Calls into the
471  *      clv common one.
472  *
473  * Input:
474  *      tvbuff_t * : tvbuffer for packet data
475  *      proto_tree * : proto tree to build on (may be null)
476  *      int : current offset into packet data
477  *      int : length of IDs in packet.
478  *      int : length of this clv
479  *
480  * Output:
481  *      void, will modify proto_tree if not null.
482  */
483 static void 
484 dissect_hello_area_address_clv(tvbuff_t *tvb, 
485         proto_tree *tree, int offset, int id_length _U_, int length)
486 {
487         isis_dissect_area_address_clv(tvb, tree, offset, length);
488 }
489
490
491
492 static void 
493 dissect_hello_ptp_adj_clv(tvbuff_t *tvb, 
494                 proto_tree *tree, int offset, int id_length _U_, int length)
495 {
496         static const value_string adj_state_vals[] = {
497             { 0, "Up" },
498             { 1, "Initializing" },
499             { 2, "Down" },
500             { 0, NULL }
501         };
502         guint8 adj_state;
503         char *adj_state_str;
504
505         adj_state = tvb_get_guint8(tvb, offset);
506         adj_state_str = val_to_str(adj_state, adj_state_vals, "Unknown (%u)");
507         switch(length) {
508           case 1:
509             proto_tree_add_text ( tree, tvb, offset, 1,
510                                   "Adjacency State: %s", adj_state_str );
511             break;
512           case 5:
513             proto_tree_add_text ( tree, tvb, offset, 1,
514                                   "Adjacency State: %s", adj_state_str ); 
515             proto_tree_add_text ( tree, tvb, offset+1, 4,        
516                                   "Extended Local circuit ID: 0x%08x", tvb_get_ntohl(tvb, offset+1) ); 
517             break;
518           case 11:
519             proto_tree_add_text ( tree, tvb, offset, 1,
520                                   "Adjacency State: %s", adj_state_str );
521             proto_tree_add_text ( tree, tvb, offset+1, 4,
522                                   "Extended Local circuit ID: 0x%08x", tvb_get_ntohl(tvb, offset+1) );
523             proto_tree_add_text ( tree, tvb, offset+5, 6,
524                                   "Neighbor SystemID: %s", print_system_id( tvb_get_ptr(tvb, offset+5, 6), 6 ) );
525             break;
526           case 15:
527             proto_tree_add_text ( tree, tvb, offset, 1,
528                                   "Adjacency State: %s", adj_state_str );
529             proto_tree_add_text ( tree, tvb, offset+1, 4,
530                                   "Extended Local circuit ID: 0x%08x", tvb_get_ntohl(tvb, offset+1) );
531             proto_tree_add_text ( tree, tvb, offset+5, 6,
532                                   "Neighbor SystemID: %s", print_system_id( tvb_get_ptr(tvb, offset+5, 6), 6 ) );  
533             proto_tree_add_text ( tree, tvb, offset+11, 4,
534                                   "Neighbor Extended Local circuit ID: 0x%08x", tvb_get_ntohl(tvb, offset+11) );
535             break;
536           default:
537             isis_dissect_unknown(tvb, tree, offset,
538                                  "malformed TLV (%d vs 1,5,11,15)", length );
539             return;
540         }
541 }
542
543 /*
544  * Name: isis_dissect_is_neighbors_clv()
545  * 
546  * Description:
547  *      Take apart a IS neighbor packet.  A neighbor is n 6 byte packets.
548  *      (they tend to be an 802.3 MAC address, but its not required).
549  *
550  * Input:
551  *      tvbuff_t * : tvbuffer for packet data
552  *      proto_tree * : protocol display tree to fill out.  May be NULL
553  *      int : offset into packet data where we are.
554  *      int : length of IDs in packet.
555  *      int : length of clv we are decoding
556  * 
557  * Output:
558  *      void, but we will add to proto tree if !NULL.
559  */
560 static void 
561 dissect_hello_is_neighbors_clv(tvbuff_t *tvb, proto_tree *tree, int offset,
562         int id_length _U_, int length)
563 {
564         while ( length > 0 ) {
565                 if (length<6) {
566                         isis_dissect_unknown(tvb, tree, offset,
567                                 "short is neighbor (%d vs 6)", length );
568                         return;
569                 }
570                 /* 
571                  * Lets turn the area address into "standard" 0000.0000.etc
572                  * format string.  
573                  */
574                 if ( tree ) {
575                         proto_tree_add_text ( tree, tvb, offset, 6, 
576                                 "IS Neighbor: %s", get_ether_name( tvb_get_ptr(tvb, offset, 6)) );
577                 }
578                 offset += 6;
579                 length -= 6;
580         }
581 }
582
583 /*
584  * Name: dissect_hello_padding_clv()
585  *
586  * Description:
587  *      Decode for a hello packet's padding clv.  Padding does nothing,
588  *      so we just return.
589  *
590  * Input:
591  *      tvbuff_t * : tvbuffer for packet data
592  *      proto_tree * : proto tree to build on (may be null)
593  *      int : current offset into packet data
594  *      int : length of IDs in packet.
595  *      int : length of this clv
596  *
597  * Output:
598  *      void
599  */
600 static void 
601 dissect_hello_padding_clv(tvbuff_t *tvb _U_, proto_tree *tree _U_, int offset _U_,
602         int id_length _U_, int length _U_)
603 {
604         /* nothing to do here! */
605 }
606
607
608 /*
609  * Name: isis_dissect_isis_hello()
610  * 
611  * Description:
612  *      This procedure rips apart the various types of ISIS hellos.  L1H and
613  *      L2H's are identical for the most part, while the PTP hello has
614  *      a shorter header.
615  *
616  * Input:
617  *      tvbuff_t * : tvbuffer for packet data
618  *      proto_tree * : protocol display tree to add to.  May be NULL.
619  *      int offset : our offset into packet data.
620  *      int : hello type, a la packet-isis.h ISIS_TYPE_* values
621  *      int : header length of packet.
622  *      int : length of IDs in packet.
623  *
624  * Output:
625  *      void, will modify proto_tree if not NULL.
626  */     
627 void 
628 isis_dissect_isis_hello(tvbuff_t *tvb, proto_tree *tree, int offset,
629         int hello_type, int header_length, int id_length)
630 {
631         proto_item      *ti;
632         proto_tree      *hello_tree = NULL;
633         int             len;
634         guint8          octet;
635         const guint8    *source_id;
636         guint16         pdu_length;
637         const guint8    *lan_id;
638
639         if (tree) {
640                 ti = proto_tree_add_text(tree, tvb, offset, -1, "ISIS HELLO");
641                 hello_tree = proto_item_add_subtree(ti, ett_isis_hello);
642                 octet = tvb_get_guint8(tvb, offset);
643                 proto_tree_add_uint_format(hello_tree,
644                         hf_isis_hello_circuit_reserved,
645                         tvb, offset, 1, octet,
646                         "Circuit type              : %s, reserved(0x%02x == 0)",
647                                 val_to_str(octet&ISIS_HELLO_CTYPE_MASK,
648                                         isis_hello_circuit_type_vals,
649                                         "Unknown (0x%x)"),
650                                 octet&ISIS_HELLO_CT_RESERVED_MASK
651                         );
652         }
653         offset += 1;
654
655         if (tree) {
656                 source_id = tvb_get_ptr(tvb, offset, id_length);
657                 proto_tree_add_bytes_format(hello_tree, hf_isis_hello_source_id, tvb,
658                                     offset, id_length, source_id,
659                                     "SystemID{ Sender of PDU } : %s", 
660                                     print_system_id( source_id, id_length ) );
661         }
662         offset += id_length;
663
664         if (tree) {
665                 proto_tree_add_item(hello_tree, hf_isis_hello_holding_timer, tvb,
666                                     offset, 2, FALSE);
667         }
668         offset += 2;
669
670         pdu_length = tvb_get_ntohs(tvb, offset);
671         if (tree) {
672                 proto_tree_add_uint(hello_tree, hf_isis_hello_pdu_length, tvb,
673                                     offset, 2, pdu_length);
674         }
675         offset += 2;
676
677         if (hello_type == ISIS_TYPE_PTP_HELLO) {
678                 if (tree) {
679                         proto_tree_add_item(hello_tree, hf_isis_hello_local_circuit_id, tvb,
680                                          offset, 1, FALSE );
681                 }
682                 offset += 1;
683         } else { 
684
685                 if (tree) {
686                         octet = tvb_get_guint8(tvb, offset);
687                         proto_tree_add_uint_format(hello_tree, hf_isis_hello_priority_reserved, tvb,
688                                     offset, 1, octet,
689                                     "Priority                  : %d, reserved(0x%02x == 0)",
690                                         octet&ISIS_HELLO_PRIORITY_MASK,
691                                         octet&ISIS_HELLO_P_RESERVED_MASK );
692                 }
693                 offset += 1;
694
695                 if (tree) {
696                         lan_id = tvb_get_ptr(tvb, offset, id_length+1);
697                         proto_tree_add_bytes_format(hello_tree, hf_isis_hello_lan_id, tvb, 
698                                      offset, id_length + 1, lan_id,
699                                          "SystemID{ Designated IS } : %s",
700                                               print_system_id( lan_id, id_length + 1 ) );
701                 }
702                 offset += id_length + 1;
703         }
704
705         len = pdu_length;
706         len -= header_length;
707         if (len < 0) {
708                 isis_dissect_unknown(tvb, tree, offset,
709                         "Packet header length %d went beyond packet", 
710                         header_length );
711                 return;
712         }
713         /*
714          * Now, we need to decode our CLVs.  We need to pass in
715          * our list of valid ones!
716          */
717         if (hello_type == ISIS_TYPE_L1_HELLO){
718                 isis_dissect_clvs(tvb, hello_tree, offset,
719                         clv_l1_hello_opts, len, id_length,
720                         ett_isis_hello_clv_unknown);
721         } else if (hello_type == ISIS_TYPE_L2_HELLO) {
722                 isis_dissect_clvs(tvb, hello_tree, offset,
723                         clv_l2_hello_opts, len, id_length,
724                         ett_isis_hello_clv_unknown);
725         } else {
726                 isis_dissect_clvs(tvb, hello_tree, offset,
727                         clv_ptp_hello_opts, len, id_length,
728                         ett_isis_hello_clv_unknown);
729         }
730 }
731
732 /*
733  * Name: isis_register_hello()
734  *
735  * Description:
736  *      Register our protocol sub-sets with protocol manager.
737  *
738  * Input: 
739  *      int : protocol index for the ISIS protocol
740  *
741  * Output:
742  *      void
743  */
744 void
745 isis_register_hello(int proto_isis) {
746         static hf_register_info hf[] = {
747                 { &hf_isis_hello_circuit_reserved,
748                 { "Circuit type              ", "isis.hello.circuit_type",
749                         FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
750
751                 { &hf_isis_hello_source_id,
752                 { "SystemID{ Sender of PDU } ", "isis.hello.source_id",
753                         FT_BYTES, BASE_HEX, NULL, 0x0, "", HFILL }},
754
755                 { &hf_isis_hello_holding_timer,
756                 { "Holding timer             ", "isis.hello.holding_timer", 
757                         FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
758
759                 { &hf_isis_hello_pdu_length,
760                 { "PDU length                ", "isis.hello.pdu_length",
761                         FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
762
763                 { &hf_isis_hello_priority_reserved,
764                  { "Priority                 ", "isis.hello.priority",
765                         FT_UINT8, BASE_DEC, NULL, ISIS_HELLO_P_RESERVED_MASK, "", HFILL }},
766
767                 { &hf_isis_hello_lan_id,
768                 { "SystemID{ Designated IS } ", "isis.hello.lan_id",
769                         FT_BYTES, BASE_DEC, NULL, 0x0, "", HFILL }},
770
771                 { &hf_isis_hello_local_circuit_id,
772                 { "Local circuit ID          ", "isis.hello.local_circuit_id",
773                         FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
774
775                 { &hf_isis_hello_clv_ipv4_int_addr,
776                 { "IPv4 interface address    ", "isis.hello.clv_ipv4_int_addr",
777                         FT_IPv4, BASE_NONE, NULL, 0x0, "", HFILL }},
778
779                 { &hf_isis_hello_clv_ipv6_int_addr,
780                 { "IPv6 interface address    ", "isis.hello.clv_ipv6_int_addr",
781                         FT_IPv6, BASE_NONE, NULL, 0x0, "", HFILL }},
782
783                 { &hf_isis_hello_clv_ptp_adj,
784                 { "Point-to-point Adjacency  ", "isis.hello.clv_ptp_adj",
785                         FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
786
787                 { &hf_isis_hello_clv_mt,
788                 { "MT-ID                     ", "isis.hello.clv_mt",
789                         FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
790         };
791         static gint *ett[] = {
792                 &ett_isis_hello,
793                 &ett_isis_hello_clv_area_addr,
794                 &ett_isis_hello_clv_is_neighbors,
795                 &ett_isis_hello_clv_padding,
796                 &ett_isis_hello_clv_unknown,
797                 &ett_isis_hello_clv_nlpid,
798                 &ett_isis_hello_clv_auth,
799                 &ett_isis_hello_clv_ipv4_int_addr,
800                 &ett_isis_hello_clv_ipv6_int_addr,
801                 &ett_isis_hello_clv_ptp_adj,
802                 &ett_isis_hello_clv_mt,
803                 &ett_isis_hello_clv_restart
804         };
805
806         proto_register_field_array(proto_isis, hf, array_length(hf));
807         proto_register_subtree_array(ett, array_length(ett));
808 }