dc00129420541eb7adf99911dd3d8c58bc88f6a2
[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.8 1998/11/17 04:29:02 gerald 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 Legth: %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");
109         switch( ntohs(ospfh.auth_type) ) {
110             case OSPF_AUTH_NONE:
111                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type: none");
112                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data (none)");
113                  break;
114             case OSPF_AUTH_SIMPLE:
115                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type: simple");
116                  strncpy(auth_data, (char *) &ospfh.auth_data, 8);
117                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data: %s", auth_data);
118                  break;
119             case OSPF_AUTH_CRYPT:
120                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type: crypt");
121                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data (crypt)");
122                  break;
123             default:
124                  add_item_to_tree(ospf_header_tree, offset + 14 , 2, "Auth Type (unknown)");
125                  add_item_to_tree(ospf_header_tree, offset + 16 , 8, "Auth Data (unknown)");
126         }
127
128     }
129
130     /*  Skip over header */
131     offset += OSPF_HEADER_LENGTH;
132     switch(ospfh.packet_type){
133         case OSPF_HELLO:
134             dissect_ospf_hello(pd, offset, fd, (GtkTree *) ospf_tree); 
135             break;
136         case OSPF_DB_DESC:
137             dissect_ospf_db_desc(pd, offset, fd, (GtkTree *) ospf_tree);   
138             break;
139         case OSPF_LS_REQ:
140             dissect_ospf_ls_req(pd, offset, fd, (GtkTree *) ospf_tree);   
141             break;
142         case OSPF_LS_UPD:
143             dissect_ospf_ls_upd(pd, offset, fd, (GtkTree *) ospf_tree);
144             break;
145         case OSPF_LS_ACK:
146             dissect_ospf_ls_ack(pd, offset, fd, (GtkTree *) ospf_tree);
147             break;
148         default:
149             dissect_data(pd, offset, fd, tree); 
150     }
151 }
152
153 void
154 dissect_ospf_hello(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
155     e_ospf_hello ospfhello;
156     guint32 *ospfneighbor;
157     char options[20]="";
158     int options_offset;
159
160     GtkWidget *ospf_hello_tree, *ti; 
161
162     memcpy(&ospfhello, &pd[offset], sizeof(e_ospf_hello));
163
164     if (tree) {
165         ti = add_item_to_tree(GTK_WIDGET(tree), offset, (fd->cap_len - offset) , "OSPF Hello Packet"); 
166         ospf_hello_tree = gtk_tree_new(); 
167         add_subtree(ti, ospf_hello_tree, ETT_OSPF_HELLO);
168
169
170         add_item_to_tree(ospf_hello_tree, offset , 4, "Network Mask: %s",  ip_to_str((guint8 *) &ospfhello.network_mask));
171         add_item_to_tree(ospf_hello_tree, offset + 4, 2, "Hello Intervall: %d seconds",  ntohs(ospfhello.hellointervall));
172
173         /* ATTENTION !!! no check for length of options string */
174         options_offset=0;
175         if(( ospfhello.options & OSPF_OPTIONS_E ) == OSPF_OPTIONS_E){
176             strcpy( (char *)(options + options_offset), "E");
177             options_offset+=1;
178         }
179         if(( ospfhello.options & OSPF_OPTIONS_MC ) == OSPF_OPTIONS_MC){
180             strcpy((char *) (options + options_offset), "/MC");
181             options_offset+=3;
182         }
183         if(( ospfhello.options & OSPF_OPTIONS_NP ) == OSPF_OPTIONS_NP){
184             strcpy((char *) (options + options_offset), "/NP");
185             options_offset+=3;
186         }
187         if(( ospfhello.options & OSPF_OPTIONS_EA ) == OSPF_OPTIONS_EA){
188             strcpy((char *) (options + options_offset) , "/EA");
189             options_offset+=3;
190         }
191         if(( ospfhello.options & OSPF_OPTIONS_DC ) == OSPF_OPTIONS_DC){
192             strcpy((char *) (options + options_offset) , "/DC");
193             options_offset+=3;
194         }
195
196         add_item_to_tree(ospf_hello_tree, offset + 6, 1, "Options: %d (%s)",  ospfhello.options, options);
197         add_item_to_tree(ospf_hello_tree, offset + 7, 1, "Router Priority: %d",  ospfhello.priority);
198         add_item_to_tree(ospf_hello_tree, offset + 8, 4, "RouterDeadIntervall: %ld seconds",  (long)ntohl(ospfhello.dead_interval));
199         add_item_to_tree(ospf_hello_tree, offset + 12, 4, "Designated Router: %s",  ip_to_str((guint8 *) &ospfhello.drouter));
200         add_item_to_tree(ospf_hello_tree, offset + 16, 4, "Backup Designated Router: %s",  ip_to_str((guint8 *) &ospfhello.bdrouter));
201
202
203         offset+=20;
204         while(((int)(fd->cap_len - offset)) >= 4){
205             printf("%d", fd->cap_len - offset);
206             ospfneighbor=(guint32 *) &pd[offset];
207             add_item_to_tree(ospf_hello_tree, offset, 4, "Active Neighbor: %s",  ip_to_str((guint8 *) ospfneighbor));
208             offset+=4;
209         }
210     }
211 }
212
213 void
214 dissect_ospf_db_desc(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
215     e_ospf_dbd ospf_dbd;
216     char options[20]="";
217     int options_offset;
218     char flags[20]="";
219     int flags_offset;
220
221     GtkWidget *ospf_db_desc_tree=NULL, *ti; 
222
223     memcpy(&ospf_dbd, &pd[offset], sizeof(e_ospf_dbd));
224
225     if (tree) {
226         ti = add_item_to_tree(GTK_WIDGET(tree), offset, (fd->cap_len - offset) , "OSPF DB Description"); 
227         ospf_db_desc_tree = gtk_tree_new(); 
228         add_subtree(ti, ospf_db_desc_tree, ETT_OSPF_DESC);
229
230         add_item_to_tree(ospf_db_desc_tree, offset, 2, "Interface MTU: %d", ntohs(ospf_dbd.interface_mtu) );
231
232
233         options_offset=0;
234         if(( ospf_dbd.options & OSPF_OPTIONS_E ) == OSPF_OPTIONS_E){
235             strcpy( (char *)(options + options_offset), "_E_");
236             options_offset+=1;
237         }
238         if(( ospf_dbd.options & OSPF_OPTIONS_MC ) == OSPF_OPTIONS_MC){
239             strcpy((char *) (options + options_offset), "_MC_");
240             options_offset+=3;
241         }
242         if(( ospf_dbd.options & OSPF_OPTIONS_NP ) == OSPF_OPTIONS_NP){
243             strcpy((char *) (options + options_offset), "_NP_");
244             options_offset+=3;
245         }
246         if(( ospf_dbd.options & OSPF_OPTIONS_EA ) == OSPF_OPTIONS_EA){
247             strcpy((char *) (options + options_offset) , "_EA_");
248             options_offset+=3;
249         }
250         if(( ospf_dbd.options & OSPF_OPTIONS_DC ) == OSPF_OPTIONS_DC){
251             strcpy((char *) (options + options_offset) , "_DC_");
252             options_offset+=3;
253         }
254
255         add_item_to_tree(ospf_db_desc_tree, offset + 2 , 1, "Options: %d (%s)", ospf_dbd.options, options );
256
257
258         flags_offset=0;
259         if(( ospf_dbd.flags & OSPF_DBD_FLAG_MS ) == OSPF_DBD_FLAG_MS){
260             strcpy( (char *)(flags + flags_offset), "_I_");
261             flags_offset+=1;
262         }
263         if(( ospf_dbd.flags & OSPF_DBD_FLAG_M ) == OSPF_DBD_FLAG_M){
264             strcpy((char *) (flags + flags_offset), "_M_");
265             flags_offset+=3;
266         }
267         if(( ospf_dbd.flags & OSPF_DBD_FLAG_I ) == OSPF_DBD_FLAG_I){
268             strcpy((char *) (flags + flags_offset), "_I_");
269             flags_offset+=3;
270         }
271
272         add_item_to_tree(ospf_db_desc_tree, offset + 3 , 1, "Flags: %d (%s)", ospf_dbd.flags, flags );
273         add_item_to_tree(ospf_db_desc_tree, offset + 4 , 4, "DD Sequence: %ld", (long)ntohl(ospf_dbd.dd_sequence) );
274     }
275     /* LS Headers will be processed here */
276     /* skip to the end of DB-Desc header */
277     offset+=8;
278     while( ((int) (fd->cap_len - offset)) >= OSPF_LSA_HEADER_LENGTH ) {
279        dissect_ospf_lsa(pd, offset, fd, (GtkTree *) tree, FALSE);
280        offset+=OSPF_LSA_HEADER_LENGTH;
281     }
282 }
283
284 void
285 dissect_ospf_ls_req(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
286     e_ospf_ls_req ospf_lsr;
287
288     GtkWidget *ospf_lsr_tree, *ti; 
289
290
291     /* zero or more LS requests may be within a LS Request */
292     /* we place every request for a LSA in a single subtree */
293     if (tree) {
294         while( ((int) ( fd->cap_len - offset)) >= OSPF_LS_REQ_LENGTH ){
295              memcpy(&ospf_lsr, &pd[offset], sizeof(e_ospf_ls_req));
296              ti = add_item_to_tree(GTK_WIDGET(tree), offset, OSPF_LS_REQ_LENGTH, "Link State Request"); 
297              ospf_lsr_tree = gtk_tree_new(); 
298              add_subtree(ti, ospf_lsr_tree, ETT_OSPF_LSR);
299
300              switch( ntohl( ospf_lsr.ls_type ) ){
301                  case OSPF_LSTYPE_ROUTER:
302                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Router-LSA (%ld)", 
303                                        (long)ntohl( ospf_lsr.ls_type ) );
304                      break;
305                  case OSPF_LSTYPE_NETWORK:
306                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Network-LSA (%ld)", 
307                                        (long)ntohl( ospf_lsr.ls_type ) );
308                      break;
309                  case OSPF_LSTYPE_SUMMERY:
310                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Summary-LSA (IP network) (%ld)", 
311                                        (long)ntohl( ospf_lsr.ls_type ) );
312                      break;
313                  case OSPF_LSTYPE_ASBR:
314                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: Summary-LSA (ASBR) (%ld)", 
315                                        (long)ntohl( ospf_lsr.ls_type ) );
316                      break;
317                  case OSPF_LSTYPE_ASEXT:
318                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: AS-External-LSA (ASBR) (%ld)", 
319                                        (long)ntohl( ospf_lsr.ls_type ) );
320                      break;
321                  default:
322                      add_item_to_tree(ospf_lsr_tree, offset, 4, "LS Type: %ld (unknown)", 
323                                        (long)ntohl( ospf_lsr.ls_type ) );
324              }
325
326              add_item_to_tree(ospf_lsr_tree, offset + 4, 4, "Link State ID : %s", 
327                                          ip_to_str((guint8 *) &(ospf_lsr.ls_id)));
328              add_item_to_tree(ospf_lsr_tree, offset + 8, 4, "Advertising Router : %s", 
329                                          ip_to_str((guint8 *) &(ospf_lsr.adv_router)));
330
331              offset+=12;
332         }
333     }
334 }
335 void
336 dissect_ospf_ls_upd(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
337     e_ospf_lsa_upd_hdr upd_hdr;
338     guint32 lsa_counter; 
339
340     GtkWidget *ospf_lsa_upd_tree=NULL, *ti; 
341
342     memcpy(&upd_hdr, &pd[offset], sizeof(e_ospf_lsa_upd_hdr));
343
344     if (tree) {
345         ti = add_item_to_tree(GTK_WIDGET(tree), offset, (fd->cap_len - offset) , "LS Update Packet"); 
346         ospf_lsa_upd_tree = gtk_tree_new(); 
347         add_subtree(ti, ospf_lsa_upd_tree, ETT_OSPF_LSA_UPD);
348
349         add_item_to_tree(ospf_lsa_upd_tree, offset, 4, "Nr oF LSAs: %ld", (long)ntohl(upd_hdr.lsa_nr) );
350     }
351     /* skip to the beginning of the first LSA */
352     offset+=4; /* the LS Upd PAcket contains only a 32 bit #LSAs field */
353     
354     lsa_counter = 0;
355     while(lsa_counter < ntohl(upd_hdr.lsa_nr)){
356         offset+=dissect_ospf_lsa(pd, offset, fd, (GtkTree *) ospf_lsa_upd_tree, TRUE);
357         lsa_counter += 1;
358     }
359 }
360
361 void
362 dissect_ospf_ls_ack(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) {
363
364     /* the body of a LS Ack packet simply contains zero or more LSA Headers */
365     while( ((int)(fd->cap_len - offset)) >= OSPF_LSA_HEADER_LENGTH ) {
366        dissect_ospf_lsa(pd, offset, fd, (GtkTree *) tree, FALSE);
367        offset+=OSPF_LSA_HEADER_LENGTH;
368     }
369
370 }
371
372 int
373 dissect_ospf_lsa(const u_char *pd, int offset, frame_data *fd, GtkTree *tree, int disassemble_body) {
374     e_ospf_lsa_hdr       lsa_hdr;
375     char                *lsa_type;
376
377     /* data strutures for the router LSA */
378     e_ospf_router_lsa           router_lsa;
379     e_ospf_router_data          router_data;
380     e_ospf_router_metric        tos_data;
381     guint16                     link_counter;
382     guint8                      tos_counter;
383     char                        *link_type;
384     char                        *link_id;
385
386     /* data structures for the network lsa */
387     e_ospf_network_lsa  network_lsa;
388     guint32             *attached_router;
389
390     /* data structures for the summary and ASBR LSAs */
391     e_ospf_summary_lsa  summary_lsa;
392
393     /* data structures for the AS-External LSA */
394     e_ospf_asexternal_lsa       asext_lsa;
395     guint32                   asext_metric;
396
397     GtkWidget *ospf_lsa_tree, *ti; 
398
399     memcpy(&lsa_hdr, &pd[offset], sizeof(e_ospf_lsa_hdr));
400
401              
402
403     switch(lsa_hdr.ls_type) {
404         case OSPF_LSTYPE_ROUTER:
405             lsa_type="Router LSA";
406             break;
407         case OSPF_LSTYPE_NETWORK:
408             lsa_type="Network LSA";
409             break;
410         case OSPF_LSTYPE_SUMMERY:
411             lsa_type="Summery LSA";
412             break;
413         case OSPF_LSTYPE_ASBR:
414             lsa_type="ASBR LSA";
415             break;
416         case OSPF_LSTYPE_ASEXT:
417             lsa_type="AS-external-LSA";
418             break;
419         default:
420             lsa_type="unknown";
421     }
422
423     if (tree) {
424         if(disassemble_body){
425              ti = add_item_to_tree(GTK_WIDGET(tree), offset, ntohs(lsa_hdr.length), 
426                                                       "%s (Type: %d)", lsa_type, lsa_hdr.ls_type); 
427         } else {
428              ti = add_item_to_tree(GTK_WIDGET(tree), offset, OSPF_LSA_HEADER_LENGTH, "LSA Header"); 
429         }
430         ospf_lsa_tree = gtk_tree_new(); 
431         add_subtree(ti, ospf_lsa_tree, ETT_OSPF_LSA);
432
433         
434         add_item_to_tree(ospf_lsa_tree, offset, 2, "LS Age: %d seconds", ntohs(lsa_hdr.ls_age));
435         add_item_to_tree(ospf_lsa_tree, offset + 2, 1, "Options: %d ", lsa_hdr.options);
436         add_item_to_tree(ospf_lsa_tree, offset + 3, 1, "LSA Type: %d (%s)", lsa_hdr.ls_type, lsa_type);
437
438         add_item_to_tree(ospf_lsa_tree, offset + 4, 4, "Linke State ID: %s ", 
439                                                      ip_to_str((guint8 *) &(lsa_hdr.ls_id)));
440
441         add_item_to_tree(ospf_lsa_tree, offset + 8, 4, "Advertising Router: %s ", 
442                                                      ip_to_str((guint8 *) &(lsa_hdr.adv_router)));
443         add_item_to_tree(ospf_lsa_tree, offset + 12, 4, "LS Sequence Number: 0x%04lx ", 
444                                                      (unsigned long)ntohl(lsa_hdr.ls_seq));
445         add_item_to_tree(ospf_lsa_tree, offset + 16, 2, "LS Checksum: %d ", ntohs(lsa_hdr.ls_checksum));
446
447         add_item_to_tree(ospf_lsa_tree, offset + 18, 2, "Length: %d ", ntohs(lsa_hdr.length));
448
449         if(!disassemble_body){
450            return OSPF_LSA_HEADER_LENGTH;
451         }
452
453         /* the LSA body starts afte 20 bytes of LSA Header */
454         offset+=20;
455
456         switch(lsa_hdr.ls_type){
457             case(OSPF_LSTYPE_ROUTER):
458                 memcpy(&router_lsa, &pd[offset], sizeof(e_ospf_router_lsa));
459
460                 /* again: flags should be secified in detail */
461                 add_item_to_tree(ospf_lsa_tree, offset, 1, "Flags: 0x%02x ", router_lsa.flags);
462                 add_item_to_tree(ospf_lsa_tree, offset + 2, 2, "Nr. of Links: %d ", 
463                                                                    ntohs(router_lsa.nr_links));
464                 offset += 4;
465                 /* router_lsa.nr_links links follow 
466                  * maybe we should put each of the links into its own subtree ???
467                  */
468                 for(link_counter = 1 ; link_counter <= ntohs(router_lsa.nr_links); link_counter++){
469
470                     memcpy(&router_data, &pd[offset], sizeof(e_ospf_router_data));
471                     /* check the Link Type and ID */
472                     switch(router_data.link_type) {
473                         case OSPF_LINK_PTP:
474                             link_type="Point-to-point connection to another router";
475                             link_id="Neighboring router's Router ID";
476                             break;
477                         case OSPF_LINK_TRANSIT:
478                             link_type="Connection to a transit network";
479                             link_id="IP address of Designated Router";
480                             break;
481                         case OSPF_LINK_STUB:
482                             link_type="Connection to a stub network";
483                             link_id="IP network/subnet number";
484                             break;
485                         case OSPF_LINK_VIRTUAL:
486                             link_type="Virtual link";
487                             link_id="Neighboring router's Router ID";
488                             break;
489                         default:
490                             link_type="unknown link type";
491                             link_id="unknown link id";
492                     }
493
494                     add_item_to_tree(ospf_lsa_tree, offset, 4, "%s: %s", link_id,
495                                                    ip_to_str((guint8 *) &(router_data.link_id)));
496
497                     /* link_data should be specified in detail (e.g. network mask) (depends on link type)*/
498                     add_item_to_tree(ospf_lsa_tree, offset + 4, 4, "Link Data: %s", 
499                                                    ip_to_str((guint8 *) &(router_data.link_data)));
500
501                     add_item_to_tree(ospf_lsa_tree, offset + 8, 1, "Link Type: %d - %s", 
502                                                               router_data.link_type, link_type);
503                     add_item_to_tree(ospf_lsa_tree, offset + 9, 1, "Nr. of TOS metrics: %d", router_data.nr_tos);
504                     add_item_to_tree(ospf_lsa_tree, offset + 10, 2, "TOS 0 metric: %d", ntohs( router_data.tos0_metric ));
505
506                     offset += 12;
507
508                     /* router_data.nr_tos metrics may follow each link 
509                      * ATTENTION: TOS metrics are not tested (I don't have TOS based routing)
510                      * please send me a mail if it is/isn't working
511                      */
512
513                     for(tos_counter = 1 ; link_counter <= ntohs(router_data.nr_tos); tos_counter++){
514                         memcpy(&tos_data, &pd[offset], sizeof(e_ospf_router_metric));
515                         add_item_to_tree(ospf_lsa_tree, offset, 1, "TOS: %d, Metric: %d", 
516                                                 tos_data.tos, ntohs(tos_data.metric));
517                         offset += 4;
518                     }
519                 }
520                 break;
521             case(OSPF_LSTYPE_NETWORK):
522                 memcpy(&network_lsa, &pd[offset], sizeof(e_ospf_network_lsa));
523                 add_item_to_tree(ospf_lsa_tree, offset, 4, "Netmask: %s", 
524                                                  ip_to_str((guint8 *) &(network_lsa.network_mask)));
525                 offset += 4;
526
527                 while( ((int) (fd->cap_len - offset)) >= 4){
528                     attached_router = (guint32 *) &pd[offset];
529                     add_item_to_tree(ospf_lsa_tree, offset, 4, "Attached Router: %s", 
530                                                  ip_to_str((guint8 *) attached_router));
531                     offset += 4;
532                 }
533                 break;
534             case(OSPF_LSTYPE_SUMMERY):
535                 /* Type 3 and 4 LSAs have the same format */
536             case(OSPF_LSTYPE_ASBR):
537                 memcpy(&summary_lsa, &pd[offset], sizeof(e_ospf_summary_lsa));
538                 add_item_to_tree(ospf_lsa_tree, offset, 4, "Netmask: %s", 
539                                                  ip_to_str((guint8 *) &(summary_lsa.network_mask)));
540                 /* returns only the TOS 0 metric (even if there are more TOS metrics) */
541                 break;
542             case(OSPF_LSTYPE_ASEXT):
543                 memcpy(&summary_lsa, &pd[offset], sizeof(e_ospf_summary_lsa));
544                 add_item_to_tree(ospf_lsa_tree, offset, 4, "Netmask: %s", 
545                                                   ip_to_str((guint8 *) &(summary_lsa.network_mask)));
546
547                 /* asext_lsa = (e_ospf_asexternal_lsa *) &pd[offset + 4]; */
548                 memcpy(&asext_lsa, &pd[offset + 4], sizeof(asext_lsa));
549                 if( (asext_lsa.options & 128) == 128 ) { /* check wether or not E bit is set */
550                    add_item_to_tree(ospf_lsa_tree, offset, 1, 
551                             "External Type: Type 2 (metric is larger than any other link state path)");
552                 } else {
553                    add_item_to_tree(ospf_lsa_tree, offset + 4, 1, 
554                             "External Type: Type 1 (metric is specified in the same units as interface cost)");
555                 }
556                 /* the metric field of a AS-external LAS is specified in 3 bytes -> not well aligned */
557                 /* this routine returns only the TOS 0 metric (even if there are more TOS metrics) */
558                 memcpy(&asext_metric, &pd[offset+4], 4); 
559                 
560                 /* erase the leading 8 bits (the dont belong to the metric */
561                 asext_metric = ntohl(asext_metric) & 0x00ffffff ;
562
563                 add_item_to_tree(ospf_lsa_tree, offset + 5,  3,"Metric: %d", asext_metric);
564                 add_item_to_tree(ospf_lsa_tree, offset + 8,  4,"Forwarding Address: %s", 
565                                                  ip_to_str((guint8 *) &(asext_lsa.gateway)));
566                 add_item_to_tree(ospf_lsa_tree, offset + 12, 4,"External Route Tag: %ld", (long)ntohl(asext_lsa.external_tag)); 
567                     
568                 break;
569             default:
570                /* unknown LSA type */
571                 add_item_to_tree(ospf_lsa_tree, offset, (fd->cap_len - offset), "Unknown LSA Type");
572         }
573     }
574     /* return the length of this LSA */
575     return ntohs(lsa_hdr.length);
576 }