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