]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/tcpdump/print-ospf6.c
This commit was generated by cvs2svn to compensate for changes in r57844,
[FreeBSD/FreeBSD.git] / contrib / tcpdump / print-ospf6.c
1 /*
2  * Copyright (c) 1992, 1993, 1994, 1995, 1996, 1997
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that: (1) source code distributions
7  * retain the above copyright notice and this paragraph in its entirety, (2)
8  * distributions including binary code include the above copyright notice and
9  * this paragraph in its entirety in the documentation or other materials
10  * provided with the distribution, and (3) all advertising materials mentioning
11  * features or use of this software display the following acknowledgement:
12  * ``This product includes software developed by the University of California,
13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14  * the University nor the names of its contributors may be used to endorse
15  * or promote products derived from this software without specific prior
16  * written permission.
17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20  *
21  * OSPF support contributed by Jeffrey Honig (jch@mitchell.cit.cornell.edu)
22  */
23
24 #ifndef lint
25 static const char rcsid[] =
26     "@(#) $Header: /tcpdump/master/tcpdump/print-ospf6.c,v 1.2 1999/11/21 09:36:58 fenner Exp $ (LBL)";
27 #endif
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include <sys/param.h>
34 #include <sys/time.h>
35 #include <sys/socket.h>
36
37 #include <netinet/in.h>
38 #include <netinet/in_systm.h>
39 #include <netinet/ip.h>
40 #include <netinet/ip_var.h>
41
42 #include <ctype.h>
43 #include <stdio.h>
44 #include <string.h>
45
46 #include "interface.h"
47 #include "addrtoname.h"
48
49 #include "ospf6.h"
50
51 struct bits {
52         u_int32_t bit;
53         const char *str;
54 };
55
56 static const struct bits ospf6_option_bits[] = {
57         { OSPF6_OPTION_V6,      "V6" },
58         { OSPF6_OPTION_E,       "E" },
59         { OSPF6_OPTION_MC,      "MC" },
60         { OSPF6_OPTION_N,       "N" },
61         { OSPF6_OPTION_R,       "R" },
62         { OSPF6_OPTION_DC,      "DC" },
63         { 0,                    NULL }
64 };
65
66 static const struct bits ospf6_rla_flag_bits[] = {
67         { RLA_FLAG_B,           "B" },
68         { RLA_FLAG_E,           "E" },
69         { RLA_FLAG_V,           "V" },
70         { RLA_FLAG_W,           "W" },
71         { 0,                    NULL }
72 };
73
74 static struct tok type2str[] = {
75         { OSPF_TYPE_UMD,        "umd" },
76         { OSPF_TYPE_HELLO,      "hello" },
77         { OSPF_TYPE_DB,         "dd" },
78         { OSPF_TYPE_LSR,        "ls_req" },
79         { OSPF_TYPE_LSU,        "ls_upd" },
80         { OSPF_TYPE_LSA,        "ls_ack" },
81         { 0,                    NULL }
82 };
83
84 static char tstr[] = " [|ospf]";
85
86 /* Forwards */
87 static inline void ospf6_print_seqage(u_int32_t, time_t);
88 static inline void ospf6_print_bits(const struct bits *, u_char);
89 static void ospf6_print_ls_type(u_int, const rtrid_t *,
90     const rtrid_t *, const char *);
91 static int ospf6_print_lshdr(const struct lsa_hdr *);
92 static int ospf6_print_lsa(const struct lsa *);
93 static int ospf6_decode_v3(const struct ospf6hdr *, const u_char *);
94
95 static inline void
96 ospf6_print_seqage(register u_int32_t seq, register time_t us)
97 {
98         register time_t sec = us % 60;
99         register time_t mins = (us / 60) % 60;
100         register time_t hour = us / 3600;
101
102         printf(" S %X age ", seq);
103         if (hour)
104                 printf("%u:%02u:%02u",
105                     (u_int32_t) hour, (u_int32_t) mins, (u_int32_t) sec);
106         else if (mins)
107                 printf("%u:%02u", (u_int32_t) mins, (u_int32_t) sec);
108         else
109                 printf("%u", (u_int32_t) sec);
110 }
111
112
113 static inline void
114 ospf6_print_bits(register const struct bits *bp, register u_char options)
115 {
116         register char sep = ' ';
117
118         do {
119                 if (options & bp->bit) {
120                         printf("%c%s", sep, bp->str);
121                         sep = '/';
122                 }
123         } while ((++bp)->bit);
124 }
125
126 static void
127 ospf6_print_ls_type(register u_int ls_type,
128     register const rtrid_t *ls_stateid,
129     register const rtrid_t *ls_router, register const char *fmt)
130 {
131         char *scope;
132
133         switch (ls_type & LS_SCOPE_MASK) {
134         case LS_SCOPE_LINKLOCAL:
135                 scope = "linklocal-";
136                 break;
137         case LS_SCOPE_AREA:
138                 scope = "area-";
139                 break;
140         case LS_SCOPE_AS:
141                 scope = "AS-";
142                 break;
143         default:
144                 scope = "";
145                 break;
146         }
147
148         switch (ls_type & LS_TYPE_MASK) {
149         case LS_TYPE_ROUTER:
150                 printf(" %srtr %s", scope, ipaddr_string(ls_router));
151                 break;
152
153         case LS_TYPE_NETWORK:
154                 printf(" %snet dr %s if %s", scope,
155                     ipaddr_string(ls_router),
156                     ipaddr_string(ls_stateid));
157                 break;
158
159         case LS_TYPE_INTER_AP:
160                 printf(" %sinter-area-prefix %s abr %s", scope,
161                     ipaddr_string(ls_stateid),
162                     ipaddr_string(ls_router));
163                 break;
164
165         case LS_TYPE_INTER_AR:
166                 printf(" %sinter-area-router %s rtr %s", scope,
167                     ipaddr_string(ls_router),
168                     ipaddr_string(ls_stateid));
169                 break;
170
171         case LS_TYPE_ASE:
172                 printf(" %sase %s asbr %s", scope,
173                     ipaddr_string(ls_stateid),
174                     ipaddr_string(ls_router));
175                 break;
176
177         case LS_TYPE_GROUP:
178                 printf(" %sgroup %s rtr %s", scope,
179                     ipaddr_string(ls_stateid),
180                     ipaddr_string(ls_router));
181                 break;
182
183         case LS_TYPE_TYPE7:
184                 printf(" %stype7 %s rtr %s", scope,
185                     ipaddr_string(ls_stateid),
186                     ipaddr_string(ls_router));
187                 break;
188
189         case LS_TYPE_LINK:
190                 printf(" %slink %s rtr %s", scope,
191                     ipaddr_string(ls_stateid),
192                     ipaddr_string(ls_router));
193                 break;
194
195         case LS_TYPE_INTRA_AP:
196                 printf(" %sintra-area-prefix %s rtr %s", scope,
197                     ipaddr_string(ls_stateid),
198                     ipaddr_string(ls_router));
199                 break;
200
201         default:
202                 printf(" %s", scope);
203                 printf(fmt, ls_type);
204                 break;
205         }
206
207 }
208
209 static int
210 ospf6_print_lshdr(register const struct lsa_hdr *lshp)
211 {
212
213         TCHECK(lshp->ls_type);
214         printf(" {");                                           /* } (ctags) */
215
216         TCHECK(lshp->ls_seq);
217         ospf6_print_seqage(ntohl(lshp->ls_seq), ntohs(lshp->ls_age));
218         ospf6_print_ls_type(ntohs(lshp->ls_type), &lshp->ls_stateid,
219                 &lshp->ls_router, "ls_type %d");
220
221         return (0);
222 trunc:
223         return (1);
224 }
225
226 static int
227 ospf6_print_lsaprefix(register const struct lsa_prefix *lsapp)
228 {
229         int k;
230         struct in6_addr prefix;
231
232         TCHECK(*lsapp);
233         k = (lsapp->lsa_p_len + 31) / 32;
234         if (k * 4 > sizeof(struct in6_addr)) {
235                 printf("??prefixlen %d??", lsapp->lsa_p_len);
236                 goto trunc;
237         }
238         memset(&prefix, 0, sizeof(prefix));
239         memcpy(&prefix, lsapp->lsa_p_prefix, k * 4);
240         printf(" %s/%d", ip6addr_string(&prefix), 
241                 lsapp->lsa_p_len);
242         if (lsapp->lsa_p_opt)
243                 printf("(opt=%x)", lsapp->lsa_p_opt);
244         return sizeof(*lsapp) - 4 + k * 4;
245
246 trunc:
247         return -1;
248 }
249
250
251 /*
252  * Print a single link state advertisement.  If truncated return 1, else 0.
253  */
254 static int
255 ospf6_print_lsa(register const struct lsa *lsap)
256 {
257         register const u_char *ls_end;
258         register const struct rlalink *rlp;
259 #if 0
260         register const struct tos_metric *tosp;
261 #endif
262         register const rtrid_t *ap;
263 #if 0
264         register const struct aslametric *almp;
265         register const struct mcla *mcp;
266 #endif
267         register const struct llsa *llsap;
268         register const struct lsa_prefix *lsapp;
269 #if 0
270         register const u_int32_t *lp;
271 #endif
272         register int j, k;
273
274         if (ospf6_print_lshdr(&lsap->ls_hdr))
275                 return (1);
276         TCHECK(lsap->ls_hdr.ls_length);
277         ls_end = (u_char *)lsap + ntohs(lsap->ls_hdr.ls_length);
278         switch (ntohs(lsap->ls_hdr.ls_type)) {
279         case LS_TYPE_ROUTER | LS_SCOPE_AREA:
280                 TCHECK(lsap->lsa_un.un_rla.rla_flags);
281                 ospf6_print_bits(ospf6_rla_flag_bits,
282                         lsap->lsa_un.un_rla.rla_flags);
283                 TCHECK(lsap->lsa_un.un_rla.rla_options);
284                 ospf6_print_bits(ospf6_option_bits,
285                         ntohl(lsap->lsa_un.un_rla.rla_options));
286
287                 TCHECK(lsap->lsa_un.un_rla.rla_link);
288                 rlp = lsap->lsa_un.un_rla.rla_link;
289                 while (rlp + sizeof(*rlp) <= (struct rlalink *)ls_end) {
290                         TCHECK(*rlp);
291                         printf(" {");                           /* } (ctags) */
292                         switch (rlp->link_type) {
293
294                         case RLA_TYPE_VIRTUAL:
295                                 printf(" virt");
296                                 /* Fall through */
297
298                         case RLA_TYPE_ROUTER:
299                                 printf(" nbrid %s nbrif %s if %s",
300                                     ipaddr_string(&rlp->link_nrtid),
301                                     ipaddr_string(&rlp->link_nifid),
302                                     ipaddr_string(&rlp->link_ifid));
303                                 break;
304
305                         case RLA_TYPE_TRANSIT:
306                                 printf(" dr %s drif %s if %s",
307                                     ipaddr_string(&rlp->link_nrtid),
308                                     ipaddr_string(&rlp->link_nifid),
309                                     ipaddr_string(&rlp->link_ifid));
310                                 break;
311
312                         default:
313                                                                 /* { (ctags) */
314                                 printf(" ??RouterLinksType 0x%02x?? }",
315                                     rlp->link_type);
316                                 return (0);
317                         }
318                         printf(" metric %d", ntohs(rlp->link_metric));
319                                                                 /* { (ctags) */
320                         printf(" }");
321                         rlp++;
322                 }
323                 break;
324
325         case LS_TYPE_NETWORK | LS_SCOPE_AREA:
326                 TCHECK(lsap->lsa_un.un_nla.nla_options);
327                 ospf6_print_bits(ospf6_option_bits,
328                         ntohl(lsap->lsa_un.un_nla.nla_options));
329                 printf(" rtrs");
330                 ap = lsap->lsa_un.un_nla.nla_router;
331                 while ((u_char *)ap < ls_end) {
332                         TCHECK(*ap);
333                         printf(" %s", ipaddr_string(ap));
334                         ++ap;
335                 }
336                 break;
337
338         case LS_TYPE_INTER_AP | LS_SCOPE_AREA:
339                 TCHECK(lsap->lsa_un.un_inter_ap.inter_ap_metric);
340                 printf(" metric %u",
341                         (u_int32_t)ntohl(lsap->lsa_un.un_inter_ap.inter_ap_metric) & SLA_MASK_METRIC);
342                 lsapp = lsap->lsa_un.un_inter_ap.inter_ap_prefix;
343                 while (lsapp + sizeof(lsapp) <= (struct lsa_prefix *)ls_end) {
344                         k = ospf6_print_lsaprefix(lsapp);
345                         if (k < 0)
346                                 goto trunc;
347                         lsapp = (struct lsa_prefix *)(((u_char *)lsapp) + k);
348                 }
349                 break;
350
351 #if 0
352         case LS_TYPE_SUM_ABR:
353                 TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
354                 lp = lsap->lsa_un.un_sla.sla_tosmetric;
355                 while ((u_char *)lp < ls_end) {
356                         register u_int32_t ul;
357
358                         TCHECK(*lp);
359                         ul = ntohl(*lp);
360                         printf(" tos %d metric %d",
361                             (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS,
362                             ul & SLA_MASK_METRIC);
363                         ++lp;
364                 }
365                 break;
366
367         case LS_TYPE_ASE:
368                 TCHECK(lsap->lsa_un.un_nla.nla_mask);
369                 printf(" mask %s",
370                     ipaddr_string(&lsap->lsa_un.un_asla.asla_mask));
371
372                 TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
373                 almp = lsap->lsa_un.un_asla.asla_metric;
374                 while ((u_char *)almp < ls_end) {
375                         register u_int32_t ul;
376
377                         TCHECK(almp->asla_tosmetric);
378                         ul = ntohl(almp->asla_tosmetric);
379                         printf(" type %d tos %d metric %d",
380                             (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1,
381                             (ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS,
382                             (ul & ASLA_MASK_METRIC));
383                         TCHECK(almp->asla_forward);
384                         if (almp->asla_forward.s_addr) {
385                                 printf(" forward %s",
386                                     ipaddr_string(&almp->asla_forward));
387                         }
388                         TCHECK(almp->asla_tag);
389                         if (almp->asla_tag.s_addr) {
390                                 printf(" tag %s",
391                                     ipaddr_string(&almp->asla_tag));
392                         }
393                         ++almp;
394                 }
395                 break;
396
397         case LS_TYPE_GROUP:
398                 /* Multicast extensions as of 23 July 1991 */
399                 mcp = lsap->lsa_un.un_mcla;
400                 while ((u_char *)mcp < ls_end) {
401                         TCHECK(mcp->mcla_vid);
402                         switch (ntohl(mcp->mcla_vtype)) {
403
404                         case MCLA_VERTEX_ROUTER:
405                                 printf(" rtr rtrid %s",
406                                     ipaddr_string(&mcp->mcla_vid));
407                                 break;
408
409                         case MCLA_VERTEX_NETWORK:
410                                 printf(" net dr %s",
411                                     ipaddr_string(&mcp->mcla_vid));
412                                 break;
413
414                         default:
415                                 printf(" ??VertexType %u??",
416                                     (u_int32_t)ntohl(mcp->mcla_vtype));
417                                 break;
418                         }
419                 ++mcp;
420                 }
421 #endif
422
423         case LS_TYPE_LINK:
424                 /* Link LSA */
425                 llsap = &lsap->lsa_un.un_llsa;
426                 TCHECK(llsap->llsa_options);
427                 ospf6_print_bits(ospf6_option_bits, ntohl(llsap->llsa_options));
428                 TCHECK(llsap->llsa_nprefix);
429                 printf(" pri %d lladdr %s npref %d", llsap->llsa_priority,
430                         ip6addr_string(&llsap->llsa_lladdr),
431                         (u_int32_t)ntohl(llsap->llsa_nprefix));
432                 lsapp = llsap->llsa_prefix;
433                 for (j = 0; j < ntohl(llsap->llsa_nprefix); j++) {
434                         k = ospf6_print_lsaprefix(lsapp);
435                         if (k < 0)
436                                 goto trunc;
437                         lsapp = (struct lsa_prefix *)(((u_char *)lsapp) + k);
438                 }
439                 break;
440
441         case LS_TYPE_INTRA_AP | LS_SCOPE_AREA:
442                 /* Intra-Area-Prefix LSA */
443                 TCHECK(lsap->lsa_un.un_intra_ap.intra_ap_rtid);
444                 ospf6_print_ls_type(
445                         ntohs(lsap->lsa_un.un_intra_ap.intra_ap_lstype),
446                         &lsap->lsa_un.un_intra_ap.intra_ap_lsid,
447                         &lsap->lsa_un.un_intra_ap.intra_ap_rtid,
448                         "LinkStateType %d");
449                 TCHECK(lsap->lsa_un.un_intra_ap.intra_ap_nprefix);
450                 printf(" npref %d",
451                         ntohs(lsap->lsa_un.un_intra_ap.intra_ap_nprefix));
452
453                 lsapp = lsap->lsa_un.un_intra_ap.intra_ap_prefix;
454                 for (j = 0;
455                      j < ntohs(lsap->lsa_un.un_intra_ap.intra_ap_nprefix);
456                      j++) {
457                         k = ospf6_print_lsaprefix(lsapp);
458                         if (k < 0)
459                                 goto trunc;
460                         lsapp = (struct lsa_prefix *)(((u_char *)lsapp) + k);
461                 }
462                 break;
463
464         default:
465                 printf(" ??LinkStateType 0x%04x??",
466                         ntohs(lsap->ls_hdr.ls_type));
467         }
468
469                                                                 /* { (ctags) */
470         fputs(" }", stdout);
471         return (0);
472 trunc:
473         fputs(" }", stdout);
474         return (1);
475 }
476
477 static int
478 ospf6_decode_v3(register const struct ospf6hdr *op,
479     register const u_char *dataend)
480 {
481         register const rtrid_t *ap;
482         register const struct lsr *lsrp;
483         register const struct lsa_hdr *lshp;
484         register const struct lsa *lsap;
485         register char sep;
486         register int i;
487
488         switch (op->ospf6_type) {
489
490         case OSPF_TYPE_UMD:
491                 /*
492                  * Rob Coltun's special monitoring packets;
493                  * do nothing
494                  */
495                 break;
496
497         case OSPF_TYPE_HELLO:
498                 if (vflag) {
499                         TCHECK(op->ospf6_hello.hello_deadint);
500                         ospf6_print_bits(ospf6_option_bits,
501                             ntohl(op->ospf6_hello.hello_options));
502                         printf(" ifid %s pri %d int %d dead %u",
503                             ipaddr_string(&op->ospf6_hello.hello_ifid),
504                             op->ospf6_hello.hello_priority,
505                             ntohs(op->ospf6_hello.hello_helloint),
506                             ntohs(op->ospf6_hello.hello_deadint));
507                 }
508                 TCHECK(op->ospf6_hello.hello_dr);
509                 if (op->ospf6_hello.hello_dr != 0)
510                         printf(" dr %s",
511                             ipaddr_string(&op->ospf6_hello.hello_dr));
512                 TCHECK(op->ospf6_hello.hello_bdr);
513                 if (op->ospf6_hello.hello_bdr != 0)
514                         printf(" bdr %s",
515                             ipaddr_string(&op->ospf6_hello.hello_bdr));
516                 if (vflag) {
517                         printf(" nbrs");
518                         ap = op->ospf6_hello.hello_neighbor;
519                         while ((u_char *)ap < dataend) {
520                                 TCHECK(*ap);
521                                 printf(" %s", ipaddr_string(ap));
522                                 ++ap;
523                         }
524                 }
525                 break;  /* HELLO */
526
527         case OSPF_TYPE_DB:
528                 TCHECK(op->ospf6_db.db_options);
529                 ospf6_print_bits(ospf6_option_bits,
530                         ntohl(op->ospf6_db.db_options));
531                 sep = ' ';
532                 TCHECK(op->ospf6_db.db_flags);
533                 if (op->ospf6_db.db_flags & OSPF6_DB_INIT) {
534                         printf("%cI", sep);
535                         sep = '/';
536                 }
537                 if (op->ospf6_db.db_flags & OSPF6_DB_MORE) {
538                         printf("%cM", sep);
539                         sep = '/';
540                 }
541                 if (op->ospf6_db.db_flags & OSPF6_DB_MASTER) {
542                         printf("%cMS", sep);
543                         sep = '/';
544                 }
545                 TCHECK(op->ospf6_db.db_seq);
546                 printf(" mtu %u S %X", ntohs(op->ospf6_db.db_mtu),
547                         (u_int32_t)ntohl(op->ospf6_db.db_seq));
548
549                 if (vflag) {
550                         /* Print all the LS adv's */
551                         lshp = op->ospf6_db.db_lshdr;
552
553                         while (!ospf6_print_lshdr(lshp)) {
554                                                         /* { (ctags) */
555                                 printf(" }");
556                                 ++lshp;
557                         }
558                 }
559                 break;
560
561         case OSPF_TYPE_LSR:
562                 if (vflag) {
563                         lsrp = op->ospf6_lsr;
564                         while ((u_char *)lsrp < dataend) {
565                                 TCHECK(*lsrp);
566                                 printf(" {");           /* } (ctags) */
567                                 ospf6_print_ls_type(ntohs(lsrp->ls_type),
568                                     &lsrp->ls_stateid,
569                                     &lsrp->ls_router,
570                                     "LinkStateType %d");
571                                                         /* { (ctags) */
572                                 printf(" }");
573                                 ++lsrp;
574                         }
575                 }
576                 break;
577
578         case OSPF_TYPE_LSU:
579                 if (vflag) {
580                         lsap = op->ospf6_lsu.lsu_lsa;
581                         TCHECK(op->ospf6_lsu.lsu_count);
582                         i = ntohl(op->ospf6_lsu.lsu_count);
583                         while (i--) {
584                                 if (ospf6_print_lsa(lsap))
585                                         goto trunc;
586                                 lsap = (struct lsa *)((u_char *)lsap +
587                                     ntohs(lsap->ls_hdr.ls_length));
588                         }
589                 }
590                 break;
591
592
593         case OSPF_TYPE_LSA:
594                 if (vflag) {
595                         lshp = op->ospf6_lsa.lsa_lshdr;
596
597                         while (!ospf6_print_lshdr(lshp)) {
598                                                         /* { (ctags) */
599                                 printf(" }");
600                                 ++lshp;
601                         }
602                 }
603                 break;
604
605         default:
606                 printf("v3 type %d", op->ospf6_type);
607                 break;
608         }
609         return (0);
610 trunc:
611         return (1);
612 }
613
614 void
615 ospf6_print(register const u_char *bp, register u_int length)
616 {
617         register const struct ospf6hdr *op;
618         register const u_char *dataend;
619         register const char *cp;
620
621         op = (struct ospf6hdr *)bp;
622
623         /* If the type is valid translate it, or just print the type */
624         /* value.  If it's not valid, say so and return */
625         TCHECK(op->ospf6_type);
626         cp = tok2str(type2str, "type%d", op->ospf6_type);
627         printf(" OSPFv%d-%s %d:", op->ospf6_version, cp, length);
628         if (*cp == 't')
629                 return;
630
631         TCHECK(op->ospf6_len);
632         if (length != ntohs(op->ospf6_len)) {
633                 printf(" [len %d]", ntohs(op->ospf6_len));
634                 return;
635         }
636         dataend = bp + length;
637
638         /* Print the routerid if it is not the same as the source */
639         TCHECK(op->ospf6_routerid);
640         printf(" rtrid %s", ipaddr_string(&op->ospf6_routerid));
641
642         TCHECK(op->ospf6_areaid);
643         if (op->ospf6_areaid != 0)
644                 printf(" area %s", ipaddr_string(&op->ospf6_areaid));
645         else
646                 printf(" backbone");
647         TCHECK(op->ospf6_instanceid);
648         if (op->ospf6_instanceid)
649                 printf(" instance %u", op->ospf6_instanceid);
650
651         /* Do rest according to version.         */
652         switch (op->ospf6_version) {
653
654         case 3:
655                 /* ospf version 3 */
656                 if (ospf6_decode_v3(op, dataend))
657                         goto trunc;
658                 break;
659
660         default:
661                 printf(" ospf [version %d]", op->ospf6_version);
662                 break;
663         }                       /* end switch on version */
664
665         return;
666 trunc:
667         fputs(tstr, stdout);
668 }