Revert "autotools: don't link with -lcrypto twice."

[tcpdump] / print-lwres.c

diff --git a/print-lwres.c b/print-lwres.c
index 9250cf6891de99b04ff58b0cef056e53db28407f..29b49c6e7be843c24866b1a5ae6ccb9a1859ec21 100644 (file)
--- a/print-lwres.c
+++ b/print-lwres.c
@@ -27,52 +27,41 @@
  * SUCH DAMAGE.
  */
 
  * SUCH DAMAGE.
  */
 

-#ifndef lint
-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-lwres.c,v 1.1 2001-01-29 09:18:50 itojun Exp $ (LBL)";
-#endif
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <sys/param.h>
-#include <sys/time.h>
-
-#include <netinet/in.h>
-
-#ifdef NOERROR
-#undef NOERROR                                 /* Solaris sucks */
-#endif
-#ifdef NOERROR
-#undef T_UNSPEC                                        /* SINIX does too */
-#endif
-#include "nameser.h"
+/* \summary: BIND9 Lightweight Resolver protocol printer */
+
+#include <config.h>

 
 

-#include <stdio.h>
-#include <string.h>
+#include "netdissect-stdinc.h"

 
 

-#include "interface.h"
+#define ND_LONGJMP_FROM_TCHECK
+#include "netdissect.h"

 #include "addrtoname.h"
 #include "addrtoname.h"

-#include "extract.h"                    /* must come after interface.h */
+#include "extract.h"
+
+#include "nameser.h"

 
 /* BIND9 lib/lwres/include/lwres */
 
 /* BIND9 lib/lwres/include/lwres */

-typedef u_int32_t lwres_uint32_t;
-typedef u_int16_t lwres_uint16_t;
-typedef u_int8_t lwres_uint8_t;
+/*
+ * Use nd_uint16_t for lwres_uint16_t
+ * Use nd_uint32_t for lwres_uint32_t
+*/

 
 struct lwres_lwpacket {
 
 struct lwres_lwpacket {

-       lwres_uint32_t          length;
-       lwres_uint16_t          version;
-       lwres_uint16_t          pktflags;
-       lwres_uint32_t          serial;
-       lwres_uint32_t          opcode;
-       lwres_uint32_t          result;
-       lwres_uint32_t          recvlength;
-       lwres_uint16_t          authtype;
-       lwres_uint16_t          authlength;
+       nd_uint32_t             length;
+       nd_uint16_t             version;
+       nd_uint16_t             pktflags;
+       nd_uint32_t             serial;
+       nd_uint32_t             opcode;
+       nd_uint32_t             result;
+       nd_uint32_t             recvlength;
+       nd_uint16_t             authtype;
+       nd_uint16_t             authlength;

 };
 
 };
 

+#define LWRES_LWPACKETFLAG_RESPONSE    0x0001U /* if set, pkt is a response */
+
+#define LWRES_LWPACKETVERSION_0                0
+

 #define LWRES_FLAG_TRUSTNOTREQUIRED    0x00000001U
 #define LWRES_FLAG_SECUREDATA          0x00000002U
 
 #define LWRES_FLAG_TRUSTNOTREQUIRED    0x00000001U
 #define LWRES_FLAG_SECUREDATA          0x00000002U
 


@@ -83,14 +72,14 @@ struct lwres_lwpacket {
 
 typedef struct {
        /* public */
 
 typedef struct {
        /* public */

-       lwres_uint16_t                  datalength;
-       unsigned char                   *data;
+       nd_uint16_t                     datalength;
+       /* data follows */

 } lwres_nooprequest_t;
 
 typedef struct {
        /* public */
 } lwres_nooprequest_t;
 
 typedef struct {
        /* public */

-       lwres_uint16_t                  datalength;
-       unsigned char                  *data;
+       nd_uint16_t                     datalength;
+       /* data follows */

 } lwres_noopresponse_t;
 
 /*
 } lwres_noopresponse_t;
 
 /*


@@ -98,30 +87,35 @@ typedef struct {
  */
 #define LWRES_OPCODE_GETADDRSBYNAME    0x00010001U
 
  */
 #define LWRES_OPCODE_GETADDRSBYNAME    0x00010001U
 

+typedef struct lwres_addr lwres_addr_t;
+
+struct lwres_addr {
+       nd_uint32_t                     family;
+       nd_uint16_t                     length;
+       /* address follows */
+};
+#define LWRES_ADDR_LEN                 6
+

 typedef struct {
        /* public */
 typedef struct {
        /* public */

-       lwres_uint32_t                  flags;
-       lwres_uint32_t                  addrtypes;
-       lwres_uint16_t                  namelen;
+       nd_uint32_t                     flags;
+       nd_uint32_t                     addrtypes;
+       nd_uint16_t                     namelen;

        /* name follows */
 } lwres_gabnrequest_t;
        /* name follows */
 } lwres_gabnrequest_t;

+#define LWRES_GABNREQUEST_LEN          10

 
 typedef struct {
        /* public */
 
 typedef struct {
        /* public */

-       lwres_uint32_t                  flags;
-       lwres_uint16_t                  naliases;
-       lwres_uint16_t                  naddrs;
-       char                           *realname;
-       char                          **aliases;
-       lwres_uint16_t                  realnamelen;
-       lwres_uint16_t                 *aliaslen;
-#if 0
-       lwres_addrlist_t                addrs;
-       /* if base != NULL, it will be freed when this structure is freed. */
-       void                           *base;
-       size_t                          baselen;
-#endif
+       nd_uint32_t                     flags;
+       nd_uint16_t                     naliases;
+       nd_uint16_t                     naddrs;
+       nd_uint16_t                     realnamelen;
+       /* aliases follows */
+       /* addrs follows */
+       /* realname follows */

 } lwres_gabnresponse_t;
 } lwres_gabnresponse_t;

+#define LWRES_GABNRESPONSE_LEN         10

 
 /*
  * get name by address
 
 /*
  * get name by address


@@ -129,26 +123,20 @@ typedef struct {
 #define LWRES_OPCODE_GETNAMEBYADDR     0x00010002U
 typedef struct {
        /* public */
 #define LWRES_OPCODE_GETNAMEBYADDR     0x00010002U
 typedef struct {
        /* public */

-       lwres_uint32_t                  flags;
-#if 0
-       lwres_addr_t                    addr;
-#endif
+       nd_uint32_t                     flags;
+       /* addr follows */

 } lwres_gnbarequest_t;
 } lwres_gnbarequest_t;

+#define LWRES_GNBAREQUEST_LEN          4

 
 typedef struct {
        /* public */
 
 typedef struct {
        /* public */

-       lwres_uint32_t                  flags;
-       lwres_uint16_t                  naliases;
-#if 0
-       char                           *realname;
-       char                          **aliases;
-       lwres_uint16_t                  realnamelen;
-       lwres_uint16_t                 *aliaslen;
-       /* if base != NULL, it will be freed when this structure is freed. */
-       void                           *base;
-       size_t                          baselen;
-#endif
+       nd_uint32_t                     flags;
+       nd_uint16_t                     naliases;
+       nd_uint16_t                     realnamelen;
+       /* aliases follows */
+       /* realname follows */

 } lwres_gnbaresponse_t;
 } lwres_gnbaresponse_t;

+#define LWRES_GNBARESPONSE_LEN         8

 
 /*
  * get rdata by name
 
 /*
  * get rdata by name


@@ -157,35 +145,27 @@ typedef struct {
 
 typedef struct {
        /* public */
 
 typedef struct {
        /* public */

-       lwres_uint32_t                  flags;
-       lwres_uint16_t                  rdclass;
-       lwres_uint16_t                  rdtype;
-       lwres_uint16_t                  namelen;
-#if 0
-       char                           *name;
-#endif
+       nd_uint32_t                     flags;
+       nd_uint16_t                     rdclass;
+       nd_uint16_t                     rdtype;
+       nd_uint16_t                     namelen;
+       /* name follows */

 } lwres_grbnrequest_t;
 } lwres_grbnrequest_t;

+#define LWRES_GRBNREQUEST_LEN          10

 
 typedef struct {
        /* public */
 
 typedef struct {
        /* public */

-       lwres_uint32_t                  flags;
-       lwres_uint16_t                  rdclass;
-       lwres_uint16_t                  rdtype;
-       lwres_uint32_t                  ttl;
-       lwres_uint16_t                  nrdatas;
-       lwres_uint16_t                  nsigs;
-#if 0
-       char                           *realname;
-       lwres_uint16_t                  realnamelen;
-       unsigned char                 **rdatas;
-       lwres_uint16_t                 *rdatalen;
-       unsigned char                 **sigs;
-       lwres_uint16_t                 *siglen;
-       /* if base != NULL, it will be freed when this structure is freed. */
-       void                           *base;
-       size_t                          baselen;
-#endif
+       nd_uint32_t                     flags;
+       nd_uint16_t                     rdclass;
+       nd_uint16_t                     rdtype;
+       nd_uint32_t                     ttl;
+       nd_uint16_t                     nrdatas;
+       nd_uint16_t                     nsigs;
+       /* realname here (len + name) */
+       /* rdata here (len + name) */
+       /* signatures here (len + name) */

 } lwres_grbnresponse_t;
 } lwres_grbnresponse_t;

+#define LWRES_GRBNRESPONSE_LEN         16

 
 #define LWRDATA_VALIDATED      0x00000001
 
 
 #define LWRDATA_VALIDATED      0x00000001
 


@@ -195,133 +175,381 @@ typedef struct {
 #define LWRES_MAX_ALIASES              16              /* max # of aliases */
 #define LWRES_MAX_ADDRS                        64              /* max # of addrs */
 
 #define LWRES_MAX_ALIASES              16              /* max # of aliases */
 #define LWRES_MAX_ADDRS                        64              /* max # of addrs */
 

-struct vstr {
-       u_int32_t v;
-       const char *s;
-};
-
-struct vstr opcode[] = {
+static const struct tok opcode[] = {

        { LWRES_OPCODE_NOOP,            "noop", },
        { LWRES_OPCODE_GETADDRSBYNAME,  "getaddrsbyname", },
        { LWRES_OPCODE_GETNAMEBYADDR,   "getnamebyaddr", },
        { LWRES_OPCODE_GETRDATABYNAME,  "getrdatabyname", },
        { LWRES_OPCODE_NOOP,            "noop", },
        { LWRES_OPCODE_GETADDRSBYNAME,  "getaddrsbyname", },
        { LWRES_OPCODE_GETNAMEBYADDR,   "getnamebyaddr", },
        { LWRES_OPCODE_GETRDATABYNAME,  "getrdatabyname", },

-       { 0,                            NULL, },
+       { 0,                            NULL, },

 };
 
 };
 

-static const char *vtostr(struct vstr *, u_int32_t, const char *);
+/* print-domain.c */
+extern const struct tok ns_type2str[];
+extern const struct tok ns_class2str[];

 
 

-static const char *
-vtostr(p, v, lastresort)
-       struct vstr *p;
-       u_int32_t v;
-       const char *lastresort;
+static unsigned
+lwres_printname(netdissect_options *ndo,
+                u_int l, const u_char *p0)

 {
 {

+       ND_PRINT(" ");
+       nd_printjn(ndo, p0, l);
+       p0 += l;
+       if (GET_U_1(p0))
+               ND_PRINT(" (not NUL-terminated!)");
+       return l + 1;
+}
+
+static unsigned
+lwres_printnamelen(netdissect_options *ndo,
+                   const u_char *p)
+{
+       uint16_t l;
+       int advance;
+
+       l = GET_BE_U_2(p);
+       advance = lwres_printname(ndo, l, p + 2);
+       return 2 + advance;
+}
+
+static unsigned
+lwres_printbinlen(netdissect_options *ndo,
+                  const u_char *p0)
+{
+       const u_char *p;
+       uint16_t l;
+       int i;

 
 

-       while (p->s) {
-               if (v == p->v)
-                       return p->s;
+       p = p0;
+       l = GET_BE_U_2(p);
+       p += 2;
+       for (i = 0; i < l; i++) {
+               ND_PRINT("%02x", GET_U_1(p));

                p++;
        }
                p++;
        }

+       return 2 + l;
+}
+
+static int
+lwres_printaddr(netdissect_options *ndo,
+                const u_char *p0)
+{
+       const u_char *p;
+       const lwres_addr_t *ap;
+       uint16_t l;
+       int i;

 
 

-       return lastresort;
+       p = p0;
+       ap = (const lwres_addr_t *)p;
+       l = GET_BE_U_2(ap->length);
+       p += LWRES_ADDR_LEN;
+       ND_TCHECK_LEN(p, l);
+
+       switch (GET_BE_U_4(ap->family)) {
+       case 1: /* IPv4 */
+               if (l < 4)
+                       return -1;
+               ND_PRINT(" %s", GET_IPADDR_STRING(p));
+               p += sizeof(nd_ipv4);
+               break;
+       case 2: /* IPv6 */
+               if (l < 16)
+                       return -1;
+               ND_PRINT(" %s", GET_IP6ADDR_STRING(p));
+               p += sizeof(nd_ipv6);
+               break;
+       default:
+               ND_PRINT(" %u/", GET_BE_U_4(ap->family));
+               for (i = 0; i < l; i++) {
+                       ND_PRINT("%02x", GET_U_1(p));
+                       p++;
+               }
+       }
+
+       return ND_BYTES_BETWEEN(p0, p);

 }
 
 void
 }
 
 void

-lwres_print(register const u_char *bp, u_int length)
+lwres_print(netdissect_options *ndo,
+            const u_char *bp, u_int length)

 {
 {

+       const u_char *p;

        const struct lwres_lwpacket *np;
        const struct lwres_lwpacket *np;

-       u_int32_t v;
-       const char *s;
-#if 0
-       u_int32_t l;
-       lwres_gabnrequest_t *gabn;
-       int i;
-#endif
+       uint32_t v;
+       const u_char *s;
+       int response;
+       int advance;
+       int unsupported = 0;

 
 

+       ndo->ndo_protocol = "lwres";

        np = (const struct lwres_lwpacket *)bp;
        np = (const struct lwres_lwpacket *)bp;

-       TCHECK(np->authlength);
-
-       printf(" lwres");
-       if (vflag)
-               printf(" v%u", ntohs(np->version));
-
-       /* opcode */
-       v = (u_int32_t)ntohl(np->opcode);
-       s = vtostr(opcode, v, NULL);
-       if (s) {
-               printf(" %s", s);
-               if (vflag)
-                       printf("(0x%x)", v);
-       } else
-               printf(" 0x%x", v);
-
-       /* flag bit */
-       v = ntohs(np->pktflags);
-       if (v) {
-               printf("[%s%s]",
-                   (v & LWRES_FLAG_TRUSTNOTREQUIRED) ? "t" : "", 
-                   (v & LWRES_FLAG_SECUREDATA) ? "S" : "");
+       ND_TCHECK_2(np->authlength);
+
+       ND_PRINT(" lwres");
+       v = GET_BE_U_2(np->version);
+       if (ndo->ndo_vflag || v != LWRES_LWPACKETVERSION_0)
+               ND_PRINT(" v%u", v);
+       if (v != LWRES_LWPACKETVERSION_0) {
+               uint32_t pkt_len = GET_BE_U_4(np->length);
+               ND_TCHECK_LEN(bp, pkt_len);
+               s = bp + pkt_len;
+               goto tail;

        }
 
        }
 

-       if (vflag > 1) {
-               printf(" (");   /*)*/
-               printf("serial:0x%x", (unsigned int)ntohl(np->serial));
-               printf(" result:0x%x", (unsigned int)ntohl(np->result));
-               printf(" recvlen:%u", (unsigned int)ntohl(np->recvlength));
-               printf(" authtype:0x%x", ntohs(np->authtype));
-               printf(" authlen:%u", ntohs(np->authlength));
+       response = GET_BE_U_2(np->pktflags) & LWRES_LWPACKETFLAG_RESPONSE;
+
+       /* opcode and pktflags */
+       v = GET_BE_U_4(np->opcode);
+       ND_PRINT(" %s%s", tok2str(opcode, "#0x%x", v), response ? "" : "?");
+
+       /* pktflags */
+       v = GET_BE_U_2(np->pktflags);
+       if (v & ~LWRES_LWPACKETFLAG_RESPONSE)
+               ND_PRINT("[0x%x]", v);
+
+       if (ndo->ndo_vflag > 1) {
+               ND_PRINT(" ("); /*)*/
+               ND_PRINT("serial:0x%x", GET_BE_U_4(np->serial));
+               ND_PRINT(" result:0x%x", GET_BE_U_4(np->result));
+               ND_PRINT(" recvlen:%u", GET_BE_U_4(np->recvlength));
+               /* BIND910: not used */
+               if (ndo->ndo_vflag > 2) {
+                       ND_PRINT(" authtype:0x%x", GET_BE_U_2(np->authtype));
+                       ND_PRINT(" authlen:%u", GET_BE_U_2(np->authlength));
+               }

                /*(*/
                /*(*/

-               printf(")");
+               ND_PRINT(")");

        }
 
        }
 

-#if 0 /*not completed yet*/

        /* per-opcode content */
        /* per-opcode content */

-       switch (ntohl(np->opcode)) {
-       case LWRES_OPCODE_NOOP:
-               break;
-       case LWRES_OPCODE_GETADDRSBYNAME:
-               gabn = (lwres_gabnrequest_t *)(np + 1);
-               TCHECK(gabn->namelen);
-               /* XXX gabn points to packed struct */
-               s = (const char *)&gabn->namelen + sizeof(gabn->namelen);
-               l = ntohs(gabn->namelen);
-               if (s + l > (const char *)snapend)
-                       goto trunc;
-
-               printf(" flags:0x%x", (unsigned int)ntohl(gabn->flags));
-               v = (u_int32_t)ntohl(gabn->addrtypes);
-               switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) {
-               case LWRES_ADDRTYPE_V4:
-                       printf(" IPv4");
+       if (!response) {
+               /*
+                * queries
+                */
+               const lwres_gabnrequest_t *gabn;
+               const lwres_gnbarequest_t *gnba;
+               const lwres_grbnrequest_t *grbn;
+               uint32_t l;
+
+               gabn = NULL;
+               gnba = NULL;
+               grbn = NULL;
+
+               p = (const u_char *)(np + 1);
+               switch (GET_BE_U_4(np->opcode)) {
+               case LWRES_OPCODE_NOOP:
+                       s = p;

                        break;
                        break;

-               case LWRES_ADDRTYPE_V6:
-                       printf(" IPv6");
+               case LWRES_OPCODE_GETADDRSBYNAME:
+                       gabn = (const lwres_gabnrequest_t *)p;
+                       ND_TCHECK_2(gabn->namelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT(" flags:0x%x",
+                                   GET_BE_U_4(gabn->flags));
+                       }
+
+                       v = GET_BE_U_4(gabn->addrtypes);
+                       switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) {
+                       case LWRES_ADDRTYPE_V4:
+                               ND_PRINT(" IPv4");
+                               break;
+                       case LWRES_ADDRTYPE_V6:
+                               ND_PRINT(" IPv6");
+                               break;
+                       case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
+                               ND_PRINT(" IPv4/6");
+                               break;
+                       }
+                       if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6))
+                               ND_PRINT("[0x%x]", v);
+
+                       s = p + LWRES_GABNREQUEST_LEN;
+                       l = GET_BE_U_2(gabn->namelen);
+                       advance = lwres_printname(ndo, l, s);
+                       s += advance;

                        break;
                        break;

-               case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
-                       printf(" IPv4/6");
+               case LWRES_OPCODE_GETNAMEBYADDR:
+                       gnba = (const lwres_gnbarequest_t *)p;
+                       ND_TCHECK_4(gnba->flags);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT(" flags:0x%x",
+                                   GET_BE_U_4(gnba->flags));
+                       }
+
+                       s = p + LWRES_GNBAREQUEST_LEN;
+                       advance = lwres_printaddr(ndo, s);
+                       if (advance < 0)
+                               goto invalid;
+                       s += advance;
+                       break;
+               case LWRES_OPCODE_GETRDATABYNAME:
+                       /* XXX no trace, not tested */
+                       grbn = (const lwres_grbnrequest_t *)p;
+                       ND_TCHECK_2(grbn->namelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT(" flags:0x%x",
+                                   GET_BE_U_4(grbn->flags));
+                       }
+
+                       ND_PRINT(" %s", tok2str(ns_type2str, "Type%u",
+                           GET_BE_U_2(grbn->rdtype)));
+                       if (GET_BE_U_2(grbn->rdclass) != C_IN) {
+                               ND_PRINT(" %s", tok2str(ns_class2str, "Class%u",
+                                   GET_BE_U_2(grbn->rdclass)));
+                       }
+
+                       s = p + LWRES_GRBNREQUEST_LEN;
+                       l = GET_BE_U_2(grbn->namelen);
+                       advance = lwres_printname(ndo, l, s);
+                       s += advance;
+                       break;
+               default:
+                       s = p;
+                       unsupported++;
+                       break;
+               }
+       } else {
+               /*
+                * responses
+                */
+               const lwres_gabnresponse_t *gabn;
+               const lwres_gnbaresponse_t *gnba;
+               const lwres_grbnresponse_t *grbn;
+               uint32_t l, na;
+               uint32_t i;
+
+               gabn = NULL;
+               gnba = NULL;
+               grbn = NULL;
+
+               p = (const u_char *)(np + 1);
+               switch (GET_BE_U_4(np->opcode)) {
+               case LWRES_OPCODE_NOOP:
+                       s = p;
+                       break;
+               case LWRES_OPCODE_GETADDRSBYNAME:
+                       gabn = (const lwres_gabnresponse_t *)p;
+                       ND_TCHECK_2(gabn->realnamelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT(" flags:0x%x",
+                                   GET_BE_U_4(gabn->flags));
+                       }
+
+                       ND_PRINT(" %u/%u", GET_BE_U_2(gabn->naliases),
+                                 GET_BE_U_2(gabn->naddrs));
+
+                       s = p + LWRES_GABNRESPONSE_LEN;
+                       l = GET_BE_U_2(gabn->realnamelen);
+                       advance = lwres_printname(ndo, l, s);
+                       s += advance;
+
+                       /* aliases */
+                       na = GET_BE_U_2(gabn->naliases);
+                       for (i = 0; i < na; i++) {
+                               advance = lwres_printnamelen(ndo, s);
+                               s += advance;
+                       }
+
+                       /* addrs */
+                       na = GET_BE_U_2(gabn->naddrs);
+                       for (i = 0; i < na; i++) {
+                               advance = lwres_printaddr(ndo, s);
+                               if (advance < 0)
+                                       goto invalid;
+                               s += advance;
+                       }
+                       break;
+               case LWRES_OPCODE_GETNAMEBYADDR:
+                       gnba = (const lwres_gnbaresponse_t *)p;
+                       ND_TCHECK_2(gnba->realnamelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT(" flags:0x%x",
+                                   GET_BE_U_4(gnba->flags));
+                       }
+
+                       ND_PRINT(" %u", GET_BE_U_2(gnba->naliases));
+
+                       s = p + LWRES_GNBARESPONSE_LEN;
+                       l = GET_BE_U_2(gnba->realnamelen);
+                       advance = lwres_printname(ndo, l, s);
+                       s += advance;
+
+                       /* aliases */
+                       na = GET_BE_U_2(gnba->naliases);
+                       for (i = 0; i < na; i++) {
+                               advance = lwres_printnamelen(ndo, s);
+                               s += advance;
+                       }
+                       break;
+               case LWRES_OPCODE_GETRDATABYNAME:
+                       /* XXX no trace, not tested */
+                       grbn = (const lwres_grbnresponse_t *)p;
+                       ND_TCHECK_2(grbn->nsigs);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT(" flags:0x%x",
+                                   GET_BE_U_4(grbn->flags));
+                       }
+
+                       ND_PRINT(" %s", tok2str(ns_type2str, "Type%u",
+                           GET_BE_U_2(grbn->rdtype)));
+                       if (GET_BE_U_2(grbn->rdclass) != C_IN) {
+                               ND_PRINT(" %s", tok2str(ns_class2str, "Class%u",
+                                   GET_BE_U_2(grbn->rdclass)));
+                       }
+                       ND_PRINT(" TTL ");
+                       unsigned_relts_print(ndo,
+                                            GET_BE_U_4(grbn->ttl));
+                       ND_PRINT(" %u/%u", GET_BE_U_2(grbn->nrdatas),
+                                 GET_BE_U_2(grbn->nsigs));
+
+                       s = p + LWRES_GRBNRESPONSE_LEN;
+                       advance = lwres_printnamelen(ndo, s);
+                       s += advance;
+
+                       /* rdatas */
+                       na = GET_BE_U_2(grbn->nrdatas);
+                       for (i = 0; i < na; i++) {
+                               /* XXX should decode resource data */
+                               advance = lwres_printbinlen(ndo, s);
+                               s += advance;
+                       }
+
+                       /* sigs */
+                       na = GET_BE_U_2(grbn->nsigs);
+                       for (i = 0; i < na; i++) {
+                               /* XXX how should we print it? */
+                               advance = lwres_printbinlen(ndo, s);
+                               s += advance;
+                       }
+                       break;
+               default:
+                       s = p;
+                       unsupported++;

                        break;
                }
                        break;
                }

-               if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6))
-                       printf("[0x%x]", v);
-               printf(" ");
-               for (i = 0; i < l; i++)
-                       safeputchar(s[i]);
-               break;
-       case LWRES_OPCODE_GETNAMEBYADDR:
-               break;
-       case LWRES_OPCODE_GETRDATABYNAME:
-               break;
-       default:
-               break;

        }
        }

-#endif

 
 

+  tail:

        /* length mismatch */
        /* length mismatch */

-       if (ntohl(np->length) != length)
-               printf(" [len: %u != %u]", (unsigned int)ntohl(np->length), length);
+       if (GET_BE_U_4(np->length) != length) {
+               ND_PRINT(" [len: %u != %u]", GET_BE_U_4(np->length),
+                         length);
+       }
+       if (!unsupported && ND_BYTES_BETWEEN(bp, s) < GET_BE_U_4(np->length))
+               ND_PRINT("[extra]");

        return;
 
        return;
 

-  trunc:
-       printf("[|lwres]");
-       return;
+  invalid:
+       nd_print_invalid(ndo);

 }
 }