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