]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-ospf6.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Improve printout of DHCPv6 options.
[tcpdump] / print-ospf6.c
diff --git a/print-ospf6.c b/print-ospf6.c
index cd3b322f392d5e03077a49fba1415b2cc404e764..11004856705bcc88a3e96144617139e57016a710 100644 (file)
--- a/print-ospf6.c
+++ b/print-ospf6.c
@@ -22,201 +22,137 @@
  */
 
 #ifndef lint
  */
 
 #ifndef lint
-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-ospf6.c,v 1.3 2000-03-15 18:32:09 itojun Exp $ (LBL)";
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-ospf6.c,v 1.15 2006-09-13 06:31:11 guy Exp $ (LBL)";
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/socket.h>
+#include <tcpdump-stdinc.h>
 
 
-#include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <netinet/ip_var.h>
-
-#include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "interface.h"
 #include "addrtoname.h"
 #include <stdio.h>
 #include <string.h>
 
 #include "interface.h"
 #include "addrtoname.h"
+#include "extract.h"
 
 
+#include "ospf.h"
 #include "ospf6.h"
 
 #include "ospf6.h"
 
-struct bits {
-       u_int32_t bit;
-       const char *str;
-};
-
-static const struct bits ospf6_option_bits[] = {
+static const struct tok ospf6_option_values[] = {
        { OSPF6_OPTION_V6,      "V6" },
        { OSPF6_OPTION_V6,      "V6" },
-       { OSPF6_OPTION_E,       "E" },
-       { OSPF6_OPTION_MC,      "MC" },
-       { OSPF6_OPTION_N,       "N" },
-       { OSPF6_OPTION_R,       "R" },
-       { OSPF6_OPTION_DC,      "DC" },
+       { OSPF6_OPTION_E,       "External" },
+       { OSPF6_OPTION_MC,      "Multicast" },
+       { OSPF6_OPTION_N,       "NSSA" },
+       { OSPF6_OPTION_R,       "Router" },
+       { OSPF6_OPTION_DC,      "Demand Circuit" },
        { 0,                    NULL }
 };
 
        { 0,                    NULL }
 };
 
-static const struct bits ospf6_rla_flag_bits[] = {
-       { RLA_FLAG_B,           "B" },
-       { RLA_FLAG_E,           "E" },
-       { RLA_FLAG_V,           "V" },
-       { RLA_FLAG_W,           "W" },
+static const struct tok ospf6_rla_flag_values[] = {
+       { RLA_FLAG_B,           "ABR" },
+       { RLA_FLAG_E,           "External" },
+       { RLA_FLAG_V,           "Virtual-Link Endpoint" },
+       { RLA_FLAG_W,           "Wildcard Receiver" },
+        { RLA_FLAG_N,           "NSSA Translator" },
        { 0,                    NULL }
 };
 
        { 0,                    NULL }
 };
 
-static struct tok type2str[] = {
-       { OSPF_TYPE_UMD,        "umd" },
-       { OSPF_TYPE_HELLO,      "hello" },
-       { OSPF_TYPE_DB,         "dd" },
-       { OSPF_TYPE_LSR,        "ls_req" },
-       { OSPF_TYPE_LSU,        "ls_upd" },
-       { OSPF_TYPE_LSA,        "ls_ack" },
+static const struct tok ospf6_asla_flag_values[] = {
+       { ASLA_FLAG_EXTERNAL,   "External Type 2" },
+       { ASLA_FLAG_FWDADDR,    "Fforwarding" },
+       { ASLA_FLAG_ROUTETAG,   "Tag" },
        { 0,                    NULL }
 };
 
        { 0,                    NULL }
 };
 
-static char tstr[] = " [|ospf]";
-
-/* Forwards */
-static inline void ospf6_print_seqage(u_int32_t, time_t);
-static inline void ospf6_print_bits(const struct bits *, u_char);
-static void ospf6_print_ls_type(u_int, const rtrid_t *,
-    const rtrid_t *, const char *);
-static int ospf6_print_lshdr(const struct lsa_hdr *);
-static int ospf6_print_lsa(const struct lsa *);
-static int ospf6_decode_v3(const struct ospf6hdr *, const u_char *);
-
-static inline void
-ospf6_print_seqage(register u_int32_t seq, register time_t us)
-{
-       register time_t sec = us % 60;
-       register time_t mins = (us / 60) % 60;
-       register time_t hour = us / 3600;
-
-       printf(" S %X age ", seq);
-       if (hour)
-               printf("%u:%02u:%02u",
-                   (u_int32_t) hour, (u_int32_t) mins, (u_int32_t) sec);
-       else if (mins)
-               printf("%u:%02u", (u_int32_t) mins, (u_int32_t) sec);
-       else
-               printf("%u", (u_int32_t) sec);
-}
-
-
-static inline void
-ospf6_print_bits(register const struct bits *bp, register u_char options)
-{
-       register char sep = ' ';
-
-       do {
-               if (options & bp->bit) {
-                       printf("%c%s", sep, bp->str);
-                       sep = '/';
-               }
-       } while ((++bp)->bit);
-}
-
-static void
-ospf6_print_ls_type(register u_int ls_type,
-    register const rtrid_t *ls_stateid,
-    register const rtrid_t *ls_router, register const char *fmt)
-{
-       char *scope;
-
-       switch (ls_type & LS_SCOPE_MASK) {
-       case LS_SCOPE_LINKLOCAL:
-               scope = "linklocal-";
-               break;
-       case LS_SCOPE_AREA:
-               scope = "area-";
-               break;
-       case LS_SCOPE_AS:
-               scope = "AS-";
-               break;
-       default:
-               scope = "";
-               break;
-       }
-
-       switch (ls_type & LS_TYPE_MASK) {
-       case LS_TYPE_ROUTER:
-               printf(" %srtr %s", scope, ipaddr_string(ls_router));
-               break;
-
-       case LS_TYPE_NETWORK:
-               printf(" %snet dr %s if %s", scope,
-                   ipaddr_string(ls_router),
-                   ipaddr_string(ls_stateid));
-               break;
+static struct tok ospf6_type_values[] = {
+       { OSPF_TYPE_HELLO,      "Hello" },
+       { OSPF_TYPE_DD,         "Database Description" },
+       { OSPF_TYPE_LS_REQ,     "LS-Request" },
+       { OSPF_TYPE_LS_UPDATE,  "LS-Update" },
+       { OSPF_TYPE_LS_ACK,     "LS-Ack" },
+       { 0,                    NULL }
+};
 
 
-       case LS_TYPE_INTER_AP:
-               printf(" %sinter-area-prefix %s abr %s", scope,
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
+static struct tok ospf6_lsa_values[] = {
+       { LS_TYPE_ROUTER,       "Router" },
+       { LS_TYPE_NETWORK,      "Network" },
+       { LS_TYPE_INTER_AP,     "Inter-Area Prefix" },
+       { LS_TYPE_INTER_AR,     "Inter-Area Router" },
+       { LS_TYPE_ASE,          "External" },
+       { LS_TYPE_GROUP,        "Multicast Group" },
+       { LS_TYPE_NSSA,         "NSSA" },
+       { LS_TYPE_LINK,         "Link" },
+       { LS_TYPE_INTRA_AP,     "Intra-Area Prefix" },
+        { LS_TYPE_INTRA_ATE,    "Intra-Area TE" },
+        { LS_TYPE_GRACE,        "Grace" },
+       { 0,                    NULL }
+};
 
 
-       case LS_TYPE_INTER_AR:
-               printf(" %sinter-area-router %s rtr %s", scope,
-                   ipaddr_string(ls_router),
-                   ipaddr_string(ls_stateid));
-               break;
+static struct tok ospf6_ls_scope_values[] = {
+       { LS_SCOPE_LINKLOCAL,   "Link Local" },
+       { LS_SCOPE_AREA,        "Area Local" },
+       { LS_SCOPE_AS,          "Domain Wide" },
+       { 0,                    NULL }
+};
 
 
-       case LS_TYPE_ASE:
-               printf(" %sase %s asbr %s", scope,
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
+static struct tok ospf6_dd_flag_values[] = {
+       { OSPF6_DB_INIT,        "Init" },
+       { OSPF6_DB_MORE,        "More" },
+       { OSPF6_DB_MASTER,      "Master" },
+       { 0,                    NULL }
+};
 
 
-       case LS_TYPE_GROUP:
-               printf(" %sgroup %s rtr %s", scope,
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
+static struct tok ospf6_lsa_prefix_option_values[] = {
+        { LSA_PREFIX_OPT_NU, "No Unicast" },
+        { LSA_PREFIX_OPT_LA, "Local address" },
+        { LSA_PREFIX_OPT_MC, "Multicast" },
+        { LSA_PREFIX_OPT_P, "Propagate" },
+        { LSA_PREFIX_OPT_DN, "Down" },
+       { 0, NULL }
+};
 
 
-       case LS_TYPE_TYPE7:
-               printf(" %stype7 %s rtr %s", scope,
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
+static char tstr[] = " [|ospf3]";
 
 
-       case LS_TYPE_LINK:
-               printf(" %slink %s rtr %s", scope,
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
+#ifdef WIN32
+#define inline __inline
+#endif /* WIN32 */
 
 
-       case LS_TYPE_INTRA_AP:
-               printf(" %sintra-area-prefix %s rtr %s", scope,
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
+/* Forwards */
+static void ospf6_print_ls_type(u_int, const rtrid_t *);
+static int ospf6_print_lshdr(const struct lsa6_hdr *);
+static int ospf6_print_lsa(const struct lsa6 *);
+static int ospf6_decode_v3(const struct ospf6hdr *, const u_char *);
 
 
-       default:
-               printf(" %s", scope);
-               printf(fmt, ls_type);
-               break;
-       }
 
 
+static void
+ospf6_print_ls_type(register u_int ls_type, register const rtrid_t *ls_stateid)
+{
+        printf("\n\t    %s LSA (%d), %s Scope%s, LSA-ID %s",
+               tok2str(ospf6_lsa_values, "Unknown", ls_type & LS_TYPE_MASK),
+               ls_type & LS_TYPE_MASK,
+               tok2str(ospf6_ls_scope_values, "Unknown", ls_type & LS_SCOPE_MASK),
+               ls_type &0x8000 ? ", transitive" : "", /* U-bit */
+               ipaddr_string(ls_stateid));
 }
 
 static int
 }
 
 static int
-ospf6_print_lshdr(register const struct lsa_hdr *lshp)
+ospf6_print_lshdr(register const struct lsa6_hdr *lshp)
 {
 
        TCHECK(lshp->ls_type);
 {
 
        TCHECK(lshp->ls_type);
-       printf(" {");                                           /* } (ctags) */
-
        TCHECK(lshp->ls_seq);
        TCHECK(lshp->ls_seq);
-       ospf6_print_seqage(ntohl(lshp->ls_seq), ntohs(lshp->ls_age));
-       ospf6_print_ls_type(ntohs(lshp->ls_type), &lshp->ls_stateid,
-               &lshp->ls_router, "ls_type %d");
+
+       printf("\n\t  Advertising Router %s, seq 0x%08x, age %us, length %u",
+               ipaddr_string(&lshp->ls_router),
+               EXTRACT_32BITS(&lshp->ls_seq),
+               EXTRACT_16BITS(&lshp->ls_age),
+               EXTRACT_16BITS(&lshp->ls_length)-(u_int)sizeof(struct lsa6_hdr));
+
+       ospf6_print_ls_type(EXTRACT_16BITS(&lshp->ls_type), &lshp->ls_stateid);
 
        return (0);
 trunc:
 
        return (0);
 trunc:
@@ -224,24 +160,28 @@ trunc:
 }
 
 static int
 }
 
 static int
-ospf6_print_lsaprefix(register const struct lsa_prefix *lsapp)
+ospf6_print_lsaprefix(register const struct lsa6_prefix *lsapp)
 {
 {
-       int k;
+       u_int wordlen;
        struct in6_addr prefix;
 
        TCHECK(*lsapp);
        struct in6_addr prefix;
 
        TCHECK(*lsapp);
-       k = (lsapp->lsa_p_len + 31) / 32;
-       if (k * 4 > sizeof(struct in6_addr)) {
-               printf("??prefixlen %d??", lsapp->lsa_p_len);
+       wordlen = (lsapp->lsa_p_len + 31) / 32;
+       if (wordlen * 4 > sizeof(struct in6_addr)) {
+               printf(" bogus prefixlen /%d", lsapp->lsa_p_len);
                goto trunc;
        }
        memset(&prefix, 0, sizeof(prefix));
                goto trunc;
        }
        memset(&prefix, 0, sizeof(prefix));
-       memcpy(&prefix, lsapp->lsa_p_prefix, k * 4);
-       printf(" %s/%d", ip6addr_string(&prefix), 
+       memcpy(&prefix, lsapp->lsa_p_prefix, wordlen * 4);
+       printf("\n\t\t%s/%d", ip6addr_string(&prefix),
                lsapp->lsa_p_len);
                lsapp->lsa_p_len);
-       if (lsapp->lsa_p_opt)
-               printf("(opt=%x)", lsapp->lsa_p_opt);
-       return sizeof(*lsapp) - 4 + k * 4;
+        if (lsapp->lsa_p_opt) {
+            printf(", Options [%s]",
+                   bittok2str(ospf6_lsa_prefix_option_values,
+                              "none", lsapp->lsa_p_opt));
+        }
+        printf(", metric %u", EXTRACT_16BITS(&lsapp->lsa_p_metric));
+       return sizeof(*lsapp) - 4 + wordlen * 4;
 
 trunc:
        return -1;
 
 trunc:
        return -1;
@@ -252,10 +192,10 @@ trunc:
  * Print a single link state advertisement.  If truncated return 1, else 0.
  */
 static int
  * Print a single link state advertisement.  If truncated return 1, else 0.
  */
 static int
-ospf6_print_lsa(register const struct lsa *lsap)
+ospf6_print_lsa(register const struct lsa6 *lsap)
 {
 {
-       register const u_char *ls_end;
-       register const struct rlalink *rlp;
+       register const u_char *ls_end, *ls_opt;
+       register const struct rlalink6 *rlp;
 #if 0
        register const struct tos_metric *tosp;
 #endif
 #if 0
        register const struct tos_metric *tosp;
 #endif
@@ -265,212 +205,214 @@ ospf6_print_lsa(register const struct lsa *lsap)
        register const struct mcla *mcp;
 #endif
        register const struct llsa *llsap;
        register const struct mcla *mcp;
 #endif
        register const struct llsa *llsap;
-       register const struct lsa_prefix *lsapp;
+       register const struct lsa6_prefix *lsapp;
 #if 0
        register const u_int32_t *lp;
 #endif
 #if 0
        register const u_int32_t *lp;
 #endif
-       register int j, k;
+       register u_int prefixes;
+       register int bytelen, length, lsa_length;
+       u_int32_t flags32;
+        u_int8_t *tptr;
 
        if (ospf6_print_lshdr(&lsap->ls_hdr))
                return (1);
        TCHECK(lsap->ls_hdr.ls_length);
 
        if (ospf6_print_lshdr(&lsap->ls_hdr))
                return (1);
        TCHECK(lsap->ls_hdr.ls_length);
-       ls_end = (u_char *)lsap + ntohs(lsap->ls_hdr.ls_length);
-       switch (ntohs(lsap->ls_hdr.ls_type)) {
+        length = EXTRACT_16BITS(&lsap->ls_hdr.ls_length);
+        lsa_length = length - sizeof(struct lsa6_hdr);
+       ls_end = (u_char *)lsap + length;
+        tptr = (u_int8_t *)lsap+sizeof(struct lsa6_hdr);
+
+       switch (EXTRACT_16BITS(&lsap->ls_hdr.ls_type)) {
        case LS_TYPE_ROUTER | LS_SCOPE_AREA:
        case LS_TYPE_ROUTER | LS_SCOPE_AREA:
-               TCHECK(lsap->lsa_un.un_rla.rla_flags);
-               ospf6_print_bits(ospf6_rla_flag_bits,
-                       lsap->lsa_un.un_rla.rla_flags);
                TCHECK(lsap->lsa_un.un_rla.rla_options);
                TCHECK(lsap->lsa_un.un_rla.rla_options);
-               ospf6_print_bits(ospf6_option_bits,
-                       ntohl(lsap->lsa_un.un_rla.rla_options));
+                printf("\n\t      Options [%s]",
+                       bittok2str(ospf6_option_values, "none",
+                                  EXTRACT_32BITS(&lsap->lsa_un.un_rla.rla_options)));
+
+               TCHECK(lsap->lsa_un.un_rla.rla_flags);
+                printf(", RLA-Flags [%s]",
+                       bittok2str(ospf6_rla_flag_values, "none",
+                                  lsap->lsa_un.un_rla.rla_flags));
+
 
                TCHECK(lsap->lsa_un.un_rla.rla_link);
                rlp = lsap->lsa_un.un_rla.rla_link;
 
                TCHECK(lsap->lsa_un.un_rla.rla_link);
                rlp = lsap->lsa_un.un_rla.rla_link;
-               while (rlp + sizeof(*rlp) <= (struct rlalink *)ls_end) {
+               while (rlp + 1 <= (struct rlalink6 *)ls_end) {
                        TCHECK(*rlp);
                        TCHECK(*rlp);
-                       printf(" {");                           /* } (ctags) */
                        switch (rlp->link_type) {
 
                        case RLA_TYPE_VIRTUAL:
                        switch (rlp->link_type) {
 
                        case RLA_TYPE_VIRTUAL:
-                               printf(" virt");
-                               /* Fall through */
+                               printf("\n\t      Virtual Link: Neighbor Router-ID %s"
+                                       "\n\t      Neighbor Interface-ID %s, Interface %s",
+                                       ipaddr_string(&rlp->link_nrtid),
+                                       ipaddr_string(&rlp->link_nifid),
+                                       ipaddr_string(&rlp->link_ifid)); 
+                                break;
 
                        case RLA_TYPE_ROUTER:
 
                        case RLA_TYPE_ROUTER:
-                               printf(" nbrid %s nbrif %s if %s",
-                                   ipaddr_string(&rlp->link_nrtid),
-                                   ipaddr_string(&rlp->link_nifid),
-                                   ipaddr_string(&rlp->link_ifid));
+                               printf("\n\t      Neighbor Router-ID %s"
+                                       "\n\t      Neighbor Interface-ID %s, Interface %s",
+                                       ipaddr_string(&rlp->link_nrtid),
+                                       ipaddr_string(&rlp->link_nifid),
+                                       ipaddr_string(&rlp->link_ifid)); 
                                break;
 
                        case RLA_TYPE_TRANSIT:
                                break;
 
                        case RLA_TYPE_TRANSIT:
-                               printf(" dr %s drif %s if %s",
+                               printf("\n\t      Neighbor Network-ID %s"
+                                       "\n\t      Neighbor Interface-ID %s, Interface %s",
                                    ipaddr_string(&rlp->link_nrtid),
                                    ipaddr_string(&rlp->link_nifid),
                                    ipaddr_string(&rlp->link_ifid));
                                break;
 
                        default:
                                    ipaddr_string(&rlp->link_nrtid),
                                    ipaddr_string(&rlp->link_nifid),
                                    ipaddr_string(&rlp->link_ifid));
                                break;
 
                        default:
-                                                               /* { (ctags) */
-                               printf(" ??RouterLinksType 0x%02x?? }",
+                               printf("\n\t      Unknown Router Links Type 0x%02x",
                                    rlp->link_type);
                                return (0);
                        }
                                    rlp->link_type);
                                return (0);
                        }
-                       printf(" metric %d", ntohs(rlp->link_metric));
-                                                               /* { (ctags) */
-                       printf(" }");
+                       printf(", metric %d", EXTRACT_16BITS(&rlp->link_metric));
                        rlp++;
                }
                break;
 
        case LS_TYPE_NETWORK | LS_SCOPE_AREA:
                TCHECK(lsap->lsa_un.un_nla.nla_options);
                        rlp++;
                }
                break;
 
        case LS_TYPE_NETWORK | LS_SCOPE_AREA:
                TCHECK(lsap->lsa_un.un_nla.nla_options);
-               ospf6_print_bits(ospf6_option_bits,
-                       ntohl(lsap->lsa_un.un_nla.nla_options));
-               printf(" rtrs");
+                printf("\n\t      Options [%s]",
+                       bittok2str(ospf6_option_values, "none",
+                                  EXTRACT_32BITS(&lsap->lsa_un.un_nla.nla_options)));
+               printf("\n\t      Connected Routers:");
                ap = lsap->lsa_un.un_nla.nla_router;
                while ((u_char *)ap < ls_end) {
                        TCHECK(*ap);
                ap = lsap->lsa_un.un_nla.nla_router;
                while ((u_char *)ap < ls_end) {
                        TCHECK(*ap);
-                       printf(" %s", ipaddr_string(ap));
+                       printf("\n\t\t%s", ipaddr_string(ap));
                        ++ap;
                }
                break;
 
        case LS_TYPE_INTER_AP | LS_SCOPE_AREA:
                TCHECK(lsap->lsa_un.un_inter_ap.inter_ap_metric);
                        ++ap;
                }
                break;
 
        case LS_TYPE_INTER_AP | LS_SCOPE_AREA:
                TCHECK(lsap->lsa_un.un_inter_ap.inter_ap_metric);
-               printf(" metric %u",
-                       (u_int32_t)ntohl(lsap->lsa_un.un_inter_ap.inter_ap_metric) & SLA_MASK_METRIC);
+               printf(", metric %u",
+                       EXTRACT_32BITS(&lsap->lsa_un.un_inter_ap.inter_ap_metric) & SLA_MASK_METRIC);
                lsapp = lsap->lsa_un.un_inter_ap.inter_ap_prefix;
                lsapp = lsap->lsa_un.un_inter_ap.inter_ap_prefix;
-               while (lsapp + sizeof(lsapp) <= (struct lsa_prefix *)ls_end) {
-                       k = ospf6_print_lsaprefix(lsapp);
-                       if (k < 0)
+               while (lsapp + sizeof(lsapp) <= (struct lsa6_prefix *)ls_end) {
+                       bytelen = ospf6_print_lsaprefix(lsapp);
+                       if (bytelen)
                                goto trunc;
                                goto trunc;
-                       lsapp = (struct lsa_prefix *)(((u_char *)lsapp) + k);
-               }
-               break;
-
-#if 0
-       case LS_TYPE_SUM_ABR:
-               TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
-               lp = lsap->lsa_un.un_sla.sla_tosmetric;
-               while ((u_char *)lp < ls_end) {
-                       register u_int32_t ul;
-
-                       TCHECK(*lp);
-                       ul = ntohl(*lp);
-                       printf(" tos %d metric %d",
-                           (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS,
-                           ul & SLA_MASK_METRIC);
-                       ++lp;
+                       lsapp = (struct lsa6_prefix *)(((u_char *)lsapp) + bytelen);
                }
                break;
                }
                break;
+       case LS_SCOPE_AS | LS_TYPE_ASE:
+               TCHECK(lsap->lsa_un.un_asla.asla_metric);
+               flags32 = EXTRACT_32BITS(&lsap->lsa_un.un_asla.asla_metric);
+                printf("\n\t     Flags [%s]",
+                       bittok2str(ospf6_asla_flag_values, "none", flags32));
+               printf(" metric %u",
+                      EXTRACT_32BITS(&lsap->lsa_un.un_asla.asla_metric) &
+                      ASLA_MASK_METRIC);
+               lsapp = lsap->lsa_un.un_asla.asla_prefix;
+               bytelen = ospf6_print_lsaprefix(lsapp);
+               if (bytelen < 0)
+                       goto trunc;
+               if ((ls_opt = (u_char *)(((u_char *)lsapp) + bytelen)) < ls_end) {
+                       struct in6_addr *fwdaddr6;
 
 
-       case LS_TYPE_ASE:
-               TCHECK(lsap->lsa_un.un_nla.nla_mask);
-               printf(" mask %s",
-                   ipaddr_string(&lsap->lsa_un.un_asla.asla_mask));
-
-               TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
-               almp = lsap->lsa_un.un_asla.asla_metric;
-               while ((u_char *)almp < ls_end) {
-                       register u_int32_t ul;
-
-                       TCHECK(almp->asla_tosmetric);
-                       ul = ntohl(almp->asla_tosmetric);
-                       printf(" type %d tos %d metric %d",
-                           (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1,
-                           (ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS,
-                           (ul & ASLA_MASK_METRIC));
-                       TCHECK(almp->asla_forward);
-                       if (almp->asla_forward.s_addr) {
+                       if ((flags32 & ASLA_FLAG_FWDADDR) != 0) {
+                               fwdaddr6 = (struct in6_addr *)ls_opt;
+                               TCHECK(*fwdaddr6);
                                printf(" forward %s",
                                printf(" forward %s",
-                                   ipaddr_string(&almp->asla_forward));
-                       }
-                       TCHECK(almp->asla_tag);
-                       if (almp->asla_tag.s_addr) {
-                               printf(" tag %s",
-                                   ipaddr_string(&almp->asla_tag));
+                                      ip6addr_string(fwdaddr6));
+
+                               ls_opt += sizeof(struct in6_addr);
                        }
                        }
-                       ++almp;
-               }
-               break;
 
 
-       case LS_TYPE_GROUP:
-               /* Multicast extensions as of 23 July 1991 */
-               mcp = lsap->lsa_un.un_mcla;
-               while ((u_char *)mcp < ls_end) {
-                       TCHECK(mcp->mcla_vid);
-                       switch (ntohl(mcp->mcla_vtype)) {
+                       if ((flags32 & ASLA_FLAG_ROUTETAG) != 0) {
+                               TCHECK(*(u_int32_t *)ls_opt);
+                               printf(" tag %s",
+                                      ipaddr_string((u_int32_t *)ls_opt));
 
 
-                       case MCLA_VERTEX_ROUTER:
-                               printf(" rtr rtrid %s",
-                                   ipaddr_string(&mcp->mcla_vid));
-                               break;
+                               ls_opt += sizeof(u_int32_t);
+                       }
 
 
-                       case MCLA_VERTEX_NETWORK:
-                               printf(" net dr %s",
-                                   ipaddr_string(&mcp->mcla_vid));
-                               break;
+                       if (lsapp->lsa_p_metric) {
+                               TCHECK(*(u_int32_t *)ls_opt);
+                               printf(" RefLSID: %s",
+                                      ipaddr_string((u_int32_t *)ls_opt));
 
 
-                       default:
-                               printf(" ??VertexType %u??",
-                                   (u_int32_t)ntohl(mcp->mcla_vtype));
-                               break;
+                               ls_opt += sizeof(u_int32_t);
                        }
                        }
-               ++mcp;
                }
                }
-#endif
+               break;
 
        case LS_TYPE_LINK:
                /* Link LSA */
                llsap = &lsap->lsa_un.un_llsa;
                TCHECK(llsap->llsa_options);
 
        case LS_TYPE_LINK:
                /* Link LSA */
                llsap = &lsap->lsa_un.un_llsa;
                TCHECK(llsap->llsa_options);
-               ospf6_print_bits(ospf6_option_bits, ntohl(llsap->llsa_options));
+                printf("\n\t      Options [%s]",
+                       bittok2str(ospf6_option_values, "none",
+                                  EXTRACT_32BITS(&llsap->llsa_options)));
                TCHECK(llsap->llsa_nprefix);
                TCHECK(llsap->llsa_nprefix);
-               printf(" pri %d lladdr %s npref %d", llsap->llsa_priority,
-                       ip6addr_string(&llsap->llsa_lladdr),
-                       (u_int32_t)ntohl(llsap->llsa_nprefix));
-               lsapp = llsap->llsa_prefix;
-               for (j = 0; j < ntohl(llsap->llsa_nprefix); j++) {
-                       k = ospf6_print_lsaprefix(lsapp);
-                       if (k < 0)
-                               goto trunc;
-                       lsapp = (struct lsa_prefix *)(((u_char *)lsapp) + k);
-               }
+                prefixes = EXTRACT_32BITS(&llsap->llsa_nprefix);
+               printf("\n\t      Priority %d, Link-local address %s, Prefixes %d:",
+                       llsap->llsa_priority,
+                       ip6addr_string(&llsap->llsa_lladdr),
+                       prefixes);
+
+               tptr = (u_int8_t *)llsap->llsa_prefix;
+                while (prefixes > 0) {
+                    lsapp = (struct lsa6_prefix *)tptr;
+                    if ((bytelen = ospf6_print_lsaprefix(lsapp)) == -1) {
+                        goto trunc;
+                    }
+                    prefixes--;
+                    tptr += bytelen;
+                }
                break;
 
        case LS_TYPE_INTRA_AP | LS_SCOPE_AREA:
                /* Intra-Area-Prefix LSA */
                TCHECK(lsap->lsa_un.un_intra_ap.intra_ap_rtid);
                ospf6_print_ls_type(
                break;
 
        case LS_TYPE_INTRA_AP | LS_SCOPE_AREA:
                /* Intra-Area-Prefix LSA */
                TCHECK(lsap->lsa_un.un_intra_ap.intra_ap_rtid);
                ospf6_print_ls_type(
-                       ntohs(lsap->lsa_un.un_intra_ap.intra_ap_lstype),
-                       &lsap->lsa_un.un_intra_ap.intra_ap_lsid,
-                       &lsap->lsa_un.un_intra_ap.intra_ap_rtid,
-                       "LinkStateType %d");
+                       EXTRACT_16BITS(&lsap->lsa_un.un_intra_ap.intra_ap_lstype),
+                       &lsap->lsa_un.un_intra_ap.intra_ap_lsid);
                TCHECK(lsap->lsa_un.un_intra_ap.intra_ap_nprefix);
                TCHECK(lsap->lsa_un.un_intra_ap.intra_ap_nprefix);
-               printf(" npref %d",
-                       ntohs(lsap->lsa_un.un_intra_ap.intra_ap_nprefix));
-
-               lsapp = lsap->lsa_un.un_intra_ap.intra_ap_prefix;
-               for (j = 0;
-                    j < ntohs(lsap->lsa_un.un_intra_ap.intra_ap_nprefix);
-                    j++) {
-                       k = ospf6_print_lsaprefix(lsapp);
-                       if (k < 0)
-                               goto trunc;
-                       lsapp = (struct lsa_prefix *)(((u_char *)lsapp) + k);
-               }
+                prefixes = EXTRACT_16BITS(&lsap->lsa_un.un_intra_ap.intra_ap_nprefix);
+               printf("\n\t      Prefixes %d:", prefixes);
+
+                tptr = (u_int8_t *)lsap->lsa_un.un_intra_ap.intra_ap_prefix;
+
+                while (prefixes > 0) {
+                    lsapp = (struct lsa6_prefix *)tptr;
+                    if ((bytelen = ospf6_print_lsaprefix(lsapp)) == -1) {
+                        goto trunc;
+                    }
+                    prefixes--;
+                    tptr += bytelen;
+                }
                break;
 
                break;
 
+        case LS_TYPE_GRACE | LS_SCOPE_LINKLOCAL:
+                if (ospf_print_grace_lsa(tptr, lsa_length) == -1) {
+                    return 1;
+                }
+            
+            break;
+
+        case LS_TYPE_INTRA_ATE | LS_SCOPE_LINKLOCAL:
+            if (ospf_print_te_lsa(tptr, lsa_length) == -1) {
+                return 1;
+            }
+            break;
+
        default:
        default:
-               printf(" ??LinkStateType 0x%04x??",
-                       ntohs(lsap->ls_hdr.ls_type));
+            if(!print_unknown_data(tptr,
+                                   "\n\t      ",
+                                   lsa_length)) {
+                return (1);
+            }
        }
 
        }
 
-                                                               /* { (ctags) */
-       fputs(" }", stdout);
        return (0);
 trunc:
        return (0);
 trunc:
-       fputs(" }", stdout);
        return (1);
 }
 
        return (1);
 }
 
@@ -479,131 +421,105 @@ ospf6_decode_v3(register const struct ospf6hdr *op,
     register const u_char *dataend)
 {
        register const rtrid_t *ap;
     register const u_char *dataend)
 {
        register const rtrid_t *ap;
-       register const struct lsr *lsrp;
-       register const struct lsa_hdr *lshp;
-       register const struct lsa *lsap;
-       register char sep;
+       register const struct lsr6 *lsrp;
+       register const struct lsa6_hdr *lshp;
+       register const struct lsa6 *lsap;
        register int i;
 
        switch (op->ospf6_type) {
 
        register int i;
 
        switch (op->ospf6_type) {
 
-       case OSPF_TYPE_UMD:
-               /*
-                * Rob Coltun's special monitoring packets;
-                * do nothing
-                */
-               break;
-
        case OSPF_TYPE_HELLO:
        case OSPF_TYPE_HELLO:
-               if (vflag) {
-                       TCHECK(op->ospf6_hello.hello_deadint);
-                       ospf6_print_bits(ospf6_option_bits,
-                           ntohl(op->ospf6_hello.hello_options));
-                       printf(" ifid %s pri %d int %d dead %u",
-                           ipaddr_string(&op->ospf6_hello.hello_ifid),
-                           op->ospf6_hello.hello_priority,
-                           ntohs(op->ospf6_hello.hello_helloint),
-                           ntohs(op->ospf6_hello.hello_deadint));
-               }
+                printf("\n\tOptions [%s]",
+                       bittok2str(ospf6_option_values, "none",
+                                  EXTRACT_32BITS(&op->ospf6_hello.hello_options)));
+
+                TCHECK(op->ospf6_hello.hello_deadint);
+                printf("\n\t  Hello Timer %us, Dead Timer %us, Interface-ID %s, Priority %u",
+                       EXTRACT_16BITS(&op->ospf6_hello.hello_helloint),
+                       EXTRACT_16BITS(&op->ospf6_hello.hello_deadint),
+                       ipaddr_string(&op->ospf6_hello.hello_ifid),
+                       op->ospf6_hello.hello_priority);
+
                TCHECK(op->ospf6_hello.hello_dr);
                if (op->ospf6_hello.hello_dr != 0)
                TCHECK(op->ospf6_hello.hello_dr);
                if (op->ospf6_hello.hello_dr != 0)
-                       printf(" dr %s",
+                       printf("\n\t  Designated Router %s",
                            ipaddr_string(&op->ospf6_hello.hello_dr));
                TCHECK(op->ospf6_hello.hello_bdr);
                if (op->ospf6_hello.hello_bdr != 0)
                            ipaddr_string(&op->ospf6_hello.hello_dr));
                TCHECK(op->ospf6_hello.hello_bdr);
                if (op->ospf6_hello.hello_bdr != 0)
-                       printf(" bdr %s",
+                       printf(", Backup Designated Router %s",
                            ipaddr_string(&op->ospf6_hello.hello_bdr));
                if (vflag) {
                            ipaddr_string(&op->ospf6_hello.hello_bdr));
                if (vflag) {
-                       printf(" nbrs");
+                       printf("\n\t  Neighbor List:");
                        ap = op->ospf6_hello.hello_neighbor;
                        while ((u_char *)ap < dataend) {
                                TCHECK(*ap);
                        ap = op->ospf6_hello.hello_neighbor;
                        while ((u_char *)ap < dataend) {
                                TCHECK(*ap);
-                               printf(" %s", ipaddr_string(ap));
+                               printf("\n\t    %s", ipaddr_string(ap));
                                ++ap;
                        }
                }
                break;  /* HELLO */
 
                                ++ap;
                        }
                }
                break;  /* HELLO */
 
-       case OSPF_TYPE_DB:
+       case OSPF_TYPE_DD:
                TCHECK(op->ospf6_db.db_options);
                TCHECK(op->ospf6_db.db_options);
-               ospf6_print_bits(ospf6_option_bits,
-                       ntohl(op->ospf6_db.db_options));
-               sep = ' ';
+                printf("\n\tOptions [%s]",
+                       bittok2str(ospf6_option_values, "none",
+                                  EXTRACT_32BITS(&op->ospf6_db.db_options)));
                TCHECK(op->ospf6_db.db_flags);
                TCHECK(op->ospf6_db.db_flags);
-               if (op->ospf6_db.db_flags & OSPF6_DB_INIT) {
-                       printf("%cI", sep);
-                       sep = '/';
-               }
-               if (op->ospf6_db.db_flags & OSPF6_DB_MORE) {
-                       printf("%cM", sep);
-                       sep = '/';
-               }
-               if (op->ospf6_db.db_flags & OSPF6_DB_MASTER) {
-                       printf("%cMS", sep);
-                       sep = '/';
-               }
-               TCHECK(op->ospf6_db.db_seq);
-               printf(" mtu %u S %X", ntohs(op->ospf6_db.db_mtu),
-                       (u_int32_t)ntohl(op->ospf6_db.db_seq));
-
-               if (vflag) {
-                       /* Print all the LS adv's */
-                       lshp = op->ospf6_db.db_lshdr;
+                printf(", DD Flags [%s]",
+                       bittok2str(ospf6_dd_flag_values,"none",op->ospf6_db.db_flags));
 
 
-                       while (!ospf6_print_lshdr(lshp)) {
-                                                       /* { (ctags) */
-                               printf(" }");
-                               ++lshp;
-                       }
-               }
+               TCHECK(op->ospf6_db.db_seq);
+               printf(", MTU %u, DD-Sequence 0x%08x",
+                       EXTRACT_16BITS(&op->ospf6_db.db_mtu),
+                       EXTRACT_32BITS(&op->ospf6_db.db_seq));
+
+                /* Print all the LS adv's */
+                lshp = op->ospf6_db.db_lshdr;
+                while (!ospf6_print_lshdr(lshp)) {
+                    ++lshp;
+                }
                break;
 
                break;
 
-       case OSPF_TYPE_LSR:
+       case OSPF_TYPE_LS_REQ:
                if (vflag) {
                        lsrp = op->ospf6_lsr;
                        while ((u_char *)lsrp < dataend) {
                                TCHECK(*lsrp);
                if (vflag) {
                        lsrp = op->ospf6_lsr;
                        while ((u_char *)lsrp < dataend) {
                                TCHECK(*lsrp);
-                               printf(" {");           /* } (ctags) */
-                               ospf6_print_ls_type(ntohs(lsrp->ls_type),
-                                   &lsrp->ls_stateid,
-                                   &lsrp->ls_router,
-                                   "LinkStateType %d");
-                                                       /* { (ctags) */
-                               printf(" }");
+                                printf("\n\t  Advertising Router %s",
+                                       ipaddr_string(&lsrp->ls_router));
+                               ospf6_print_ls_type(EXTRACT_16BITS(&lsrp->ls_type),
+                                                    &lsrp->ls_stateid);
                                ++lsrp;
                        }
                }
                break;
 
                                ++lsrp;
                        }
                }
                break;
 
-       case OSPF_TYPE_LSU:
+       case OSPF_TYPE_LS_UPDATE:
                if (vflag) {
                        lsap = op->ospf6_lsu.lsu_lsa;
                        TCHECK(op->ospf6_lsu.lsu_count);
                if (vflag) {
                        lsap = op->ospf6_lsu.lsu_lsa;
                        TCHECK(op->ospf6_lsu.lsu_count);
-                       i = ntohl(op->ospf6_lsu.lsu_count);
+                       i = EXTRACT_32BITS(&op->ospf6_lsu.lsu_count);
                        while (i--) {
                                if (ospf6_print_lsa(lsap))
                                        goto trunc;
                        while (i--) {
                                if (ospf6_print_lsa(lsap))
                                        goto trunc;
-                               lsap = (struct lsa *)((u_char *)lsap +
-                                   ntohs(lsap->ls_hdr.ls_length));
+                               lsap = (struct lsa6 *)((u_char *)lsap +
+                                   EXTRACT_16BITS(&lsap->ls_hdr.ls_length));
                        }
                }
                break;
 
 
                        }
                }
                break;
 
 
-       case OSPF_TYPE_LSA:
+       case OSPF_TYPE_LS_ACK:
                if (vflag) {
                        lshp = op->ospf6_lsa.lsa_lshdr;
 
                        while (!ospf6_print_lshdr(lshp)) {
                if (vflag) {
                        lshp = op->ospf6_lsa.lsa_lshdr;
 
                        while (!ospf6_print_lshdr(lshp)) {
-                                                       /* { (ctags) */
-                               printf(" }");
                                ++lshp;
                        }
                }
                break;
 
        default:
                                ++lshp;
                        }
                }
                break;
 
        default:
-               printf("v3 type %d", op->ospf6_type);
                break;
        }
        return (0);
                break;
        }
        return (0);
@@ -623,30 +539,35 @@ ospf6_print(register const u_char *bp, register u_int length)
        /* If the type is valid translate it, or just print the type */
        /* value.  If it's not valid, say so and return */
        TCHECK(op->ospf6_type);
        /* If the type is valid translate it, or just print the type */
        /* value.  If it's not valid, say so and return */
        TCHECK(op->ospf6_type);
-       cp = tok2str(type2str, "type%d", op->ospf6_type);
-       printf("OSPFv%d-%s %d:", op->ospf6_version, cp, length);
-       if (*cp == 't')
+       cp = tok2str(ospf6_type_values, "unknown LS-type", op->ospf6_type);
+       printf("OSPFv%u, %s, length %d", op->ospf6_version, cp, length);
+       if (*cp == 'u') {
                return;
                return;
+        }
+
+        if(!vflag) { /* non verbose - so lets bail out here */
+                return;
+        }
 
        TCHECK(op->ospf6_len);
 
        TCHECK(op->ospf6_len);
-       if (length != ntohs(op->ospf6_len)) {
-               printf(" [len %d]", ntohs(op->ospf6_len));
+       if (length != EXTRACT_16BITS(&op->ospf6_len)) {
+               printf(" [len %d]", EXTRACT_16BITS(&op->ospf6_len));
                return;
        }
        dataend = bp + length;
 
        /* Print the routerid if it is not the same as the source */
        TCHECK(op->ospf6_routerid);
                return;
        }
        dataend = bp + length;
 
        /* Print the routerid if it is not the same as the source */
        TCHECK(op->ospf6_routerid);
-       printf(" rtrid %s", ipaddr_string(&op->ospf6_routerid));
+       printf("\n\tRouter-ID %s", ipaddr_string(&op->ospf6_routerid));
 
        TCHECK(op->ospf6_areaid);
        if (op->ospf6_areaid != 0)
 
        TCHECK(op->ospf6_areaid);
        if (op->ospf6_areaid != 0)
-               printf(" area %s", ipaddr_string(&op->ospf6_areaid));
+               printf(", Area %s", ipaddr_string(&op->ospf6_areaid));
        else
        else
-               printf(" backbone");
+               printf(", Backbone Area");
        TCHECK(op->ospf6_instanceid);
        if (op->ospf6_instanceid)
        TCHECK(op->ospf6_instanceid);
        if (op->ospf6_instanceid)
-               printf(" instance %u", op->ospf6_instanceid);
+               printf(", Instance %u", op->ospf6_instanceid);
 
        /* Do rest according to version.         */
        switch (op->ospf6_version) {
 
        /* Do rest according to version.         */
        switch (op->ospf6_version) {
[mirror] the TCPdump network dissector