]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-ospf.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Get rid of unused variables.
[tcpdump] / print-ospf.c
diff --git a/print-ospf.c b/print-ospf.c
index c929e57e6da134ae13c3da10d84aef890ef98c92..020dbec90336c53e61e24d72d2a28009463d49bb 100644 (file)
--- a/print-ospf.c
+++ b/print-ospf.c
@@ -23,171 +23,112 @@
 
 #ifndef lint
 static const char rcsid[] =
 
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-ospf.c,v 1.28 2000-09-23 08:54:36 guy Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-ospf.c,v 1.36 2002-12-23 19:57:49 hannes 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 <ctype.h>
 #include <stdio.h>
 
 #include "interface.h"
 #include "addrtoname.h"
 #include <stdio.h>
 
 #include "interface.h"
 #include "addrtoname.h"
+#include "extract.h"
 
 #include "ospf.h"
 
 #include "ip.h"
 
 
 #include "ospf.h"
 
 #include "ip.h"
 
-struct bits {
-       u_int32_t bit;
-       const char *str;
+static struct tok ospf_option_values[] = {
+       { OSPF_OPTION_T,        "TOS" },
+       { OSPF_OPTION_E,        "External" },
+       { OSPF_OPTION_MC,       "Multicast" },
+       { OSPF_OPTION_NP,       "NSSA" },
+       { OSPF_OPTION_EA,       "Advertise External" },
+       { OSPF_OPTION_DC,       "Demand Circuit" },
+       { OSPF_OPTION_O,        "Opaque" },
+       { 0,                    NULL }
 };
 
 };
 
-static const struct bits ospf_option_bits[] = {
-       { OSPF_OPTION_T,        "T" },
-       { OSPF_OPTION_E,        "E" },
-       { OSPF_OPTION_MC,       "MC" },
+static struct tok ospf_authtype_values[] = {
+       { OSPF_AUTH_NONE,       "none" },
+       { OSPF_AUTH_NONE,       "simple" },
+       { OSPF_AUTH_MD5,        "MD5" },
        { 0,                    NULL }
 };
 
        { 0,                    NULL }
 };
 
-static const struct bits ospf_rla_flag_bits[] = {
-       { RLA_FLAG_B,           "B" },
-       { RLA_FLAG_E,           "E" },
-       { RLA_FLAG_W1,          "W1" },
+static struct tok ospf_rla_flag_values[] = {
+       { RLA_FLAG_B,           "ABR" },
+       { RLA_FLAG_E,           "ASBR" },
+       { RLA_FLAG_W1,          "Virtual" },
        { RLA_FLAG_W2,          "W2" },
        { 0,                    NULL }
 };
 
 static struct tok type2str[] = {
        { RLA_FLAG_W2,          "W2" },
        { 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" },
+       { OSPF_TYPE_UMD,        "UMD" },
+       { 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 }
+};
+
+static struct tok lsa_values[] = {
+       { LS_TYPE_ROUTER,       "Router" },
+       { LS_TYPE_NETWORK,      "Network" },
+       { LS_TYPE_SUM_IP,       "Summary" },
+       { LS_TYPE_SUM_ABR,      "ASBR Summary" },
+       { LS_TYPE_ASE,          "External" },
+       { LS_TYPE_GROUP,        "Multicast Group" },
+       { LS_TYPE_NSSA,         "NSSA" },
+       { LS_TYPE_OPAQUE_LL,    "Link Local Opaque" },
+       { LS_TYPE_OPAQUE_AL,    "Area Local Opaque" },
+       { LS_TYPE_OPAQUE_DW,    "Domain Wide Opaque" },
+       { 0,                    NULL }
+};
+
+static struct tok ospf_dd_flag_values[] = {
+       { OSPF_DB_INIT,         "Init" },
+       { OSPF_DB_MORE,         "More" },
+       { OSPF_DB_MASTER,       "Master" },
        { 0,                    NULL }
 };
 
 static char tstr[] = " [|ospf]";
 
        { 0,                    NULL }
 };
 
 static char tstr[] = " [|ospf]";
 
-/* Forwards */
-static inline void ospf_print_seqage(u_int32_t, time_t);
-static inline void ospf_print_bits(const struct bits *, u_char);
-static void ospf_print_ls_type(u_int, const struct in_addr *,
-    const struct in_addr *, const char *);
+#ifdef WIN32
+#define inline __inline
+#endif /* WIN32 */
+
 static int ospf_print_lshdr(const struct lsa_hdr *);
 static int ospf_print_lsa(const struct lsa *);
 static int ospf_decode_v2(const struct ospfhdr *, const u_char *);
 
 static int ospf_print_lshdr(const struct lsa_hdr *);
 static int ospf_print_lsa(const struct lsa *);
 static int ospf_decode_v2(const struct ospfhdr *, const u_char *);
 
-static inline void
-ospf_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
-ospf_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
-ospf_print_ls_type(register u_int ls_type,
-    register const struct in_addr *ls_stateid,
-    register const struct in_addr *ls_router, register const char *fmt)
-{
-
-       switch (ls_type) {
-
-       case LS_TYPE_ROUTER:
-               printf(" rtr %s ", ipaddr_string(ls_router));
-               break;
-
-       case LS_TYPE_NETWORK:
-               printf(" net dr %s if %s",
-                   ipaddr_string(ls_router),
-                   ipaddr_string(ls_stateid));
-               break;
-
-       case LS_TYPE_SUM_IP:
-               printf(" sum %s abr %s",
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
-
-       case LS_TYPE_SUM_ABR:
-               printf(" abr %s rtr %s",
-                   ipaddr_string(ls_router),
-                   ipaddr_string(ls_stateid));
-               break;
-
-       case LS_TYPE_ASE:
-               printf(" ase %s asbr %s",
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
-
-       case LS_TYPE_GROUP:
-               printf(" group %s rtr %s",
-                   ipaddr_string(ls_stateid),
-                   ipaddr_string(ls_router));
-               break;
-
-       default:
-               putchar(' ');
-               printf(fmt, ls_type);
-               break;
-       }
-}
-
 static int
 static int
-ospf_print_lshdr(register const struct lsa_hdr *lshp)
-{
+ospf_print_lshdr(register const struct lsa_hdr *lshp) {
 
        TCHECK(lshp->ls_type);
 
        TCHECK(lshp->ls_type);
-       printf(" {");                                           /* } (ctags) */
-
        TCHECK(lshp->ls_options);
        TCHECK(lshp->ls_options);
-       ospf_print_bits(ospf_option_bits, lshp->ls_options);
-       TCHECK(lshp->ls_seq);
-       ospf_print_seqage(ntohl(lshp->ls_seq), ntohs(lshp->ls_age));
-       ospf_print_ls_type(lshp->ls_type, &lshp->ls_stateid, &lshp->ls_router,
-           "ls_type %d");
 
 
-       return (0);
+        printf("\n\t  %s LSA (%d), LSA-ID: %s, Advertising Router: %s, seq 0x%08x, age %us",
+               tok2str(lsa_values,"unknown",lshp->ls_type),
+               lshp->ls_type,
+               ipaddr_string(&lshp->ls_stateid),
+               ipaddr_string(&lshp->ls_router),
+               EXTRACT_32BITS(&lshp->ls_seq),
+               EXTRACT_16BITS(&lshp->ls_age));
+        printf("\n\t    Options: %s", bittok2str(ospf_option_values,"none",lshp->ls_options));
+
+return (0);
 trunc:
        return (1);
 }
 
 trunc:
        return (1);
 }
 
-
 /*
  * Print a single link state advertisement.  If truncated return 1, else 0.
  */
 /*
  * Print a single link state advertisement.  If truncated return 1, else 0.
  */
@@ -203,65 +144,69 @@ ospf_print_lsa(register const struct lsa *lsap)
        register const u_int32_t *lp;
        register int j, k;
 
        register const u_int32_t *lp;
        register int j, k;
 
-       if (ospf_print_lshdr(&lsap->ls_hdr))
-               return (1);
+        printf("\n\t  %s LSA (%d), LSA-ID: %s, Advertising Router: %s, seq 0x%08x, age %us",
+               tok2str(lsa_values,"unknown",lsap->ls_hdr.ls_type),
+               lsap->ls_hdr.ls_type,
+               ipaddr_string(&lsap->ls_hdr.ls_stateid),
+               ipaddr_string(&lsap->ls_hdr.ls_router),
+               EXTRACT_32BITS(&lsap->ls_hdr.ls_seq),
+               EXTRACT_16BITS(&lsap->ls_hdr.ls_age));
+        printf("\n\t    Options: %s", bittok2str(ospf_option_values,"none",lsap->ls_hdr.ls_options));
+
        TCHECK(lsap->ls_hdr.ls_length);
        TCHECK(lsap->ls_hdr.ls_length);
-       ls_end = (u_char *)lsap + ntohs(lsap->ls_hdr.ls_length);
+       ls_end = (u_char *)lsap + EXTRACT_16BITS(&lsap->ls_hdr.ls_length);
        switch (lsap->ls_hdr.ls_type) {
 
        case LS_TYPE_ROUTER:
                TCHECK(lsap->lsa_un.un_rla.rla_flags);
        switch (lsap->ls_hdr.ls_type) {
 
        case LS_TYPE_ROUTER:
                TCHECK(lsap->lsa_un.un_rla.rla_flags);
-               ospf_print_bits(ospf_rla_flag_bits,
-                   lsap->lsa_un.un_rla.rla_flags);
+                printf("\n\t    Router LSA Options: %s", bittok2str(ospf_rla_flag_values,"unknown (%u)",lsap->lsa_un.un_rla.rla_flags));
 
                TCHECK(lsap->lsa_un.un_rla.rla_count);
 
                TCHECK(lsap->lsa_un.un_rla.rla_count);
-               j = ntohs(lsap->lsa_un.un_rla.rla_count);
+               j = EXTRACT_16BITS(&lsap->lsa_un.un_rla.rla_count);
                TCHECK(lsap->lsa_un.un_rla.rla_link);
                rlp = lsap->lsa_un.un_rla.rla_link;
                while (j--) {
                        TCHECK(*rlp);
                TCHECK(lsap->lsa_un.un_rla.rla_link);
                rlp = lsap->lsa_un.un_rla.rla_link;
                while (j--) {
                        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, Interface-IP: %s",
+                                   ipaddr_string(&rlp->link_id),
+                                   ipaddr_string(&rlp->link_data)); 
+                                break;
 
                        case RLA_TYPE_ROUTER:
 
                        case RLA_TYPE_ROUTER:
-                               printf(" nbrid %s if %s",
+                               printf("\n\t      Neighbor-Router-ID: %s, Interface-IP: %s",
                                    ipaddr_string(&rlp->link_id),
                                    ipaddr_string(&rlp->link_data));
                                break;
 
                        case RLA_TYPE_TRANSIT:
                                    ipaddr_string(&rlp->link_id),
                                    ipaddr_string(&rlp->link_data));
                                break;
 
                        case RLA_TYPE_TRANSIT:
-                               printf(" dr %s if %s",
+                               printf("\n\t      Neighbor-Network-ID: %s, Interface-IP: %s",
                                    ipaddr_string(&rlp->link_id),
                                    ipaddr_string(&rlp->link_data));
                                break;
 
                        case RLA_TYPE_STUB:
                                    ipaddr_string(&rlp->link_id),
                                    ipaddr_string(&rlp->link_data));
                                break;
 
                        case RLA_TYPE_STUB:
-                               printf(" net %s mask %s",
+                               printf("\n\t      Stub-Network: %s, mask: %s",
                                    ipaddr_string(&rlp->link_id),
                                    ipaddr_string(&rlp->link_data));
                                break;
 
                        default:
                                    ipaddr_string(&rlp->link_id),
                                    ipaddr_string(&rlp->link_data));
                                break;
 
                        default:
-                                                               /* { (ctags) */
-                               printf(" ??RouterLinksType %d?? }",
+                               printf("\n\t      unknown Router Links Type (%u)",
                                    rlp->link_type);
                                return (0);
                        }
                                    rlp->link_type);
                                return (0);
                        }
-                       printf(" tos 0 metric %d", ntohs(rlp->link_tos0metric));
+                       printf(", tos 0, metric: %d", EXTRACT_16BITS(&rlp->link_tos0metric));
                        tosp = (struct tos_metric *)
                            ((sizeof rlp->link_tos0metric) + (u_char *) rlp);
                        for (k = 0; k < (int) rlp->link_toscount; ++k, ++tosp) {
                                TCHECK(*tosp);
                        tosp = (struct tos_metric *)
                            ((sizeof rlp->link_tos0metric) + (u_char *) rlp);
                        for (k = 0; k < (int) rlp->link_toscount; ++k, ++tosp) {
                                TCHECK(*tosp);
-                               printf(" tos %d metric %d",
+                               printf(", tos %d, metric: %d",
                                    tosp->tos_type,
                                    tosp->tos_type,
-                                   ntohs(tosp->tos_metric));
+                                   EXTRACT_16BITS(&tosp->tos_metric));
                        }
                        }
-                                                               /* { (ctags) */
-                       printf(" }");
                        rlp = (struct rlalink *)((u_char *)(rlp + 1) +
                            ((rlp->link_toscount) * sizeof(*tosp)));
                }
                        rlp = (struct rlalink *)((u_char *)(rlp + 1) +
                            ((rlp->link_toscount) * sizeof(*tosp)));
                }
@@ -269,7 +214,7 @@ ospf_print_lsa(register const struct lsa *lsap)
 
        case LS_TYPE_NETWORK:
                TCHECK(lsap->lsa_un.un_nla.nla_mask);
 
        case LS_TYPE_NETWORK:
                TCHECK(lsap->lsa_un.un_nla.nla_mask);
-               printf(" mask %s rtrs",
+               printf("\n\t    mask %s rtrs",
                    ipaddr_string(&lsap->lsa_un.un_nla.nla_mask));
                ap = lsap->lsa_un.un_nla.nla_router;
                while ((u_char *)ap < ls_end) {
                    ipaddr_string(&lsap->lsa_un.un_nla.nla_mask));
                ap = lsap->lsa_un.un_nla.nla_router;
                while ((u_char *)ap < ls_end) {
@@ -281,19 +226,41 @@ ospf_print_lsa(register const struct lsa *lsap)
 
        case LS_TYPE_SUM_IP:
                TCHECK(lsap->lsa_un.un_nla.nla_mask);
 
        case LS_TYPE_SUM_IP:
                TCHECK(lsap->lsa_un.un_nla.nla_mask);
-               printf(" mask %s",
+               printf("\n\t    mask %s",
                    ipaddr_string(&lsap->lsa_un.un_sla.sla_mask));
                    ipaddr_string(&lsap->lsa_un.un_sla.sla_mask));
-               /* Fall through */
+               TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
+               lp = lsap->lsa_un.un_sla.sla_tosmetric;
+                /* suppress tos if its not supported */
+                if(!((lsap->ls_hdr.ls_options)&OSPF_OPTION_T)) {
+                    printf(", metric: %u", EXTRACT_32BITS(lp)&SLA_MASK_METRIC);
+                    break;
+                }
+               while ((u_char *)lp < ls_end) {
+                       register u_int32_t ul;
+
+                       TCHECK(*lp);
+                       ul = EXTRACT_32BITS(lp);
+                       printf(", tos %d metric %d",
+                           (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS,
+                           ul & SLA_MASK_METRIC);
+                       ++lp;
+               }
+               break;
 
        case LS_TYPE_SUM_ABR:
                TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
                lp = lsap->lsa_un.un_sla.sla_tosmetric;
 
        case LS_TYPE_SUM_ABR:
                TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
                lp = lsap->lsa_un.un_sla.sla_tosmetric;
+                /* suppress tos if its not supported */
+                if(!((lsap->ls_hdr.ls_options)&OSPF_OPTION_T)) {
+                    printf(", metric: %u", EXTRACT_32BITS(lp)&SLA_MASK_METRIC);
+                    break;
+                }
                while ((u_char *)lp < ls_end) {
                        register u_int32_t ul;
 
                        TCHECK(*lp);
                while ((u_char *)lp < ls_end) {
                        register u_int32_t ul;
 
                        TCHECK(*lp);
-                       ul = ntohl(*lp);
-                       printf(" tos %d metric %d",
+                       ul = EXTRACT_32BITS(lp);
+                       printf(", tos %d metric %d",
                            (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS,
                            ul & SLA_MASK_METRIC);
                        ++lp;
                            (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS,
                            ul & SLA_MASK_METRIC);
                        ++lp;
@@ -302,7 +269,7 @@ ospf_print_lsa(register const struct lsa *lsap)
 
        case LS_TYPE_ASE:
                TCHECK(lsap->lsa_un.un_nla.nla_mask);
 
        case LS_TYPE_ASE:
                TCHECK(lsap->lsa_un.un_nla.nla_mask);
-               printf(" mask %s",
+               printf("\n\t    mask %s",
                    ipaddr_string(&lsap->lsa_un.un_asla.asla_mask));
 
                TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
                    ipaddr_string(&lsap->lsa_un.un_asla.asla_mask));
 
                TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
@@ -311,19 +278,23 @@ ospf_print_lsa(register const struct lsa *lsap)
                        register u_int32_t ul;
 
                        TCHECK(almp->asla_tosmetric);
                        register u_int32_t ul;
 
                        TCHECK(almp->asla_tosmetric);
-                       ul = ntohl(almp->asla_tosmetric);
-                       printf(" type %d tos %d metric %d",
+                       ul = EXTRACT_32BITS(&almp->asla_tosmetric);
+                       printf(", type %d, tos %d metric:",
                            (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1,
                            (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1,
-                           (ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS,
-                           (ul & ASLA_MASK_METRIC));
+                           (ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS);
+                        if ((ul & ASLA_MASK_METRIC)==0xffffff)
+                            printf(" infinite");
+                        else
+                            printf(" %d", (ul & ASLA_MASK_METRIC));
+
                        TCHECK(almp->asla_forward);
                        if (almp->asla_forward.s_addr) {
                        TCHECK(almp->asla_forward);
                        if (almp->asla_forward.s_addr) {
-                               printf(" forward %s",
+                               printf(", forward %s",
                                    ipaddr_string(&almp->asla_forward));
                        }
                        TCHECK(almp->asla_tag);
                        if (almp->asla_tag.s_addr) {
                                    ipaddr_string(&almp->asla_forward));
                        }
                        TCHECK(almp->asla_tag);
                        if (almp->asla_tag.s_addr) {
-                               printf(" tag %s",
+                               printf(", tag %s",
                                    ipaddr_string(&almp->asla_tag));
                        }
                        ++almp;
                                    ipaddr_string(&almp->asla_tag));
                        }
                        ++almp;
@@ -335,32 +306,29 @@ ospf_print_lsa(register const struct lsa *lsap)
                mcp = lsap->lsa_un.un_mcla;
                while ((u_char *)mcp < ls_end) {
                        TCHECK(mcp->mcla_vid);
                mcp = lsap->lsa_un.un_mcla;
                while ((u_char *)mcp < ls_end) {
                        TCHECK(mcp->mcla_vid);
-                       switch (ntohl(mcp->mcla_vtype)) {
+                       switch (EXTRACT_32BITS(&mcp->mcla_vtype)) {
 
                        case MCLA_VERTEX_ROUTER:
 
                        case MCLA_VERTEX_ROUTER:
-                               printf(" rtr rtrid %s",
+                               printf("\n\t    Router Router-ID %s",
                                    ipaddr_string(&mcp->mcla_vid));
                                break;
 
                        case MCLA_VERTEX_NETWORK:
                                    ipaddr_string(&mcp->mcla_vid));
                                break;
 
                        case MCLA_VERTEX_NETWORK:
-                               printf(" net dr %s",
+                               printf("\n\t    Network Designated Router %s",
                                    ipaddr_string(&mcp->mcla_vid));
                                break;
 
                        default:
                                    ipaddr_string(&mcp->mcla_vid));
                                break;
 
                        default:
-                               printf(" ??VertexType %u??",
-                                   (u_int32_t)ntohl(mcp->mcla_vtype));
+                               printf("\n\t    unknown VertexType (%u)",
+                                   EXTRACT_32BITS(&mcp->mcla_vtype));
                                break;
                        }
                ++mcp;
                }
        }
 
                                break;
                        }
                ++mcp;
                }
        }
 
-                                                               /* { (ctags) */
-       fputs(" }", stdout);
        return (0);
 trunc:
        return (0);
 trunc:
-       fputs(" }", stdout);
        return (1);
 }
 
        return (1);
 }
 
@@ -372,8 +340,7 @@ ospf_decode_v2(register const struct ospfhdr *op,
        register const struct lsr *lsrp;
        register const struct lsa_hdr *lshp;
        register const struct lsa *lsap;
        register const struct lsr *lsrp;
        register const struct lsa_hdr *lshp;
        register const struct lsa *lsap;
-       register char sep;
-       register int i;
+       register int lsa_count;
 
        switch (op->ospf_type) {
 
 
        switch (op->ospf_type) {
 
@@ -385,113 +352,89 @@ ospf_decode_v2(register const struct ospfhdr *op,
                break;
 
        case OSPF_TYPE_HELLO:
                break;
 
        case OSPF_TYPE_HELLO:
-               if (vflag) {
-                       TCHECK(op->ospf_hello.hello_deadint);
-                       ospf_print_bits(ospf_option_bits,
-                           op->ospf_hello.hello_options);
-                       printf(" mask %s int %d pri %d dead %u",
-                           ipaddr_string(&op->ospf_hello.hello_mask),
-                           ntohs(op->ospf_hello.hello_helloint),
-                           op->ospf_hello.hello_priority,
-                           (u_int32_t)ntohl(op->ospf_hello.hello_deadint));
-               }
+                TCHECK(op->ospf_hello.hello_deadint);
+                printf("\n\t  Hello Timer: %us, Dead Timer %us, mask: %s, Priority: %u",
+                       EXTRACT_16BITS(&op->ospf_hello.hello_helloint),
+                       EXTRACT_32BITS(&op->ospf_hello.hello_deadint),
+                       ipaddr_string(&op->ospf_hello.hello_mask),
+                       op->ospf_hello.hello_priority);
+
+                printf("\n\t  Options: %s",
+                       bittok2str(ospf_option_values,"none",op->ospf_hello.hello_options));
+
                TCHECK(op->ospf_hello.hello_dr);
                if (op->ospf_hello.hello_dr.s_addr != 0)
                TCHECK(op->ospf_hello.hello_dr);
                if (op->ospf_hello.hello_dr.s_addr != 0)
-                       printf(" dr %s",
+                       printf("\n\t  Designated Router %s",
                            ipaddr_string(&op->ospf_hello.hello_dr));
                            ipaddr_string(&op->ospf_hello.hello_dr));
+
                TCHECK(op->ospf_hello.hello_bdr);
                if (op->ospf_hello.hello_bdr.s_addr != 0)
                TCHECK(op->ospf_hello.hello_bdr);
                if (op->ospf_hello.hello_bdr.s_addr != 0)
-                       printf(" bdr %s",
+                       printf(", Backup Designated Router %s",
                            ipaddr_string(&op->ospf_hello.hello_bdr));
                            ipaddr_string(&op->ospf_hello.hello_bdr));
-               if (vflag) {
-                       printf(" nbrs");
-                       ap = op->ospf_hello.hello_neighbor;
-                       while ((u_char *)ap < dataend) {
-                               TCHECK(*ap);
-                               printf(" %s", ipaddr_string(ap));
-                               ++ap;
-                       }
-               }
+
+                ap = op->ospf_hello.hello_neighbor;
+                if ((u_char *)ap < dataend)
+                        printf("\n\t  Neighbor List:");
+                while ((u_char *)ap < dataend) {
+                        TCHECK(*ap);
+                        printf("\n\t    %s", ipaddr_string(ap));
+                        ++ap;
+                }
                break;  /* HELLO */
 
                break;  /* HELLO */
 
-       case OSPF_TYPE_DB:
+       case OSPF_TYPE_DD:
                TCHECK(op->ospf_db.db_options);
                TCHECK(op->ospf_db.db_options);
-               ospf_print_bits(ospf_option_bits, op->ospf_db.db_options);
-               sep = ' ';
+                printf("\n\t  Options: %s",
+                       bittok2str(ospf_option_values,"none",op->ospf_db.db_options));
                TCHECK(op->ospf_db.db_flags);
                TCHECK(op->ospf_db.db_flags);
-               if (op->ospf_db.db_flags & OSPF_DB_INIT) {
-                       printf("%cI", sep);
-                       sep = '/';
-               }
-               if (op->ospf_db.db_flags & OSPF_DB_MORE) {
-                       printf("%cM", sep);
-                       sep = '/';
-               }
-               if (op->ospf_db.db_flags & OSPF_DB_MASTER) {
-                       printf("%cMS", sep);
-                       sep = '/';
-               }
-               TCHECK(op->ospf_db.db_seq);
-               printf(" S %X", (u_int32_t)ntohl(op->ospf_db.db_seq));
+                printf("\n\t  DD Flags: %s",
+                       bittok2str(ospf_dd_flag_values,"none",op->ospf_db.db_flags));
 
                if (vflag) {
                        /* Print all the LS adv's */
                        lshp = op->ospf_db.db_lshdr;
 
                if (vflag) {
                        /* Print all the LS adv's */
                        lshp = op->ospf_db.db_lshdr;
-
                        while (!ospf_print_lshdr(lshp)) {
                        while (!ospf_print_lshdr(lshp)) {
-                                                       /* { (ctags) */
-                               printf(" }");
                                ++lshp;
                        }
                }
                break;
 
                                ++lshp;
                        }
                }
                break;
 
-       case OSPF_TYPE_LSR:
-               if (vflag) {
-                       lsrp = op->ospf_lsr;
-                       while ((u_char *)lsrp < dataend) {
-                               TCHECK(*lsrp);
-                               printf(" {");           /* } (ctags) */
-                               ospf_print_ls_type(ntohl(lsrp->ls_type),
-                                   &lsrp->ls_stateid,
-                                   &lsrp->ls_router,
-                                   "LinkStateType %d");
-                                                       /* { (ctags) */
-                               printf(" }");
-                               ++lsrp;
-                       }
-               }
+       case OSPF_TYPE_LS_REQ:
+                lsrp = op->ospf_lsr;
+                while ((u_char *)lsrp < dataend) {
+                        TCHECK(*lsrp);
+
+                        printf("\n\t  %s LSA (%d), LSA-ID: %s, Advertising Router: %s",
+                               tok2str(lsa_values,"unknown",lsrp->ls_type),
+                               lsrp->ls_type,
+                               ipaddr_string(&lsrp->ls_stateid),
+                               ipaddr_string(&lsrp->ls_router));
+                        ++lsrp;
+                }
                break;
 
                break;
 
-       case OSPF_TYPE_LSU:
-               if (vflag) {
-                       lsap = op->ospf_lsu.lsu_lsa;
-                       TCHECK(op->ospf_lsu.lsu_count);
-                       i = ntohl(op->ospf_lsu.lsu_count);
-                       while (i--) {
-                               if (ospf_print_lsa(lsap))
-                                       goto trunc;
-                               lsap = (struct lsa *)((u_char *)lsap +
-                                   ntohs(lsap->ls_hdr.ls_length));
-                       }
-               }
+       case OSPF_TYPE_LS_UPDATE:
+                lsap = op->ospf_lsu.lsu_lsa;
+                TCHECK(op->ospf_lsu.lsu_count);
+                lsa_count = EXTRACT_32BITS(&op->ospf_lsu.lsu_count);
+                printf(", %d LSA%s",lsa_count, lsa_count > 1 ? "s" : "");
+                while (lsa_count--) {
+                        if (ospf_print_lsa(lsap))
+                                goto trunc;
+                        lsap = (struct lsa *)((u_char *)lsap +
+                                              EXTRACT_16BITS(&lsap->ls_hdr.ls_length));
+                }
                break;
 
                break;
 
-
-       case OSPF_TYPE_LSA:
-               if (vflag) {
-                       lshp = op->ospf_lsa.lsa_lshdr;
-
-                       while (!ospf_print_lshdr(lshp)) {
-                                                       /* { (ctags) */
-                               printf(" }");
-                               ++lshp;
-                       }
-               }
-               break;
+       case OSPF_TYPE_LS_ACK:
+                lshp = op->ospf_lsa.lsa_lshdr;
+                while (!ospf_print_lshdr(lshp)) {
+                    ++lshp;
+                }
+                break;
 
        default:
 
        default:
-               printf("v2 type %d", op->ospf_type);
+               printf("v2 type (%d)", op->ospf_type);
                break;
        }
        return (0);
                break;
        }
        return (0);
@@ -510,16 +453,10 @@ ospf_print(register const u_char *bp, register u_int length,
 
        op = (struct ospfhdr *)bp;
        ip = (struct ip *)bp2;
 
        op = (struct ospfhdr *)bp;
        ip = (struct ip *)bp2;
-       /* Print the source and destination address  */
-#if 0
-       (void) printf("%s > %s:",
-           ipaddr_string(&ip->ip_src),
-           ipaddr_string(&ip->ip_dst));
-#endif
 
         /* XXX Before we do anything else, strip off the MD5 trailer */
         TCHECK(op->ospf_authtype);
 
         /* XXX Before we do anything else, strip off the MD5 trailer */
         TCHECK(op->ospf_authtype);
-        if (ntohs(op->ospf_authtype) == OSPF_AUTH_MD5) {
+        if (EXTRACT_16BITS(&op->ospf_authtype) == OSPF_AUTH_MD5) {
                 length -= OSPF_AUTH_MD5_LEN;
                 snapend -= OSPF_AUTH_MD5_LEN;
         }
                 length -= OSPF_AUTH_MD5_LEN;
                 snapend -= OSPF_AUTH_MD5_LEN;
         }
@@ -527,50 +464,57 @@ ospf_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->ospf_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->ospf_type);
-       cp = tok2str(type2str, "type%d", op->ospf_type);
-       printf(" OSPFv%d-%s %d:", op->ospf_version, cp, length);
-       if (*cp == 't')
+       cp = tok2str(type2str, "unknown LS-Type %d", op->ospf_type);
+       printf("OSPFv%d %s length: %d", op->ospf_version, cp, length);
+       if (*cp == 'u')
                return;
 
                return;
 
+        if(!vflag) /* non verbose - so lets bail out here */
+                return;
+
        TCHECK(op->ospf_len);
        TCHECK(op->ospf_len);
-       if (length != ntohs(op->ospf_len)) {
-               printf(" [len %d]", ntohs(op->ospf_len));
+       if (length != EXTRACT_16BITS(&op->ospf_len)) {
+               printf(" [len %d]", EXTRACT_16BITS(&op->ospf_len));
                return;
        }
        dataend = bp + length;
 
                return;
        }
        dataend = bp + length;
 
-       /* Print the routerid if it is not the same as the source */
        TCHECK(op->ospf_routerid);
        TCHECK(op->ospf_routerid);
-       if (ip->ip_src.s_addr != op->ospf_routerid.s_addr)
-               printf(" rtrid %s", ipaddr_string(&op->ospf_routerid));
+        printf("\n\tRouter-ID: %s", ipaddr_string(&op->ospf_routerid));
 
        TCHECK(op->ospf_areaid);
        if (op->ospf_areaid.s_addr != 0)
 
        TCHECK(op->ospf_areaid);
        if (op->ospf_areaid.s_addr != 0)
-               printf(" area %s", ipaddr_string(&op->ospf_areaid));
+               printf(", Area %s", ipaddr_string(&op->ospf_areaid));
        else
        else
-               printf(" backbone");
+               printf(", Backbone Area");
 
        if (vflag) {
                /* Print authentication data (should we really do this?) */
                TCHECK2(op->ospf_authdata[0], sizeof(op->ospf_authdata));
 
        if (vflag) {
                /* Print authentication data (should we really do this?) */
                TCHECK2(op->ospf_authdata[0], sizeof(op->ospf_authdata));
-               switch (ntohs(op->ospf_authtype)) {
+
+                printf(", Authentication Type: %s (%u)",
+                       tok2str(ospf_authtype_values,"unknown",EXTRACT_16BITS(&op->ospf_authtype)),
+                       EXTRACT_16BITS(&op->ospf_authtype));
+
+               switch (EXTRACT_16BITS(&op->ospf_authtype)) {
 
                case OSPF_AUTH_NONE:
                        break;
 
                case OSPF_AUTH_SIMPLE:
 
                case OSPF_AUTH_NONE:
                        break;
 
                case OSPF_AUTH_SIMPLE:
-                       printf(" auth \"");
                        (void)fn_printn(op->ospf_authdata,
                            sizeof(op->ospf_authdata), NULL);
                        printf("\"");
                        break;
 
                case OSPF_AUTH_MD5:
                        (void)fn_printn(op->ospf_authdata,
                            sizeof(op->ospf_authdata), NULL);
                        printf("\"");
                        break;
 
                case OSPF_AUTH_MD5:
-                       printf(" auth MD5");
+                        printf("\n\tKey-ID: %u, Auth-Length: %u, Crypto Sequence Number: 0x%08x",
+                               *((op->ospf_authdata)+2),
+                               *((op->ospf_authdata)+3),
+                               EXTRACT_32BITS((op->ospf_authdata)+4));
                        break;
 
                default:
                        break;
 
                default:
-                       printf(" ??authtype-%d??", ntohs(op->ospf_authtype));
                        return;
                }
        }
                        return;
                }
        }
[mirror] the TCPdump network dissector