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