Handle very large -f files by rejecting them.

[tcpdump] / print-lwres.c

diff --git a/print-lwres.c b/print-lwres.c
index 9250cf6891de99b04ff58b0cef056e53db28407f..ae352807d006b2399e222b718eabf3dbfd24bbc2 100644 (file)
--- a/print-lwres.c
+++ b/print-lwres.c
@@ -27,39 +27,27 @@
  * 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
+/* \summary: BIND9 Lightweight Resolver protocol printer */

 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 

-#include <sys/param.h>
-#include <sys/time.h>
-
-#include <netinet/in.h>
+#include <netdissect-stdinc.h>

 
 

-#ifdef NOERROR
-#undef NOERROR                                 /* Solaris sucks */
-#endif
-#ifdef NOERROR
-#undef T_UNSPEC                                        /* SINIX does too */
-#endif

 #include "nameser.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include "nameser.h"
 
 #include <stdio.h>
 #include <string.h>
 

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

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

-#include "extract.h"                    /* must come after interface.h */
+#include "extract.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;
+typedef uint32_t lwres_uint32_t;
+typedef uint16_t lwres_uint16_t;
+typedef uint8_t lwres_uint8_t;

 
 struct lwres_lwpacket {
        lwres_uint32_t          length;
 
 struct lwres_lwpacket {
        lwres_uint32_t          length;


@@ -73,6 +61,10 @@ struct lwres_lwpacket {
        lwres_uint16_t          authlength;
 };
 
        lwres_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
 


@@ -84,13 +76,13 @@ struct lwres_lwpacket {
 typedef struct {
        /* public */
        lwres_uint16_t                  datalength;
 typedef struct {
        /* public */
        lwres_uint16_t                  datalength;

-       unsigned char                   *data;
+       /* data follows */

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

-       unsigned char                  *data;
+       /* data follows */

 } lwres_noopresponse_t;
 
 /*
 } lwres_noopresponse_t;
 
 /*


@@ -98,6 +90,14 @@ typedef struct {
  */
 #define LWRES_OPCODE_GETADDRSBYNAME    0x00010001U
 
  */
 #define LWRES_OPCODE_GETADDRSBYNAME    0x00010001U
 

+typedef struct lwres_addr lwres_addr_t;
+
+struct lwres_addr {
+       lwres_uint32_t                  family;
+       lwres_uint16_t                  length;
+       /* address folows */
+};
+

 typedef struct {
        /* public */
        lwres_uint32_t                  flags;
 typedef struct {
        /* public */
        lwres_uint32_t                  flags;


@@ -111,16 +111,10 @@ typedef struct {
        lwres_uint32_t                  flags;
        lwres_uint16_t                  naliases;
        lwres_uint16_t                  naddrs;
        lwres_uint32_t                  flags;
        lwres_uint16_t                  naliases;
        lwres_uint16_t                  naddrs;

-       char                           *realname;
-       char                          **aliases;

        lwres_uint16_t                  realnamelen;
        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
+       /* aliases follows */
+       /* addrs follows */
+       /* realname follows */

 } lwres_gabnresponse_t;
 
 /*
 } lwres_gabnresponse_t;
 
 /*


@@ -130,24 +124,17 @@ typedef struct {
 typedef struct {
        /* public */
        lwres_uint32_t                  flags;
 typedef struct {
        /* public */
        lwres_uint32_t                  flags;

-#if 0

        lwres_addr_t                    addr;
        lwres_addr_t                    addr;

-#endif
+       /* addr body follows */

 } lwres_gnbarequest_t;
 
 typedef struct {
        /* public */
        lwres_uint32_t                  flags;
        lwres_uint16_t                  naliases;
 } lwres_gnbarequest_t;
 
 typedef struct {
        /* public */
        lwres_uint32_t                  flags;
        lwres_uint16_t                  naliases;

-#if 0
-       char                           *realname;
-       char                          **aliases;

        lwres_uint16_t                  realnamelen;
        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
+       /* aliases follows */
+       /* realname follows */

 } lwres_gnbaresponse_t;
 
 /*
 } lwres_gnbaresponse_t;
 
 /*


@@ -161,9 +148,7 @@ typedef struct {
        lwres_uint16_t                  rdclass;
        lwres_uint16_t                  rdtype;
        lwres_uint16_t                  namelen;
        lwres_uint16_t                  rdclass;
        lwres_uint16_t                  rdtype;
        lwres_uint16_t                  namelen;

-#if 0
-       char                           *name;
-#endif
+       /* name follows */

 } lwres_grbnrequest_t;
 
 typedef struct {
 } lwres_grbnrequest_t;
 
 typedef struct {


@@ -174,17 +159,9 @@ typedef struct {
        lwres_uint32_t                  ttl;
        lwres_uint16_t                  nrdatas;
        lwres_uint16_t                  nsigs;
        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
+       /* realname here (len + name) */
+       /* rdata here (len + name) */
+       /* signatures here (len + name) */

 } lwres_grbnresponse_t;
 
 #define LWRDATA_VALIDATED      0x00000001
 } lwres_grbnresponse_t;
 
 #define LWRDATA_VALIDATED      0x00000001


@@ -195,12 +172,7 @@ 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_NOOP,            "noop", },
        { LWRES_OPCODE_GETADDRSBYNAME,  "getaddrsbyname", },
        { LWRES_OPCODE_GETNAMEBYADDR,   "getnamebyaddr", },


@@ -208,120 +180,416 @@ struct vstr opcode[] = {
        { 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 int
+lwres_printname(netdissect_options *ndo,
+                size_t l, const char *p0)
+{
+       const char *p;
+       size_t i;
+
+       p = p0;
+       /* + 1 for terminating \0 */
+       if (p + l + 1 > (const char *)ndo->ndo_snapend)
+               goto trunc;
+
+       ND_PRINT((ndo, " "));
+       for (i = 0; i < l; i++)
+               safeputchar(ndo, *p++);
+       p++;    /* skip terminating \0 */
+
+       return p - p0;
+
+  trunc:
+       return -1;
+}
+
+static int
+lwres_printnamelen(netdissect_options *ndo,
+                   const char *p)
+{
+       uint16_t l;
+       int advance;
+
+       if (p + 2 > (const char *)ndo->ndo_snapend)
+               goto trunc;
+       l = EXTRACT_16BITS(p);
+       advance = lwres_printname(ndo, l, p + 2);
+       if (advance < 0)
+               goto trunc;
+       return 2 + advance;
+
+  trunc:
+       return -1;
+}
+
+static int
+lwres_printbinlen(netdissect_options *ndo,
+                  const char *p0)
+{
+       const char *p;
+       uint16_t l;
+       int i;
+
+       p = p0;
+       if (p + 2 > (const char *)ndo->ndo_snapend)
+               goto trunc;
+       l = EXTRACT_16BITS(p);
+       if (p + 2 + l > (const char *)ndo->ndo_snapend)
+               goto trunc;
+       p += 2;
+       for (i = 0; i < l; i++)
+               ND_PRINT((ndo, "%02x", *p++));
+       return p - p0;

 
 

-static const char *
-vtostr(p, v, lastresort)
-       struct vstr *p;
-       u_int32_t v;
-       const char *lastresort;
+  trunc:
+       return -1;
+}
+
+static int
+lwres_printaddr(netdissect_options *ndo,
+                const lwres_addr_t *ap)

 {
 {

+       uint16_t l;
+       const char *p;
+       int i;

 
 

-       while (p->s) {
-               if (v == p->v)
-                       return p->s;
-               p++;
+       ND_TCHECK(ap->length);
+       l = EXTRACT_16BITS(&ap->length);
+       /* XXX ap points to packed struct */
+       p = (const char *)&ap->length + sizeof(ap->length);
+       ND_TCHECK2(*p, l);
+
+       switch (EXTRACT_32BITS(&ap->family)) {
+       case 1: /* IPv4 */
+               if (l < 4)
+                       return -1;
+               ND_PRINT((ndo, " %s", ipaddr_string(ndo, p)));
+               p += sizeof(struct in_addr);
+               break;
+       case 2: /* IPv6 */
+               if (l < 16)
+                       return -1;
+               ND_PRINT((ndo, " %s", ip6addr_string(ndo, p)));
+               p += sizeof(struct in6_addr);
+               break;
+       default:
+               ND_PRINT((ndo, " %u/", EXTRACT_32BITS(&ap->family)));
+               for (i = 0; i < l; i++)
+                       ND_PRINT((ndo, "%02x", *p++));

        }
 
        }
 

-       return lastresort;
+       return p - (const char *)ap;
+
+  trunc:
+       return -1;

 }
 
 void
 }
 
 void

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

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

-       u_int32_t v;
+       uint32_t v;

        const char *s;
        const char *s;

-#if 0
-       u_int32_t l;
-       lwres_gabnrequest_t *gabn;
-       int i;
-#endif
+       int response;
+       int advance;
+       int unsupported = 0;

 
        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(np->authlength);
+
+       ND_PRINT((ndo, " lwres"));
+       v = EXTRACT_16BITS(&np->version);
+       if (ndo->ndo_vflag || v != LWRES_LWPACKETVERSION_0)
+               ND_PRINT((ndo, " v%u", v));
+       if (v != LWRES_LWPACKETVERSION_0) {
+               s = (const char *)np + EXTRACT_32BITS(&np->length);
+               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 = EXTRACT_16BITS(&np->pktflags) & LWRES_LWPACKETFLAG_RESPONSE;
+
+       /* opcode and pktflags */
+       v = EXTRACT_32BITS(&np->opcode);
+       s = tok2str(opcode, "#0x%x", v);
+       ND_PRINT((ndo, " %s%s", s, response ? "" : "?"));
+
+       /* pktflags */
+       v = EXTRACT_16BITS(&np->pktflags);
+       if (v & ~LWRES_LWPACKETFLAG_RESPONSE)
+               ND_PRINT((ndo, "[0x%x]", v));
+
+       if (ndo->ndo_vflag > 1) {
+               ND_PRINT((ndo, " ("));  /*)*/
+               ND_PRINT((ndo, "serial:0x%x", EXTRACT_32BITS(&np->serial)));
+               ND_PRINT((ndo, " result:0x%x", EXTRACT_32BITS(&np->result)));
+               ND_PRINT((ndo, " recvlen:%u", EXTRACT_32BITS(&np->recvlength)));
+               /* BIND910: not used */
+               if (ndo->ndo_vflag > 2) {
+                       ND_PRINT((ndo, " authtype:0x%x", EXTRACT_16BITS(&np->authtype)));
+                       ND_PRINT((ndo, " authlen:%u", EXTRACT_16BITS(&np->authlength)));
+               }

                /*(*/
                /*(*/

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

        }
 
        }
 

-#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;
+
+               switch (EXTRACT_32BITS(&np->opcode)) {
+               case LWRES_OPCODE_NOOP:

                        break;
                        break;

-               case LWRES_ADDRTYPE_V6:
-                       printf(" IPv6");
+               case LWRES_OPCODE_GETADDRSBYNAME:
+                       gabn = (const lwres_gabnrequest_t *)(np + 1);
+                       ND_TCHECK(gabn->namelen);
+                       /* XXX gabn points to packed struct */
+                       s = (const char *)&gabn->namelen +
+                           sizeof(gabn->namelen);
+                       l = EXTRACT_16BITS(&gabn->namelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT((ndo, " flags:0x%x",
+                                   EXTRACT_32BITS(&gabn->flags)));
+                       }
+
+                       v = EXTRACT_32BITS(&gabn->addrtypes);
+                       switch (v & (LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6)) {
+                       case LWRES_ADDRTYPE_V4:
+                               ND_PRINT((ndo, " IPv4"));
+                               break;
+                       case LWRES_ADDRTYPE_V6:
+                               ND_PRINT((ndo, " IPv6"));
+                               break;
+                       case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
+                               ND_PRINT((ndo, " IPv4/6"));
+                               break;
+                       }
+                       if (v & ~(LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6))
+                               ND_PRINT((ndo, "[0x%x]", v));
+
+                       advance = lwres_printname(ndo, l, s);
+                       if (advance < 0)
+                               goto trunc;
+                       s += advance;

                        break;
                        break;

-               case LWRES_ADDRTYPE_V4 | LWRES_ADDRTYPE_V6:
-                       printf(" IPv4/6");
+               case LWRES_OPCODE_GETNAMEBYADDR:
+                       gnba = (const lwres_gnbarequest_t *)(np + 1);
+                       ND_TCHECK(gnba->addr);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT((ndo, " flags:0x%x",
+                                   EXTRACT_32BITS(&gnba->flags)));
+                       }
+
+                       s = (const char *)&gnba->addr;
+
+                       advance = lwres_printaddr(ndo, &gnba->addr);
+                       if (advance < 0)
+                               goto trunc;
+                       s += advance;
+                       break;
+               case LWRES_OPCODE_GETRDATABYNAME:
+                       /* XXX no trace, not tested */
+                       grbn = (const lwres_grbnrequest_t *)(np + 1);
+                       ND_TCHECK(grbn->namelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT((ndo, " flags:0x%x",
+                                   EXTRACT_32BITS(&grbn->flags)));
+                       }
+
+                       ND_PRINT((ndo, " %s", tok2str(ns_type2str, "Type%d",
+                           EXTRACT_16BITS(&grbn->rdtype))));
+                       if (EXTRACT_16BITS(&grbn->rdclass) != C_IN) {
+                               ND_PRINT((ndo, " %s", tok2str(ns_class2str, "Class%d",
+                                   EXTRACT_16BITS(&grbn->rdclass))));
+                       }
+
+                       /* XXX grbn points to packed struct */
+                       s = (const char *)&grbn->namelen +
+                           sizeof(grbn->namelen);
+                       l = EXTRACT_16BITS(&grbn->namelen);
+
+                       advance = lwres_printname(ndo, l, s);
+                       if (advance < 0)
+                               goto trunc;
+                       s += advance;
+                       break;
+               default:
+                       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;
+
+               switch (EXTRACT_32BITS(&np->opcode)) {
+               case LWRES_OPCODE_NOOP:
+                       break;
+               case LWRES_OPCODE_GETADDRSBYNAME:
+                       gabn = (const lwres_gabnresponse_t *)(np + 1);
+                       ND_TCHECK(gabn->realnamelen);
+                       /* XXX gabn points to packed struct */
+                       s = (const char *)&gabn->realnamelen +
+                           sizeof(gabn->realnamelen);
+                       l = EXTRACT_16BITS(&gabn->realnamelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT((ndo, " flags:0x%x",
+                                   EXTRACT_32BITS(&gabn->flags)));
+                       }
+
+                       ND_PRINT((ndo, " %u/%u", EXTRACT_16BITS(&gabn->naliases),
+                           EXTRACT_16BITS(&gabn->naddrs)));
+
+                       advance = lwres_printname(ndo, l, s);
+                       if (advance < 0)
+                               goto trunc;
+                       s += advance;
+
+                       /* aliases */
+                       na = EXTRACT_16BITS(&gabn->naliases);
+                       for (i = 0; i < na; i++) {
+                               advance = lwres_printnamelen(ndo, s);
+                               if (advance < 0)
+                                       goto trunc;
+                               s += advance;
+                       }
+
+                       /* addrs */
+                       na = EXTRACT_16BITS(&gabn->naddrs);
+                       for (i = 0; i < na; i++) {
+                               advance = lwres_printaddr(ndo, (const lwres_addr_t *)s);
+                               if (advance < 0)
+                                       goto trunc;
+                               s += advance;
+                       }
+                       break;
+               case LWRES_OPCODE_GETNAMEBYADDR:
+                       gnba = (const lwres_gnbaresponse_t *)(np + 1);
+                       ND_TCHECK(gnba->realnamelen);
+                       /* XXX gnba points to packed struct */
+                       s = (const char *)&gnba->realnamelen +
+                           sizeof(gnba->realnamelen);
+                       l = EXTRACT_16BITS(&gnba->realnamelen);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT((ndo, " flags:0x%x",
+                                   EXTRACT_32BITS(&gnba->flags)));
+                       }
+
+                       ND_PRINT((ndo, " %u", EXTRACT_16BITS(&gnba->naliases)));
+
+                       advance = lwres_printname(ndo, l, s);
+                       if (advance < 0)
+                               goto trunc;
+                       s += advance;
+
+                       /* aliases */
+                       na = EXTRACT_16BITS(&gnba->naliases);
+                       for (i = 0; i < na; i++) {
+                               advance = lwres_printnamelen(ndo, s);
+                               if (advance < 0)
+                                       goto trunc;
+                               s += advance;
+                       }
+                       break;
+               case LWRES_OPCODE_GETRDATABYNAME:
+                       /* XXX no trace, not tested */
+                       grbn = (const lwres_grbnresponse_t *)(np + 1);
+                       ND_TCHECK(grbn->nsigs);
+
+                       /* BIND910: not used */
+                       if (ndo->ndo_vflag > 2) {
+                               ND_PRINT((ndo, " flags:0x%x",
+                                   EXTRACT_32BITS(&grbn->flags)));
+                       }
+
+                       ND_PRINT((ndo, " %s", tok2str(ns_type2str, "Type%d",
+                           EXTRACT_16BITS(&grbn->rdtype))));
+                       if (EXTRACT_16BITS(&grbn->rdclass) != C_IN) {
+                               ND_PRINT((ndo, " %s", tok2str(ns_class2str, "Class%d",
+                                   EXTRACT_16BITS(&grbn->rdclass))));
+                       }
+                       ND_PRINT((ndo, " TTL "));
+                       unsigned_relts_print(ndo, EXTRACT_32BITS(&grbn->ttl));
+                       ND_PRINT((ndo, " %u/%u", EXTRACT_16BITS(&grbn->nrdatas),
+                           EXTRACT_16BITS(&grbn->nsigs)));
+
+                       /* XXX grbn points to packed struct */
+                       s = (const char *)&grbn->nsigs+ sizeof(grbn->nsigs);
+
+                       advance = lwres_printnamelen(ndo, s);
+                       if (advance < 0)
+                               goto trunc;
+                       s += advance;
+
+                       /* rdatas */
+                       na = EXTRACT_16BITS(&grbn->nrdatas);
+                       for (i = 0; i < na; i++) {
+                               /* XXX should decode resource data */
+                               advance = lwres_printbinlen(ndo, s);
+                               if (advance < 0)
+                                       goto trunc;
+                               s += advance;
+                       }
+
+                       /* sigs */
+                       na = EXTRACT_16BITS(&grbn->nsigs);
+                       for (i = 0; i < na; i++) {
+                               /* XXX how should we print it? */
+                               advance = lwres_printbinlen(ndo, s);
+                               if (advance < 0)
+                                       goto trunc;
+                               s += advance;
+                       }
+                       break;
+               default:
+                       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 (EXTRACT_32BITS(&np->length) != length) {
+               ND_PRINT((ndo, " [len: %u != %u]", EXTRACT_32BITS(&np->length),
+                   length));
+       }
+       if (!unsupported && s < (const char *)np + EXTRACT_32BITS(&np->length))
+               ND_PRINT((ndo, "[extra]"));

        return;
 
   trunc:
        return;
 
   trunc:

-       printf("[|lwres]");
-       return;
+       ND_PRINT((ndo, "[|lwres]"));

 }
 }