Clean up some output lines, and show the checksum value on the line for
[obnox/wireshark/wip.git] / packet-ospf.c
1 /* packet-ospf.c
2  * Routines for OSPF packet disassembly
3  * (c) Copyright Hannes R. Boehm <hannes@boehm.org>
4  *
5  * $Id: packet-ospf.c,v 1.9 1999/01/17 09:30:05 guy Exp $
6  *
7  * At this time, this module is able to analyze OSPF
8  * packets as specified in RFC2328. MOSPF (RFC1584) and other
9  * OSPF Extensions which introduce new Packet types
10  * (e.g the External Atributes LSA) are not supported.
11  *
12  * TOS - support is not fully implemented
13  * 
14  * Ethereal - Network traffic analyzer
15  * By Gerald Combs <gerald@zing.org>
16  * Copyright 1998 Gerald Combs
17  * 
18  * 
19  * This program is free software; you can redistribute it and/or
20  * modify it under the terms of the GNU General Public License
21  * as published by the Free Software Foundation; either version 2
22  * of the License, or (at your option) any later version.
23  * 
24  * This program is distributed in the hope that it will be useful,
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27  * GNU General Public License for more details.
28  * 
29  * You should have received a copy of the GNU General Public License
30  * along with this program; if not, write to the Free Software
31  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
32  */
33  
34 #ifdef HAVE_CONFIG_H
35 # include "config.h"
36 #endif
37
38 #include <gtk/gtk.h>
39
40 #include <stdio.h>
41 #include <string.h>
42
43 #ifdef HAVE_SYS_TYPES_H
44 # include <sys/types.h>
45 #endif
46
47 #ifdef HAVE_NETINET_IN_H
48 # include <netinet/in.h>
49 #endif
50
51 #include "ethereal.h"
52 #include "packet.h"
53 #include "packet-ospf.h"
54
55
56 void 
57 dissect_ospf(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
58     e_ospfhdr ospfh;
59
60     GtkWidget *ospf_tree = NULL, *ti; 
61     GtkWidget *ospf_header_tree;
62     char auth_data[9]="";
63     char *packet_type;
64     static value_string pt_vals[] = { {OSPF_HELLO,   "Hello Packet"   },
65                                       {OSPF_DB_DESC, "DB Descr."      },
66                                       {OSPF_LS_REQ,  "LS Request"     },
67                                       {OSPF_LS_UPD,  "LS Update"      },
68                                       {OSPF_LS_ACK,  "LS Acknowledge" },
69                                       {0,             NULL            } };
70
71     memcpy(&ospfh, &pd[offset], sizeof(e_ospfhdr));
72
73     packet_type = match_strval(ospfh.packet_type, pt_vals);
74     if (check_col(fd, COL_PROTOCOL))
75         col_add_str(fd, COL_PROTOCOL, "OSPF");
76     if (check_col(fd, COL_INFO)) {
77         if (packet_type != NULL)
78             col_add_str(fd, COL_INFO, packet_type); 
79         else
80             col_add_fstr(fd, COL_INFO, "Unknown (%d)", ospfh.packet_type); 
81     }  
82
83     if (tree) {
84         ti = add_item_to_tree(GTK_WIDGET(tree), offset, ntohs(ospfh.length), "Open Shortest Path First"); 
85         ospf_tree = gtk_tree_new(); 
86         add_subtree(ti, ospf_tree, ETT_OSPF);
87
88         ti = add_item_to_tree(GTK_WIDGET(ospf_tree), offset, OSPF_HEADER_LENGTH, "OSPF Header"); 
89         ospf_header_tree = gtk_tree_new();
90         add_subtree(ti, ospf_header_tree, ETT_OSPF_HDR);
91
92         add_item_to_tree(ospf_header_tree, offset, 1, "OSPF Version: %d", ospfh.version);  
93         add_item_to_tree(ospf_header_tree, offset + 1 , 1, "OSPF Packet Type: %d (%s)", 
94                                                            ospfh.packet_type,
95                                                            (packet_type != NULL ?
96                                                              packet_type :
97                                                              "Unknown"));
98         add_item_to_tree(ospf_header_tree, offset + 2 , 2, "Packet Length: %d", 
99                                                            ntohs(ospfh.length));
100         add_item_to_tree(ospf_header_tree, offset + 4 , 4, "Source OSPF Router ID: %s", 
101
102                                                            ip_to_str((guint8 *) &(ospfh.routerid)));
103         if (!(ospfh.area)) {
104            add_item_to_tree(ospf_header_tree, offset + 8 , 4, "Area ID: Backbone");
105         } else {
106            add_item_to_tree(ospf_header_tree, offset + 8 , 4, "Area ID: %s", ip_to_str((guint8 *) &(ospfh.area)));
107         }
108         add_item_to_tree(ospf_header_tree, offset + 12 , 2, "Packet Checksum: 0x%x",
109               ntohs(ospfh.checksum));
110         switch( ntohs(ospfh.auth_type) ) {
111             case OSPF_AUTH_NONE:
112                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type: none");
113                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data (none)");
114                  break;
115             case OSPF_AUTH_SIMPLE:
116                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type: simple");
117                  strncpy(auth_data, (char *) &ospfh.auth_data, 8);
118                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data: %s", auth_data);
119                  break;
120             case OSPF_AUTH_CRYPT:
121                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type: crypt");
122                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data (crypt)");
123                  break;
124             default:
125                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type (unknown)");
126                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data (unknown)");
127         }
128
129     }
130
131     /*  Skip over header */
132     offset += OSPF_HEADER_LENGTH;
133     switch(ospfh.packet_type){
134         case OSPF_HELLO:
135             dissect_ospf_hello(pd, offset, fd, (GtkTree *) ospf_tree); 
136             break;
137         case OSPF_DB_DESC:
138             dissect_ospf_db_desc(pd, offset, fd, (GtkTree *) ospf_tree);   
139             break;
140         case OSPF_LS_REQ:
141             dissect_ospf_ls_req(pd, offset, fd, (GtkTree *) ospf_tree);   
142             break;
143         case OSPF_LS_UPD:
144             dissect_ospf_ls_upd(pd, offset, fd, (GtkTree *) ospf_tree);
145             break;
146         case OSPF_LS_ACK:
147             dissect_ospf_ls_ack(pd, offset, fd, (GtkTree *) ospf_tree);
148             break;
149         default:
150             dissect_data(pd, offset, fd, tree); 
151     }
152 }
153
154 void
155 dissect_ospf_hello(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
156     e_ospf_hello ospfhello;
157     guint32 *ospfneighbor;
158     char options[20]="";
159     int options_offset;
160
161     GtkWidget *ospf_hello_tree, *ti; 
162
163     memcpy(&ospfhello, &pd[offset], sizeof(e_ospf_hello));
164
165     if (tree) {
166         ti = add_item_to_tree(GTK_WIDGET(tree), offset, (fd->cap_len - offset) , "OSPF Hello Packet"); 
167         ospf_hello_tree = gtk_tree_new(); 
168         add_subtree(ti, ospf_hello_tree, ETT_OSPF_HELLO);
169
170
171         add_item_to_tree(ospf_hello_tree, offset , 4, "Network Mask: %s",  ip_to_str((guint8 *) &ospfhello.network_mask));
172         add_item_to_tree(ospf_hello_tree, offset + 4, 2, "Hello Interval: %d seconds",  ntohs(ospfhello.hellointervall));
173
174         /* ATTENTION !!! no check for length of options string */
175         options_offset=0;
176         if(( ospfhello.options & OSPF_OPTIONS_E ) == OSPF_OPTIONS_E){
177             strcpy( (char *)(options + options_offset), "E");
178             options_offset+=1;
179         }
180         if(( ospfhello.options & OSPF_OPTIONS_MC ) == OSPF_OPTIONS_MC){
181             strcpy((char *) (options + options_offset), "/MC");
182             options_offset+=3;
183         }
184         if(( ospfhello.options & OSPF_OPTIONS_NP ) == OSPF_OPTIONS_NP){
185             strcpy((char *) (options + options_offset), "/NP");
186             options_offset+=3;
187         }
188         if(( ospfhello.options & OSPF_OPTIONS_EA ) == OSPF_OPTIONS_EA){
189             strcpy((char *) (options + options_offset) , "/EA");
190             options_offset+=3;
191         }
192         if(( ospfhello.options & OSPF_OPTIONS_DC ) == OSPF_OPTIONS_DC){
193             strcpy((char *) (options + options_offset) , "/DC");
194             options_offset+=3;
195         }
196
197         add_item_to_tree(ospf_hello_tree, offset + 6, 1, "Options: %d (%s)",  ospfhello.options, options);
198         add_item_to_tree(ospf_hello_tree, offset + 7, 1, "Router Priority: %d",  ospfhello.priority);
199         add_item_to_tree(ospf_hello_tree, offset + 8, 4, "Router Dead Interval: %ld seconds",  (long)ntohl(ospfhello.dead_interval));
200         add_item_to_tree(ospf_hello_tree, offset + 12, 4, "Designated Router: %s",  ip_to_str((guint8 *) &ospfhello.drouter));
201         add_item_to_tree(ospf_hello_tree, offset + 16, 4, "Backup Designated Router: %s",  ip_to_str((guint8 *) &ospfhello.bdrouter));
202
203
204         offset+=20;
205         while(((int)(fd->cap_len - offset)) >= 4){
206             printf("%d", fd->cap_len - offset);
207             ospfneighbor=(guint32 *) &pd[offset];
208             add_item_to_tree(ospf_hello_tree, offset, 4, "Active Neighbor: %s",  ip_to_str((guint8 *) ospfneighbor));
209             offset+=4;
210         }
211     }
212 }
213
214 void
215 dissect_ospf_db_desc(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
216     e_ospf_dbd ospf_dbd;
217     char options[20]="";
218     int options_offset;
219     char flags[20]="";
220     int flags_offset;
221
222     GtkWidget *ospf_db_desc_tree=NULL, *ti; 
223
224     memcpy(&ospf_dbd, &pd[offset], sizeof(e_ospf_dbd));
225
226     if (tree) {
227         ti = add_item_to_tree(GTK_WIDGET(tree), offset, (fd->cap_len - offset) , "OSPF DB Description"); 
228         ospf_db_desc_tree = gtk_tree_new(); 
229         add_subtree(ti, ospf_db_desc_tree, ETT_OSPF_DESC);
230
231         add_item_to_tree(ospf_db_desc_tree, offset, 2, "Interface MTU: %d", ntohs(ospf_dbd.interface_mtu) );
232
233
234         options_offset=0;
235         if(( ospf_dbd.options & OSPF_OPTIONS_E ) == OSPF_OPTIONS_E){
236             strcpy( (char *)(options + options_offset), "_E_");
237             options_offset+=1;
238         }
239         if(( ospf_dbd.options & OSPF_OPTIONS_MC ) == OSPF_OPTIONS_MC){
240             strcpy((char *) (options + options_offset), "_MC_");
241             options_offset+=3;
242         }
243         if(( ospf_dbd.options & OSPF_OPTIONS_NP ) == OSPF_OPTIONS_NP){
244             strcpy((char *) (options + options_offset), "_NP_");
245             options_offset+=3;
246         }
247         if(( ospf_dbd.options & OSPF_OPTIONS_EA ) == OSPF_OPTIONS_EA){
248             strcpy((char *) (options + options_offset) , "_EA_");
249             options_offset+=3;
250         }
251         if(( ospf_dbd.options & OSPF_OPTIONS_DC ) == OSPF_OPTIONS_DC){
252             strcpy((char *) (options + options_offset) , "_DC_");
253             options_offset+=3;
254         }
255
256         add_item_to_tree(ospf_db_desc_tree, offset + 2 , 1, "Options: %d (%s)", ospf_dbd.options, options );
257
258
259         flags_offset=0;
260         if(( ospf_dbd.flags & OSPF_DBD_FLAG_MS ) == OSPF_DBD_FLAG_MS){
261             strcpy( (char *)(flags + flags_offset), "_I_");
262             flags_offset+=1;
263         }
264         if(( ospf_dbd.flags & OSPF_DBD_FLAG_M ) == OSPF_DBD_FLAG_M){
265             strcpy((char *) (flags + flags_offset), "_M_");
266             flags_offset+=3;
267         }
268         if(( ospf_dbd.flags & OSPF_DBD_FLAG_I ) == OSPF_DBD_FLAG_I){
269             strcpy((char *) (flags + flags_offset), "_I_");
270             flags_offset+=3;
271         }
272
273         add_item_to_tree(ospf_db_desc_tree, offset + 3 , 1, "Flags: %d (%s)", ospf_dbd.flags, flags );
274         add_item_to_tree(ospf_db_desc_tree, offset + 4 , 4, "DD Sequence: %ld", (long)ntohl(ospf_dbd.dd_sequence) );
275     }
276     /* LS Headers will be processed here */
277     /* skip to the end of DB-Desc header */
278     offset+=8;
279     while( ((int) (fd->cap_len - offset)) >= OSPF_LSA_HEADER_LENGTH ) {
280        dissect_ospf_lsa(pd, offset, fd, (GtkTree *) tree, FALSE);
281        offset+=OSPF_LSA_HEADER_LENGTH;
282     }
283 }
284
285 void
286 dissect_ospf_ls_req(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
287     e_ospf_ls_req ospf_lsr;
288
289     GtkWidget *ospf_lsr_tree, *ti; 
290
291
292     /* zero or more LS requests may be within a LS Request */
293     /* we place every request for a LSA in a single subtree */
294     if (tree) {
295         while( ((int) ( fd->cap_len - offset)) >= OSPF_LS_REQ_LENGTH ){
296              memcpy(&ospf_lsr, &pd[offset], sizeof(e_ospf_ls_req));
297              ti = add_item_to_tree(GTK_WIDGET(tree), offset, OSPF_LS_REQ_LENGTH, "Link State Request"); 
298              ospf_lsr_tree = gtk_tree_new(); 
299              add_subtree(ti, ospf_lsr_tree, ETT_OSPF_LSR);
300
301              switch( ntohl( ospf_lsr.ls_type ) ){
302                  case OSPF_LSTYPE_ROUTER:
303                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Router-LSA (%ld)", 
304                                        (long)ntohl( ospf_lsr.ls_type ) );
305                      break;
306                  case OSPF_LSTYPE_NETWORK:
307                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Network-LSA (%ld)", 
308                                        (long)ntohl( ospf_lsr.ls_type ) );
309                      break;
310                  case OSPF_LSTYPE_SUMMERY:
311                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Summary-LSA (IP network) (%ld)", 
312                                        (long)ntohl( ospf_lsr.ls_type ) );
313                      break;
314                  case OSPF_LSTYPE_ASBR:
315                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Summary-LSA (ASBR) (%ld)", 
316                                        (long)ntohl( ospf_lsr.ls_type ) );
317                      break;
318                  case OSPF_LSTYPE_ASEXT:
319                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: AS-External-LSA (ASBR) (%ld)", 
320                                        (long)ntohl( ospf_lsr.ls_type ) );
321                      break;
322                  default:
323                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: %ld (unknown)", 
324                                        (long)ntohl( ospf_lsr.ls_type ) );
325              }
326
327              add_item_to_tree(ospf_lsr_tree, offset + 4, 4, "Link State ID : %s", 
328                                          ip_to_str((guint8 *) &(ospf_lsr.ls_id)));
329              add_item_to_tree(ospf_lsr_tree, offset + 8, 4, "Advertising Router : %s", 
330                                          ip_to_str((guint8 *) &(ospf_lsr.adv_router)));
331
332              offset+=12;
333         }
334     }
335 }
336 void
337 dissect_ospf_ls_upd(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
338     e_ospf_lsa_upd_hdr upd_hdr;
339     guint32 lsa_counter; 
340
341     GtkWidget *ospf_lsa_upd_tree=NULL, *ti; 
342
343     memcpy(&upd_hdr, &pd[offset], sizeof(e_ospf_lsa_upd_hdr));
344
345     if (tree) {
346         ti = add_item_to_tree(GTK_WIDGET(tree), offset, (fd->cap_len - offset) , "LS Update Packet"); 
347         ospf_lsa_upd_tree = gtk_tree_new(); 
348         add_subtree(ti, ospf_lsa_upd_tree, ETT_OSPF_LSA_UPD);
349
350         add_item_to_tree(ospf_lsa_upd_tree, offset, 4, "Nr oF LSAs: %ld", (long)ntohl(upd_hdr.lsa_nr) );
351     }
352     /* skip to the beginning of the first LSA */
353     offset+=4; /* the LS Upd PAcket contains only a 32 bit #LSAs field */
354     
355     lsa_counter = 0;
356     while(lsa_counter < ntohl(upd_hdr.lsa_nr)){
357         offset+=dissect_ospf_lsa(pd, offset, fd, (GtkTree *) ospf_lsa_upd_tree, TRUE);
358         lsa_counter += 1;
359     }
360 }
361
362 void
363 dissect_ospf_ls_ack(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
364
365     /* the body of a LS Ack packet simply contains zero or more LSA Headers */
366     while( ((int)(fd->cap_len - offset)) >= OSPF_LSA_HEADER_LENGTH ) {
367        dissect_ospf_lsa(pd, offset, fd, (GtkTree *) tree, FALSE);
368        offset+=OSPF_LSA_HEADER_LENGTH;
369     }
370
371 }
372
373 int
374 dissect_ospf_lsa(const u_char *pd, int offset, frame_data *fd, GtkTree *tree, int disassemble_body) {
375     e_ospf_lsa_hdr       lsa_hdr;
376     char                *lsa_type;
377
378     /* data strutures for the router LSA */
379     e_ospf_router_lsa           router_lsa;
380     e_ospf_router_data          router_data;
381     e_ospf_router_metric        tos_data;
382     guint16                     link_counter;
383     guint8                      tos_counter;
384     char                        *link_type;
385     char                        *link_id;
386
387     /* data structures for the network lsa */
388     e_ospf_network_lsa  network_lsa;
389     guint32             *attached_router;
390
391     /* data structures for the summary and ASBR LSAs */
392     e_ospf_summary_lsa  summary_lsa;
393
394     /* data structures for the AS-External LSA */
395     e_ospf_asexternal_lsa       asext_lsa;
396     guint32                   asext_metric;
397
398     GtkWidget *ospf_lsa_tree, *ti; 
399
400     memcpy(&lsa_hdr, &pd[offset], sizeof(e_ospf_lsa_hdr));
401
402              
403
404     switch(lsa_hdr.ls_type) {
405         case OSPF_LSTYPE_ROUTER:
406             lsa_type="Router LSA";
407             break;
408         case OSPF_LSTYPE_NETWORK:
409             lsa_type="Network LSA";
410             break;
411         case OSPF_LSTYPE_SUMMERY:
412             lsa_type="Summery LSA";
413             break;
414         case OSPF_LSTYPE_ASBR:
415             lsa_type="ASBR LSA";
416             break;
417         case OSPF_LSTYPE_ASEXT:
418             lsa_type="AS-external-LSA";
419             break;
420         default:
421             lsa_type="unknown";
422     }
423
424     if (tree) {
425         if(disassemble_body){
426              ti = add_item_to_tree(GTK_WIDGET(tree), offset, ntohs(lsa_hdr.length), 
427                                                       "%s (Type: %d)", lsa_type, lsa_hdr.ls_type); 
428         } else {
429              ti = add_item_to_tree(GTK_WIDGET(tree), offset, OSPF_LSA_HEADER_LENGTH, "LSA Header"); 
430         }
431         ospf_lsa_tree = gtk_tree_new(); 
432         add_subtree(ti, ospf_lsa_tree, ETT_OSPF_LSA);
433
434         
435         add_item_to_tree(ospf_lsa_tree, offset, 2, "LS Age: %d seconds", ntohs(lsa_hdr.ls_age));
436         add_item_to_tree(ospf_lsa_tree, offset + 2, 1, "Options: %d ", lsa_hdr.options);
437         add_item_to_tree(ospf_lsa_tree, offset + 3, 1, "LSA Type: %d (%s)", lsa_hdr.ls_type, lsa_type);
438
439         add_item_to_tree(ospf_lsa_tree, offset + 4, 4, "Linke State ID: %s ", 
440                                                      ip_to_str((guint8 *) &(lsa_hdr.ls_id)));
441
442         add_item_to_tree(ospf_lsa_tree, offset + 8, 4, "Advertising Router: %s ", 
443                                                      ip_to_str((guint8 *) &(lsa_hdr.adv_router)));
444         add_item_to_tree(ospf_lsa_tree, offset + 12, 4, "LS Sequence Number: 0x%04lx ", 
445                                                      (unsigned long)ntohl(lsa_hdr.ls_seq));
446         add_item_to_tree(ospf_lsa_tree, offset + 16, 2, "LS Checksum: %d ", ntohs(lsa_hdr.ls_checksum));
447
448         add_item_to_tree(ospf_lsa_tree, offset + 18, 2, "Length: %d ", ntohs(lsa_hdr.length));
449
450         if(!disassemble_body){
451            return OSPF_LSA_HEADER_LENGTH;
452         }
453
454         /* the LSA body starts afte 20 bytes of LSA Header */
455         offset+=20;
456
457         switch(lsa_hdr.ls_type){
458             case(OSPF_LSTYPE_ROUTER):
459                 memcpy(&router_lsa, &pd[offset], sizeof(e_ospf_router_lsa));
460
461                 /* again: flags should be secified in detail */
462                 add_item_to_tree(ospf_lsa_tree, offset, 1, "Flags: 0x%02x ", router_lsa.flags);
463                 add_item_to_tree(ospf_lsa_tree, offset + 2, 2, "Nr. of Links: %d ", 
464                                                                    ntohs(router_lsa.nr_links));
465                 offset += 4;
466                 /* router_lsa.nr_links links follow 
467                  * maybe we should put each of the links into its own subtree ???
468                  */
469                 for(link_counter = 1 ; link_counter <= ntohs(router_lsa.nr_links); link_counter++){
470
471                     memcpy(&router_data, &pd[offset], sizeof(e_ospf_router_data));
472                     /* check the Link Type and ID */
473                     switch(router_data.link_type) {
474                         case OSPF_LINK_PTP:
475                             link_type="Point-to-point connection to another router";
476                             link_id="Neighboring router's Router ID";
477                             break;
478                         case OSPF_LINK_TRANSIT:
479                             link_type="Connection to a transit network";
480                             link_id="IP address of Designated Router";
481                             break;
482                         case OSPF_LINK_STUB:
483                             link_type="Connection to a stub network";
484                             link_id="IP network/subnet number";
485                             break;
486                         case OSPF_LINK_VIRTUAL:
487                             link_type="Virtual link";
488                             link_id="Neighboring router's Router ID";
489                             break;
490                         default:
491                             link_type="unknown link type";
492                             link_id="unknown link id";
493                     }
494
495                     add_item_to_tree(ospf_lsa_tree, offset, 4, "%s: %s", link_id,
496                                                    ip_to_str((guint8 *) &(router_data.link_id)));
497
498                     /* link_data should be specified in detail (e.g. network mask) (depends on link type)*/
499                     add_item_to_tree(ospf_lsa_tree, offset + 4, 4, "Link Data: %s", 
500                                                    ip_to_str((guint8 *) &(router_data.link_data)));
501
502                     add_item_to_tree(ospf_lsa_tree, offset + 8, 1, "Link Type: %d - %s", 
503                                                               router_data.link_type, link_type);
504                     add_item_to_tree(ospf_lsa_tree, offset + 9, 1, "Nr. of TOS metrics: %d", router_data.nr_tos);
505                     add_item_to_tree(ospf_lsa_tree, offset + 10, 2, "TOS 0 metric: %d", ntohs( router_data.tos0_metric ));
506
507                     offset += 12;
508
509                     /* router_data.nr_tos metrics may follow each link 
510                      * ATTENTION: TOS metrics are not tested (I don't have TOS based routing)
511                      * please send me a mail if it is/isn't working
512                      */
513
514                     for(tos_counter = 1 ; link_counter <= ntohs(router_data.nr_tos); tos_counter++){
515                         memcpy(&tos_data, &pd[offset], sizeof(e_ospf_router_metric));
516                         add_item_to_tree(ospf_lsa_tree, offset, 1, "TOS: %d, Metric: %d", 
517                                                 tos_data.tos, ntohs(tos_data.metric));
518                         offset += 4;
519                     }
520                 }
521                 break;
522             case(OSPF_LSTYPE_NETWORK):
523                 memcpy(&network_lsa, &pd[offset], sizeof(e_ospf_network_lsa));
524                 add_item_to_tree(ospf_lsa_tree, offset, 4, "Netmask: %s", 
525                                                  ip_to_str((guint8 *) &(network_lsa.network_mask)));
526                 offset += 4;
527
528                 while( ((int) (fd->cap_len - offset)) >= 4){
529                     attached_router = (guint32 *) &pd[offset];
530                     add_item_to_tree(ospf_lsa_tree, offset, 4, "Attached Router: %s", 
531                                                  ip_to_str((guint8 *) attached_router));
532                     offset += 4;
533                 }
534                 break;
535             case(OSPF_LSTYPE_SUMMERY):
536                 /* Type 3 and 4 LSAs have the same format */
537             case(OSPF_LSTYPE_ASBR):
538                 memcpy(&summary_lsa, &pd[offset], sizeof(e_ospf_summary_lsa));
539                 add_item_to_tree(ospf_lsa_tree, offset, 4, "Netmask: %s", 
540                                                  ip_to_str((guint8 *) &(summary_lsa.network_mask)));
541                 /* returns only the TOS 0 metric (even if there are more TOS metrics) */
542                 break;
543             case(OSPF_LSTYPE_ASEXT):
544                 memcpy(&summary_lsa, &pd[offset], sizeof(e_ospf_summary_lsa));
545                 add_item_to_tree(ospf_lsa_tree, offset, 4, "Netmask: %s", 
546                                                   ip_to_str((guint8 *) &(summary_lsa.network_mask)));
547
548                 /* asext_lsa = (e_ospf_asexternal_lsa *) &pd[offset + 4]; */
549                 memcpy(&asext_lsa, &pd[offset + 4], sizeof(asext_lsa));
550                 if( (asext_lsa.options & 128) == 128 ) { /* check wether or not E bit is set */
551                    add_item_to_tree(ospf_lsa_tree, offset, 1, 
552                             "External Type: Type 2 (metric is larger than any other link state path)");
553                 } else {
554                    add_item_to_tree(ospf_lsa_tree, offset + 4, 1, 
555                             "External Type: Type 1 (metric is specified in the same units as interface cost)");
556                 }
557                 /* the metric field of a AS-external LAS is specified in 3 bytes -> not well aligned */
558                 /* this routine returns only the TOS 0 metric (even if there are more TOS metrics) */
559                 memcpy(&asext_metric, &pd[offset+4], 4); 
560                 
561                 /* erase the leading 8 bits (the dont belong to the metric */
562                 asext_metric = ntohl(asext_metric) & 0x00ffffff ;
563
564                 add_item_to_tree(ospf_lsa_tree, offset + 5,  3,"Metric: %d", asext_metric);
565                 add_item_to_tree(ospf_lsa_tree, offset + 8,  4,"Forwarding Address: %s", 
566                                                  ip_to_str((guint8 *) &(asext_lsa.gateway)));
567                 add_item_to_tree(ospf_lsa_tree, offset + 12, 4,"External Route Tag: %ld", (long)ntohl(asext_lsa.external_tag)); 
568                     
569                 break;
570             default:
571                /* unknown LSA type */
572                 add_item_to_tree(ospf_lsa_tree, offset, (fd->cap_len - offset), "Unknown LSA Type");
573         }
574     }
575     /* return the length of this LSA */
576     return ntohs(lsa_hdr.length);
577 }