From: Denis Ovsienko <infrastation@yandex.ru>
Date: Wed, 26 Mar 2014 11:47:29 +0000 (+0400)
Subject: NDOize AODV, IPv4 and SCTP decoders
X-Git-Tag: tcpdump-4.6.0~148
X-Git-Url: https://git.tcpdump.org/tcpdump/commitdiff_plain/b6303af682e72841f79ac6847f93b0cb0a49c549

NDOize AODV, IPv4 and SCTP decoders
---

diff --git a/interface.h b/interface.h
index b739694b..024e3668 100644
--- a/interface.h
+++ b/interface.h
@@ -164,7 +164,6 @@ extern u_int16_t create_osi_cksum(const u_int8_t *, int, int);
 
 extern void ascii_print(const u_char *, u_int);
 extern void aarp_print(const u_char *, u_int);
-extern void aodv_print(const u_char *, u_int, int);
 extern void atalk_print(const u_char *, u_int);
 extern void bgp_print(const u_char *, int);
 extern void decnet_print(const u_char *, u_int, u_int);
@@ -224,7 +223,6 @@ extern void print_data(const unsigned char *, int);
 extern void cfm_print(const u_char *, u_int);
 extern void cdp_print(const u_char *, u_int, u_int);
 extern void lwres_print(const u_char *, u_int);
-extern void sctp_print(const u_char *, const u_char *, u_int);
 extern void forces_print(const u_char *, u_int);
 extern void mpls_lsp_ping_print(const u_char *, u_int);
 extern void sip_print(const u_char *, u_int);
diff --git a/ip.h b/ip.h
index 2fcb40ea..64ec5dc6 100644
--- a/ip.h
+++ b/ip.h
@@ -33,6 +33,9 @@
  *	@(#)ip.h	8.2 (Berkeley) 6/1/94
  */
 
+#ifndef TCPDUMP_IP_H
+#define TCPDUMP_IP_H
+
 /*
  * Definitions for internet protocol version 4.
  * Per RFC 791, September 1981.
@@ -158,6 +161,4 @@ struct	ip_timestamp {
 #define	IPTTLDEC	1		/* subtracted when forwarding */
 
 #define	IP_MSS		576		/* default maximum segment size */
-
-/* in print-ip.c */
-extern int nextproto4_cksum(const struct ip *, const u_int8_t *, u_int, u_int, u_int);
+#endif /* TCPDUMP_IP_H */
diff --git a/netdissect.h b/netdissect.h
index 41e95c74..5ad150d1 100644
--- a/netdissect.h
+++ b/netdissect.h
@@ -38,6 +38,8 @@
 
 #include <stdarg.h>
 
+#include "ip.h" /* struct ip for nextproto4_cksum() */
+
 #if !defined(HAVE_SNPRINTF)
 int snprintf (char *str, size_t sz, const char *format, ...)
 #ifdef __ATTRIBUTE___FORMAT_OK
@@ -467,6 +469,8 @@ extern const u_char * ns_nprint (netdissect_options *, register const u_char *,
 extern void ns_print(netdissect_options *, const u_char *, u_int, int);
 extern void bootp_print(netdissect_options *, const u_char *, u_int);
 extern void sflow_print(netdissect_options *, const u_char *, u_int);
+extern void aodv_print(netdissect_options *, const u_char *, u_int, int);
+extern void sctp_print(netdissect_options *, const u_char *, const u_char *, u_int);
 
 /* stuff that has not yet been rototiled */
 
@@ -505,10 +509,6 @@ extern void ppp_hdlc_if_print(u_char *,
 extern void ppp_bsdos_if_print(u_char *,
 			       const struct pcap_pkthdr *, const u_char *);
 
-extern void sctp_print(netdissect_options *ndo,
-		       const u_char *bp, const u_char *bp2,
-		       u_int sctpPacketLength);
-
 extern void snmp_print(netdissect_options *,const u_char *, u_int);
 extern void tcp_print(netdissect_options *,const u_char *, u_int,
 		      const u_char *, int);
@@ -562,6 +562,7 @@ struct cksum_vec {
 extern u_int16_t in_cksum(const struct cksum_vec *, int);
 extern u_int16_t in_cksum_shouldbe(u_int16_t, u_int16_t);
 #endif
+extern int nextproto4_cksum(netdissect_options *ndo, const struct ip *, const u_int8_t *, u_int, u_int, u_int);
 
 extern void esp_print_decodesecret(netdissect_options *ndo);
 extern int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
diff --git a/print-aodv.c b/print-aodv.c
index 47f09a77..e8ab1ca2 100644
--- a/print-aodv.c
+++ b/print-aodv.c
@@ -30,16 +30,15 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#define NETDISSECT_REWORKED
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 
+/* for offsetof */
 #include <stddef.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <string.h>
 
 #include "interface.h"
 #include "addrtoname.h"
@@ -202,50 +201,52 @@ struct aodv_hello {
 #define	AODV_EXT_HELLO	1
 
 static void
-aodv_extension(const struct aodv_ext *ep, u_int length)
+aodv_extension(netdissect_options *ndo,
+               const struct aodv_ext *ep, u_int length)
 {
 	u_int i;
 	const struct aodv_hello *ah;
 
 	switch (ep->type) {
 	case AODV_EXT_HELLO:
-		if (snapend < (u_char *) ep) {
-			printf(" [|hello]");
+		if (ndo->ndo_snapend < (u_char *) ep) {
+			ND_PRINT((ndo, " [|hello]"));
 			return;
 		}
-		i = min(length, (u_int)(snapend - (u_char *)ep));
+		i = min(length, (u_int)(ndo->ndo_snapend - (u_char *)ep));
 		if (i < sizeof(struct aodv_hello)) {
-			printf(" [|hello]");
+			ND_PRINT((ndo, " [|hello]"));
 			return;
 		}
 		i -= sizeof(struct aodv_hello);
 		ah = (void *)ep;
-		printf("\n\text HELLO %ld ms",
-		    (unsigned long)EXTRACT_32BITS(&ah->interval));
+		ND_PRINT((ndo, "\n\text HELLO %ld ms",
+		    (unsigned long)EXTRACT_32BITS(&ah->interval)));
 		break;
 
 	default:
-		printf("\n\text %u %u", ep->type, ep->length);
+		ND_PRINT((ndo, "\n\text %u %u", ep->type, ep->length));
 		break;
 	}
 }
 
 static void
-aodv_rreq(const union aodv *ap, const u_char *dat, u_int length)
+aodv_rreq(netdissect_options *ndo,
+          const union aodv *ap, const u_char *dat, u_int length)
 {
 	u_int i;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < sizeof(ap->rreq)) {
-		printf(" [|rreq]");
+		ND_PRINT((ndo, " [|rreq]"));
 		return;
 	}
 	i -= sizeof(ap->rreq);
-	printf(" rreq %u %s%s%s%s%shops %u id 0x%08lx\n"
+	ND_PRINT((ndo, " rreq %u %s%s%s%s%shops %u id 0x%08lx\n"
 	    "\tdst %s seq %lu src %s seq %lu", length,
 	    ap->rreq.rreq_type & RREQ_JOIN ? "[J]" : "",
 	    ap->rreq.rreq_type & RREQ_REPAIR ? "[R]" : "",
@@ -257,27 +258,28 @@ aodv_rreq(const union aodv *ap, const u_char *dat, u_int length)
 	    ipaddr_string(&ap->rreq.rreq_da),
 	    (unsigned long)EXTRACT_32BITS(&ap->rreq.rreq_ds),
 	    ipaddr_string(&ap->rreq.rreq_oa),
-	    (unsigned long)EXTRACT_32BITS(&ap->rreq.rreq_os));
+	    (unsigned long)EXTRACT_32BITS(&ap->rreq.rreq_os)));
 	if (i >= sizeof(struct aodv_ext))
-		aodv_extension((void *)(&ap->rreq + 1), i);
+		aodv_extension(ndo, (void *)(&ap->rreq + 1), i);
 }
 
 static void
-aodv_rrep(const union aodv *ap, const u_char *dat, u_int length)
+aodv_rrep(netdissect_options *ndo,
+          const union aodv *ap, const u_char *dat, u_int length)
 {
 	u_int i;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < sizeof(ap->rrep)) {
-		printf(" [|rrep]");
+		ND_PRINT((ndo, " [|rrep]"));
 		return;
 	}
 	i -= sizeof(ap->rrep);
-	printf(" rrep %u %s%sprefix %u hops %u\n"
+	ND_PRINT((ndo, " rrep %u %s%sprefix %u hops %u\n"
 	    "\tdst %s dseq %lu src %s %lu ms", length,
 	    ap->rrep.rrep_type & RREP_REPAIR ? "[R]" : "",
 	    ap->rrep.rrep_type & RREP_ACK ? "[A] " : " ",
@@ -286,64 +288,67 @@ aodv_rrep(const union aodv *ap, const u_char *dat, u_int length)
 	    ipaddr_string(&ap->rrep.rrep_da),
 	    (unsigned long)EXTRACT_32BITS(&ap->rrep.rrep_ds),
 	    ipaddr_string(&ap->rrep.rrep_oa),
-	    (unsigned long)EXTRACT_32BITS(&ap->rrep.rrep_life));
+	    (unsigned long)EXTRACT_32BITS(&ap->rrep.rrep_life)));
 	if (i >= sizeof(struct aodv_ext))
-		aodv_extension((void *)(&ap->rrep + 1), i);
+		aodv_extension(ndo, (void *)(&ap->rrep + 1), i);
 }
 
 static void
-aodv_rerr(const union aodv *ap, const u_char *dat, u_int length)
+aodv_rerr(netdissect_options *ndo,
+          const union aodv *ap, const u_char *dat, u_int length)
 {
 	u_int i;
 	const struct rerr_unreach *dp = NULL;
 	int n, trunc;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < offsetof(struct aodv_rerr, r)) {
-		printf(" [|rerr]");
+		ND_PRINT((ndo, " [|rerr]"));
 		return;
 	}
 	i -= offsetof(struct aodv_rerr, r);
 	dp = &ap->rerr.r.dest[0];
 	n = ap->rerr.rerr_dc * sizeof(ap->rerr.r.dest[0]);
-	printf(" rerr %s [items %u] [%u]:",
+	ND_PRINT((ndo, " rerr %s [items %u] [%u]:",
 	    ap->rerr.rerr_flags & RERR_NODELETE ? "[D]" : "",
-	    ap->rerr.rerr_dc, length);
+	    ap->rerr.rerr_dc, length));
 	trunc = n - (i/sizeof(ap->rerr.r.dest[0]));
 	for (; i >= sizeof(ap->rerr.r.dest[0]);
 	    ++dp, i -= sizeof(ap->rerr.r.dest[0])) {
-		printf(" {%s}(%ld)", ipaddr_string(&dp->u_da),
-		    (unsigned long)EXTRACT_32BITS(&dp->u_ds));
+		ND_PRINT((ndo, " {%s}(%ld)", ipaddr_string(&dp->u_da),
+		    (unsigned long)EXTRACT_32BITS(&dp->u_ds)));
 	}
 	if (trunc)
-		printf("[|rerr]");
+		ND_PRINT((ndo, "[|rerr]"));
 }
 
 static void
 #ifdef INET6
-aodv_v6_rreq(const union aodv *ap, const u_char *dat, u_int length)
+aodv_v6_rreq(netdissect_options *ndo,
+             const union aodv *ap, const u_char *dat, u_int length)
 #else
-aodv_v6_rreq(const union aodv *ap _U_, const u_char *dat _U_, u_int length)
+aodv_v6_rreq(netdissect_options *ndo,
+             const union aodv *ap _U_, const u_char *dat _U_, u_int length)
 #endif
 {
 #ifdef INET6
 	u_int i;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < sizeof(ap->rreq6)) {
-		printf(" [|rreq6]");
+		ND_PRINT((ndo, " [|rreq6]"));
 		return;
 	}
 	i -= sizeof(ap->rreq6);
-	printf(" v6 rreq %u %s%s%s%s%shops %u id 0x%08lx\n"
+	ND_PRINT((ndo, " v6 rreq %u %s%s%s%s%shops %u id 0x%08lx\n"
 	    "\tdst %s seq %lu src %s seq %lu", length,
 	    ap->rreq6.rreq_type & RREQ_JOIN ? "[J]" : "",
 	    ap->rreq6.rreq_type & RREQ_REPAIR ? "[R]" : "",
@@ -355,35 +360,37 @@ aodv_v6_rreq(const union aodv *ap _U_, const u_char *dat _U_, u_int length)
 	    ip6addr_string(&ap->rreq6.rreq_da),
 	    (unsigned long)EXTRACT_32BITS(&ap->rreq6.rreq_ds),
 	    ip6addr_string(&ap->rreq6.rreq_oa),
-	    (unsigned long)EXTRACT_32BITS(&ap->rreq6.rreq_os));
+	    (unsigned long)EXTRACT_32BITS(&ap->rreq6.rreq_os)));
 	if (i >= sizeof(struct aodv_ext))
-		aodv_extension((void *)(&ap->rreq6 + 1), i);
+		aodv_extension(ndo, (void *)(&ap->rreq6 + 1), i);
 #else
-	printf(" v6 rreq %u", length);
+	ND_PRINT((ndo, " v6 rreq %u", length));
 #endif
 }
 
 static void
 #ifdef INET6
-aodv_v6_rrep(const union aodv *ap, const u_char *dat, u_int length)
+aodv_v6_rrep(netdissect_options *ndo,
+             const union aodv *ap, const u_char *dat, u_int length)
 #else
-aodv_v6_rrep(const union aodv *ap _U_, const u_char *dat _U_, u_int length)
+aodv_v6_rrep(netdissect_options *ndo,
+             const union aodv *ap _U_, const u_char *dat _U_, u_int length)
 #endif
 {
 #ifdef INET6
 	u_int i;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < sizeof(ap->rrep6)) {
-		printf(" [|rrep6]");
+		ND_PRINT((ndo, " [|rrep6]"));
 		return;
 	}
 	i -= sizeof(ap->rrep6);
-	printf(" rrep %u %s%sprefix %u hops %u\n"
+	ND_PRINT((ndo, " rrep %u %s%sprefix %u hops %u\n"
 	   "\tdst %s dseq %lu src %s %lu ms", length,
 	    ap->rrep6.rrep_type & RREP_REPAIR ? "[R]" : "",
 	    ap->rrep6.rrep_type & RREP_ACK ? "[A] " : " ",
@@ -392,19 +399,21 @@ aodv_v6_rrep(const union aodv *ap _U_, const u_char *dat _U_, u_int length)
 	    ip6addr_string(&ap->rrep6.rrep_da),
 	    (unsigned long)EXTRACT_32BITS(&ap->rrep6.rrep_ds),
 	    ip6addr_string(&ap->rrep6.rrep_oa),
-	    (unsigned long)EXTRACT_32BITS(&ap->rrep6.rrep_life));
+	    (unsigned long)EXTRACT_32BITS(&ap->rrep6.rrep_life)));
 	if (i >= sizeof(struct aodv_ext))
-		aodv_extension((void *)(&ap->rrep6 + 1), i);
+		aodv_extension(ndo, (void *)(&ap->rrep6 + 1), i);
 #else
-	printf(" rrep %u", length);
+	ND_PRINT((ndo, " rrep %u", length));
 #endif
 }
 
 static void
 #ifdef INET6
-aodv_v6_rerr(const union aodv *ap, u_int length)
+aodv_v6_rerr(netdissect_options *ndo,
+             const union aodv *ap, u_int length)
 #else
-aodv_v6_rerr(const union aodv *ap _U_, u_int length)
+aodv_v6_rerr(netdissect_options *ndo,
+             const union aodv *ap _U_, u_int length)
 #endif
 {
 #ifdef INET6
@@ -415,43 +424,45 @@ aodv_v6_rerr(const union aodv *ap _U_, u_int length)
 	j = sizeof(ap->rerr.r.dest6[0]);
 	dp6 = &ap->rerr.r.dest6[0];
 	n = ap->rerr.rerr_dc * j;
-	printf(" rerr %s [items %u] [%u]:",
+	ND_PRINT((ndo, " rerr %s [items %u] [%u]:",
 	    ap->rerr.rerr_flags & RERR_NODELETE ? "[D]" : "",
-	    ap->rerr.rerr_dc, length);
+	    ap->rerr.rerr_dc, length));
 	trunc = n - (i/j);
 	for (; i -= j >= 0; ++dp6) {
-		printf(" {%s}(%ld)", ip6addr_string(&dp6->u_da),
-		    (unsigned long)EXTRACT_32BITS(&dp6->u_ds));
+		ND_PRINT((ndo, " {%s}(%ld)", ip6addr_string(&dp6->u_da),
+		    (unsigned long)EXTRACT_32BITS(&dp6->u_ds)));
 	}
 	if (trunc)
-		printf("[|rerr]");
+		ND_PRINT((ndo, "[|rerr]"));
 #else
-	printf(" rerr %u", length);
+	ND_PRINT((ndo, " rerr %u", length));
 #endif
 }
 
 static void
 #ifdef INET6
-aodv_v6_draft_01_rreq(const union aodv *ap, const u_char *dat, u_int length)
+aodv_v6_draft_01_rreq(netdissect_options *ndo,
+                      const union aodv *ap, const u_char *dat, u_int length)
 #else
-aodv_v6_draft_01_rreq(const union aodv *ap _U_, const u_char *dat _U_,
+aodv_v6_draft_01_rreq(netdissect_options *ndo,
+                      const union aodv *ap _U_, const u_char *dat _U_,
     u_int length)
 #endif
 {
 #ifdef INET6
 	u_int i;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < sizeof(ap->rreq6_draft_01)) {
-		printf(" [|rreq6]");
+		ND_PRINT((ndo, " [|rreq6]"));
 		return;
 	}
 	i -= sizeof(ap->rreq6_draft_01);
-	printf(" rreq %u %s%s%s%s%shops %u id 0x%08lx\n"
+	ND_PRINT((ndo, " rreq %u %s%s%s%s%shops %u id 0x%08lx\n"
 	    "\tdst %s seq %lu src %s seq %lu", length,
 	    ap->rreq6_draft_01.rreq_type & RREQ_JOIN ? "[J]" : "",
 	    ap->rreq6_draft_01.rreq_type & RREQ_REPAIR ? "[R]" : "",
@@ -463,36 +474,38 @@ aodv_v6_draft_01_rreq(const union aodv *ap _U_, const u_char *dat _U_,
 	    ip6addr_string(&ap->rreq6_draft_01.rreq_da),
 	    (unsigned long)EXTRACT_32BITS(&ap->rreq6_draft_01.rreq_ds),
 	    ip6addr_string(&ap->rreq6_draft_01.rreq_oa),
-	    (unsigned long)EXTRACT_32BITS(&ap->rreq6_draft_01.rreq_os));
+	    (unsigned long)EXTRACT_32BITS(&ap->rreq6_draft_01.rreq_os)));
 	if (i >= sizeof(struct aodv_ext))
-		aodv_extension((void *)(&ap->rreq6_draft_01 + 1), i);
+		aodv_extension(ndo, (void *)(&ap->rreq6_draft_01 + 1), i);
 #else
-	printf(" rreq %u", length);
+	ND_PRINT((ndo, " rreq %u", length));
 #endif
 }
 
 static void
 #ifdef INET6
-aodv_v6_draft_01_rrep(const union aodv *ap, const u_char *dat, u_int length)
+aodv_v6_draft_01_rrep(netdissect_options *ndo,
+                      const union aodv *ap, const u_char *dat, u_int length)
 #else
-aodv_v6_draft_01_rrep(const union aodv *ap _U_, const u_char *dat _U_,
+aodv_v6_draft_01_rrep(netdissect_options *ndo,
+                      const union aodv *ap _U_, const u_char *dat _U_,
     u_int length)
 #endif
 {
 #ifdef INET6
 	u_int i;
 
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	i = min(length, (u_int)(snapend - dat));
+	i = min(length, (u_int)(ndo->ndo_snapend - dat));
 	if (i < sizeof(ap->rrep6_draft_01)) {
-		printf(" [|rrep6]");
+		ND_PRINT((ndo, " [|rrep6]"));
 		return;
 	}
 	i -= sizeof(ap->rrep6_draft_01);
-	printf(" rrep %u %s%sprefix %u hops %u\n"
+	ND_PRINT((ndo, " rrep %u %s%sprefix %u hops %u\n"
 	   "\tdst %s dseq %lu src %s %lu ms", length,
 	    ap->rrep6_draft_01.rrep_type & RREP_REPAIR ? "[R]" : "",
 	    ap->rrep6_draft_01.rrep_type & RREP_ACK ? "[A] " : " ",
@@ -501,19 +514,21 @@ aodv_v6_draft_01_rrep(const union aodv *ap _U_, const u_char *dat _U_,
 	    ip6addr_string(&ap->rrep6_draft_01.rrep_da),
 	    (unsigned long)EXTRACT_32BITS(&ap->rrep6_draft_01.rrep_ds),
 	    ip6addr_string(&ap->rrep6_draft_01.rrep_oa),
-	    (unsigned long)EXTRACT_32BITS(&ap->rrep6_draft_01.rrep_life));
+	    (unsigned long)EXTRACT_32BITS(&ap->rrep6_draft_01.rrep_life)));
 	if (i >= sizeof(struct aodv_ext))
-		aodv_extension((void *)(&ap->rrep6_draft_01 + 1), i);
+		aodv_extension(ndo, (void *)(&ap->rrep6_draft_01 + 1), i);
 #else
-	printf(" rrep %u", length);
+	ND_PRINT((ndo, " rrep %u", length));
 #endif
 }
 
 static void
 #ifdef INET6
-aodv_v6_draft_01_rerr(const union aodv *ap, u_int length)
+aodv_v6_draft_01_rerr(netdissect_options *ndo,
+                      const union aodv *ap, u_int length)
 #else
-aodv_v6_draft_01_rerr(const union aodv *ap _U_, u_int length)
+aodv_v6_draft_01_rerr(netdissect_options *ndo,
+                      const union aodv *ap _U_, u_int length)
 #endif
 {
 #ifdef INET6
@@ -524,81 +539,82 @@ aodv_v6_draft_01_rerr(const union aodv *ap _U_, u_int length)
 	j = sizeof(ap->rerr.r.dest6_draft_01[0]);
 	dp6 = &ap->rerr.r.dest6_draft_01[0];
 	n = ap->rerr.rerr_dc * j;
-	printf(" rerr %s [items %u] [%u]:",
+	ND_PRINT((ndo, " rerr %s [items %u] [%u]:",
 	    ap->rerr.rerr_flags & RERR_NODELETE ? "[D]" : "",
-	    ap->rerr.rerr_dc, length);
+	    ap->rerr.rerr_dc, length));
 	trunc = n - (i/j);
 	for (; i -= j >= 0; ++dp6) {
-		printf(" {%s}(%ld)", ip6addr_string(&dp6->u_da),
-		    (unsigned long)EXTRACT_32BITS(&dp6->u_ds));
+		ND_PRINT((ndo, " {%s}(%ld)", ip6addr_string(&dp6->u_da),
+		    (unsigned long)EXTRACT_32BITS(&dp6->u_ds)));
 	}
 	if (trunc)
-		printf("[|rerr]");
+		ND_PRINT((ndo, "[|rerr]"));
 #else
-	printf(" rerr %u", length);
+	ND_PRINT((ndo, " rerr %u", length));
 #endif
 }
 
 void
-aodv_print(const u_char *dat, u_int length, int is_ip6)
+aodv_print(netdissect_options *ndo,
+           const u_char *dat, u_int length, int is_ip6)
 {
 	const union aodv *ap;
 
 	ap = (union aodv *)dat;
-	if (snapend < dat) {
-		printf(" [|aodv]");
+	if (ndo->ndo_snapend < dat) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	if (min(length, (u_int)(snapend - dat)) < sizeof(ap->rrep_ack)) {
-		printf(" [|aodv]");
+	if (min(length, (u_int)(ndo->ndo_snapend - dat)) < sizeof(ap->rrep_ack)) {
+		ND_PRINT((ndo, " [|aodv]"));
 		return;
 	}
-	printf(" aodv");
+	ND_PRINT((ndo, " aodv"));
 
 	switch (ap->rerr.rerr_type) {
 
 	case AODV_RREQ:
 		if (is_ip6)
-			aodv_v6_rreq(ap, dat, length);
+			aodv_v6_rreq(ndo, ap, dat, length);
 		else
-			aodv_rreq(ap, dat, length);
+			aodv_rreq(ndo, ap, dat, length);
 		break;
 
 	case AODV_RREP:
 		if (is_ip6)
-			aodv_v6_rrep(ap, dat, length);
+			aodv_v6_rrep(ndo, ap, dat, length);
 		else
-			aodv_rrep(ap, dat, length);
+			aodv_rrep(ndo, ap, dat, length);
 		break;
 
 	case AODV_RERR:
 		if (is_ip6)
-			aodv_v6_rerr(ap, length);
+			aodv_v6_rerr(ndo, ap, length);
 		else
-			aodv_rerr(ap, dat, length);
+			aodv_rerr(ndo, ap, dat, length);
 		break;
 
 	case AODV_RREP_ACK:
-		printf(" rrep-ack %u", length);
+		ND_PRINT((ndo, " rrep-ack %u", length));
 		break;
 
 	case AODV_V6_DRAFT_01_RREQ:
-		aodv_v6_draft_01_rreq(ap, dat, length);
+		aodv_v6_draft_01_rreq(ndo, ap, dat, length);
 		break;
 
 	case AODV_V6_DRAFT_01_RREP:
-		aodv_v6_draft_01_rrep(ap, dat, length);
+		aodv_v6_draft_01_rrep(ndo, ap, dat, length);
 		break;
 
 	case AODV_V6_DRAFT_01_RERR:
-		aodv_v6_draft_01_rerr(ap, length);
+		aodv_v6_draft_01_rerr(ndo, ap, length);
 		break;
 
 	case AODV_V6_DRAFT_01_RREP_ACK:
-		printf(" rrep-ack %u", length);
+		ND_PRINT((ndo, " rrep-ack %u", length));
 		break;
 
 	default:
-		printf(" %u %u", ap->rreq.rreq_type, length);
+		ND_PRINT((ndo, " %u %u", ap->rreq.rreq_type, length));
 	}
 }
diff --git a/print-dccp.c b/print-dccp.c
index e9b246b0..d8a98755 100644
--- a/print-dccp.c
+++ b/print-dccp.c
@@ -183,10 +183,10 @@ static inline u_int dccp_csum_coverage(const struct dccp_hdr* dh, u_int len)
 	return (cov > len)? len : cov;
 }
 
-static int dccp_cksum(const struct ip *ip,
+static int dccp_cksum(netdissect_options *ndo, const struct ip *ip,
 	const struct dccp_hdr *dh, u_int len)
 {
-	return nextproto4_cksum(ip, (const u_int8_t *)(void *)dh, len,
+	return nextproto4_cksum(ndo, ip, (const u_int8_t *)(void *)dh, len,
 				dccp_csum_coverage(dh, len), IPPROTO_DCCP);
 }
 
@@ -334,7 +334,7 @@ void dccp_print(netdissect_options *ndo, const u_char *bp, const u_char *data2,
 		dccp_sum = EXTRACT_16BITS(&dh->dccph_checksum);
 		ND_PRINT((ndo, "cksum 0x%04x ", dccp_sum));
 		if (IP_V(ip) == 4)
-			sum = dccp_cksum(ip, dh, len);
+			sum = dccp_cksum(ndo, ip, dh, len);
 #ifdef INET6
 		else if (IP_V(ip) == 6)
 			sum = dccp6_cksum(ip6, dh, len);
diff --git a/print-ip.c b/print-ip.c
index 449f8c2d..252584da 100644
--- a/print-ip.c
+++ b/print-ip.c
@@ -19,14 +19,13 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
+#define NETDISSECT_REWORKED
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 
 #include "addrtoname.h"
@@ -55,25 +54,26 @@ static const struct tok ip_option_values[] = {
  * print the recorded route in an IP RR, LSRR or SSRR option.
  */
 static void
-ip_printroute(register const u_char *cp, u_int length)
+ip_printroute(netdissect_options *ndo,
+              register const u_char *cp, u_int length)
 {
 	register u_int ptr;
 	register u_int len;
 
 	if (length < 3) {
-		printf(" [bad length %u]", length);
+		ND_PRINT((ndo, " [bad length %u]", length));
 		return;
 	}
 	if ((length + 1) & 3)
-		printf(" [bad length %u]", length);
+		ND_PRINT((ndo, " [bad length %u]", length));
 	ptr = cp[2] - 1;
 	if (ptr < 3 || ((ptr + 1) & 3) || ptr > length + 1)
-		printf(" [bad ptr %u]", cp[2]);
+		ND_PRINT((ndo, " [bad ptr %u]", cp[2]));
 
 	for (len = 3; len < length; len += 4) {
-		printf(" %s", ipaddr_string(&cp[len]));
-                if (ptr > len)
-                        printf(",");
+		ND_PRINT((ndo, " %s", ipaddr_string(&cp[len])));
+		if (ptr > len)
+			ND_PRINT((ndo, ","));
 	}
 }
 
@@ -85,7 +85,8 @@ ip_printroute(register const u_char *cp, u_int length)
  * calculation.
  */
 static u_int32_t
-ip_finddst(const struct ip *ip)
+ip_finddst(netdissect_options *ndo,
+           const struct ip *ip)
 {
 	int length;
 	int len;
@@ -98,19 +99,19 @@ ip_finddst(const struct ip *ip)
 	for (; length > 0; cp += len, length -= len) {
 		int tt;
 
-		TCHECK(*cp);
+		ND_TCHECK(*cp);
 		tt = *cp;
 		if (tt == IPOPT_EOL)
 			break;
 		else if (tt == IPOPT_NOP)
 			len = 1;
 		else {
-			TCHECK(cp[1]);
+			ND_TCHECK(cp[1]);
 			len = cp[1];
 			if (len < 2)
 				break;
 		}
-		TCHECK2(*cp, len);
+		ND_TCHECK2(*cp, len);
 		switch (tt) {
 
 		case IPOPT_SSRR:
@@ -130,8 +131,9 @@ trunc:
  * Compute a V4-style checksum by building a pseudoheader.
  */
 int
-nextproto4_cksum(const struct ip *ip, const u_int8_t *data,
-		 u_int len, u_int covlen, u_int next_proto)
+nextproto4_cksum(netdissect_options *ndo,
+                 const struct ip *ip, const u_int8_t *data,
+                 u_int len, u_int covlen, u_int next_proto)
 {
 	struct phdr {
 		u_int32_t src;
@@ -150,7 +152,7 @@ nextproto4_cksum(const struct ip *ip, const u_int8_t *data,
 	if (IP_HL(ip) == 5)
 		UNALIGNED_MEMCPY(&ph.dst, &ip->ip_dst.s_addr, sizeof(u_int32_t));
 	else
-		ph.dst = ip_finddst(ip);
+		ph.dst = ip_finddst(ndo, ip);
 
 	vec[0].ptr = (const u_int8_t *)(void *)&ph;
 	vec[0].len = sizeof(ph);
@@ -160,7 +162,8 @@ nextproto4_cksum(const struct ip *ip, const u_int8_t *data,
 }
 
 static void
-ip_printts(register const u_char *cp, u_int length)
+ip_printts(netdissect_options *ndo,
+           register const u_char *cp, u_int length)
 {
 	register u_int ptr;
 	register u_int len;
@@ -168,23 +171,23 @@ ip_printts(register const u_char *cp, u_int length)
 	const char *type;
 
 	if (length < 4) {
-		printf("[bad length %u]", length);
+		ND_PRINT((ndo, "[bad length %u]", length));
 		return;
 	}
-	printf(" TS{");
+	ND_PRINT((ndo, " TS{"));
 	hoplen = ((cp[3]&0xF) != IPOPT_TS_TSONLY) ? 8 : 4;
 	if ((length - 4) & (hoplen-1))
-		printf("[bad length %u]", length);
+		ND_PRINT((ndo, "[bad length %u]", length));
 	ptr = cp[2] - 1;
 	len = 0;
 	if (ptr < 4 || ((ptr - 4) & (hoplen-1)) || ptr > length + 1)
-		printf("[bad ptr %u]", cp[2]);
+		ND_PRINT((ndo, "[bad ptr %u]", cp[2]));
 	switch (cp[3]&0xF) {
 	case IPOPT_TS_TSONLY:
-		printf("TSONLY");
+		ND_PRINT((ndo, "TSONLY"));
 		break;
 	case IPOPT_TS_TSANDADDR:
-		printf("TS+ADDR");
+		ND_PRINT((ndo, "TS+ADDR"));
 		break;
 	/*
 	 * prespecified should really be 3, but some ones might send 2
@@ -193,13 +196,13 @@ ip_printts(register const u_char *cp, u_int length)
 	 */
 
 	case 2:
-		printf("PRESPEC2.0");
+		ND_PRINT((ndo, "PRESPEC2.0"));
 		break;
 	case 3:			/* IPOPT_TS_PRESPEC */
-		printf("PRESPEC");
+		ND_PRINT((ndo, "PRESPEC"));
 		break;
 	default:
-		printf("[bad ts type %d]", cp[3]&0xF);
+		ND_PRINT((ndo, "[bad ts type %d]", cp[3]&0xF));
 		goto done;
 	}
 
@@ -207,25 +210,26 @@ ip_printts(register const u_char *cp, u_int length)
 	for (len = 4; len < length; len += hoplen) {
 		if (ptr == len)
 			type = " ^ ";
-		printf("%s%d@%s", type, EXTRACT_32BITS(&cp[len+hoplen-4]),
-		       hoplen!=8 ? "" : ipaddr_string(&cp[len]));
+		ND_PRINT((ndo, "%s%d@%s", type, EXTRACT_32BITS(&cp[len+hoplen-4]),
+		       hoplen!=8 ? "" : ipaddr_string(&cp[len])));
 		type = " ";
 	}
 
 done:
-	printf("%s", ptr == len ? " ^ " : "");
+	ND_PRINT((ndo, "%s", ptr == len ? " ^ " : ""));
 
 	if (cp[3]>>4)
-		printf(" [%d hops not recorded]} ", cp[3]>>4);
+		ND_PRINT((ndo, " [%d hops not recorded]} ", cp[3]>>4));
 	else
-		printf("}");
+		ND_PRINT((ndo, "}"));
 }
 
 /*
  * print IP options.
  */
 static void
-ip_optprint(register const u_char *cp, u_int length)
+ip_optprint(netdissect_options *ndo,
+            register const u_char *cp, u_int length)
 {
 	register u_int option_len;
 	const char *sep = "";
@@ -233,57 +237,57 @@ ip_optprint(register const u_char *cp, u_int length)
 	for (; length > 0; cp += option_len, length -= option_len) {
 		u_int option_code;
 
-		printf("%s", sep);
+		ND_PRINT((ndo, "%s", sep));
 		sep = ",";
 
-		TCHECK(*cp);
+		ND_TCHECK(*cp);
 		option_code = *cp;
 
-                printf("%s",
-                        tok2str(ip_option_values,"unknown %u",option_code));
+		ND_PRINT((ndo, "%s",
+		          tok2str(ip_option_values,"unknown %u",option_code)));
 
 		if (option_code == IPOPT_NOP ||
                     option_code == IPOPT_EOL)
 			option_len = 1;
 
 		else {
-			TCHECK(cp[1]);
+			ND_TCHECK(cp[1]);
 			option_len = cp[1];
 			if (option_len < 2) {
-		                printf(" [bad length %u]", option_len);
+				ND_PRINT((ndo, " [bad length %u]", option_len));
 				return;
 			}
 		}
 
 		if (option_len > length) {
-	                printf(" [bad length %u]", option_len);
+			ND_PRINT((ndo, " [bad length %u]", option_len));
 			return;
 		}
 
-                TCHECK2(*cp, option_len);
+		ND_TCHECK2(*cp, option_len);
 
 		switch (option_code) {
 		case IPOPT_EOL:
 			return;
 
 		case IPOPT_TS:
-			ip_printts(cp, option_len);
+			ip_printts(ndo, cp, option_len);
 			break;
 
 		case IPOPT_RR:       /* fall through */
 		case IPOPT_SSRR:
 		case IPOPT_LSRR:
-			ip_printroute(cp, option_len);
+			ip_printroute(ndo, cp, option_len);
 			break;
 
 		case IPOPT_RA:
 			if (option_len < 4) {
-				printf(" [bad length %u]", option_len);
+				ND_PRINT((ndo, " [bad length %u]", option_len));
 				break;
 			}
-                        TCHECK(cp[3]);
-                        if (EXTRACT_16BITS(&cp[2]) != 0)
-                            printf(" value %u", EXTRACT_16BITS(&cp[2]));
+			ND_TCHECK(cp[3]);
+			if (EXTRACT_16BITS(&cp[2]) != 0)
+				ND_PRINT((ndo, " value %u", EXTRACT_16BITS(&cp[2])));
 			break;
 
 		case IPOPT_NOP:       /* nothing to print - fall through */
@@ -295,7 +299,7 @@ ip_optprint(register const u_char *cp, u_int length)
 	return;
 
 trunc:
-	printf("%s", tstr);
+	ND_PRINT((ndo, "%s", tstr));
 }
 
 #define IP_RES 0x8000
@@ -327,7 +331,7 @@ again:
 
 	case IPPROTO_AH:
 		ipds->nh = *ipds->cp;
-		ipds->advance = ah_print(gndo, ipds->cp);
+		ipds->advance = ah_print(ndo, ipds->cp);
 		if (ipds->advance <= 0)
 			break;
 		ipds->cp += ipds->advance;
@@ -361,7 +365,7 @@ again:
 	}
 
 	case IPPROTO_SCTP:
-		sctp_print(ipds->cp, (const u_char *)ipds->ip, ipds->len);
+		sctp_print(ndo, ipds->cp, (const u_char *)ipds->ip, ipds->len);
 		break;
 
 	case IPPROTO_DCCP:
@@ -426,7 +430,7 @@ again:
 	case IPPROTO_IPV4:
 		/* DVMRP multicast tunnel (ip-in-ip encapsulation) */
 		ip_print(ndo, ipds->cp, ipds->len);
-		if (! vflag) {
+		if (! ndo->ndo_vflag) {
 			ND_PRINT((ndo, " (ipip-proto-4)"));
 			return;
 		}
@@ -459,17 +463,17 @@ again:
 		break;
 
 	case IPPROTO_VRRP:
-		if (packettype == PT_CARP) {
-			if (vflag)
-				(void)printf("carp %s > %s: ",
+		if (ndo->ndo_packettype == PT_CARP) {
+			if (ndo->ndo_vflag)
+				ND_PRINT((ndo, "carp %s > %s: ",
 					     ipaddr_string(&ipds->ip->ip_src),
-					     ipaddr_string(&ipds->ip->ip_dst));
+					     ipaddr_string(&ipds->ip->ip_dst)));
 			carp_print(ndo, ipds->cp, ipds->len, ipds->ip->ip_ttl);
 		} else {
-			if (vflag)
-				(void)printf("vrrp %s > %s: ",
+			if (ndo->ndo_vflag)
+				ND_PRINT((ndo, "vrrp %s > %s: ",
 					     ipaddr_string(&ipds->ip->ip_src),
-					     ipaddr_string(&ipds->ip->ip_dst));
+					     ipaddr_string(&ipds->ip->ip_dst)));
 			vrrp_print(ndo, ipds->cp, ipds->len,
 				(const u_char *)ipds->ip, ipds->ip->ip_ttl);
 		}
@@ -526,35 +530,35 @@ ip_print(netdissect_options *ndo,
 
 	ipds->ip = (const struct ip *)bp;
 	if (IP_V(ipds->ip) != 4) { /* print version if != 4 */
-	    printf("IP%u ", IP_V(ipds->ip));
+	    ND_PRINT((ndo, "IP%u ", IP_V(ipds->ip)));
 	    if (IP_V(ipds->ip) == 6)
-		printf(", wrong link-layer encapsulation");
+	      ND_PRINT((ndo, ", wrong link-layer encapsulation"));
 	}
-        else if (!eflag)
-	    printf("IP ");
+	else if (!ndo->ndo_eflag)
+		ND_PRINT((ndo, "IP "));
 
 	if ((u_char *)(ipds->ip + 1) > ndo->ndo_snapend) {
-		printf("%s", tstr);
+		ND_PRINT((ndo, "%s", tstr));
 		return;
 	}
 	if (length < sizeof (struct ip)) {
-		(void)printf("truncated-ip %u", length);
+		ND_PRINT((ndo, "truncated-ip %u", length));
 		return;
 	}
 	hlen = IP_HL(ipds->ip) * 4;
 	if (hlen < sizeof (struct ip)) {
-		(void)printf("bad-hlen %u", hlen);
+		ND_PRINT((ndo, "bad-hlen %u", hlen));
 		return;
 	}
 
 	ipds->len = EXTRACT_16BITS(&ipds->ip->ip_len);
 	if (length < ipds->len)
-		(void)printf("truncated-ip - %u bytes missing! ",
-			ipds->len - length);
+		ND_PRINT((ndo, "truncated-ip - %u bytes missing! ",
+			ipds->len - length));
 	if (ipds->len < hlen) {
 #ifdef GUESS_TSO
             if (ipds->len) {
-                (void)printf("bad-len %u", ipds->len);
+                ND_PRINT((ndo, "bad-len %u", ipds->len));
                 return;
             }
             else {
@@ -562,7 +566,7 @@ ip_print(netdissect_options *ndo,
                 ipds->len = length;
             }
 #else
-            (void)printf("bad-len %u", ipds->len);
+            ND_PRINT((ndo, "bad-len %u", ipds->len));
             return;
 #endif /* GUESS_TSO */
 	}
@@ -578,24 +582,24 @@ ip_print(netdissect_options *ndo,
 
 	ipds->off = EXTRACT_16BITS(&ipds->ip->ip_off);
 
-        if (vflag) {
-            (void)printf("(tos 0x%x", (int)ipds->ip->ip_tos);
+        if (ndo->ndo_vflag) {
+            ND_PRINT((ndo, "(tos 0x%x", (int)ipds->ip->ip_tos));
             /* ECN bits */
             if (ipds->ip->ip_tos & 0x03) {
                 switch (ipds->ip->ip_tos & 0x03) {
                 case 1:
-                    (void)printf(",ECT(1)");
+                    ND_PRINT((ndo, ",ECT(1)"));
                     break;
                 case 2:
-                    (void)printf(",ECT(0)");
+                    ND_PRINT((ndo, ",ECT(0)"));
                     break;
                 case 3:
-                    (void)printf(",CE");
+                    ND_PRINT((ndo, ",CE"));
                 }
             }
 
             if (ipds->ip->ip_ttl >= 1)
-                (void)printf(", ttl %u", ipds->ip->ip_ttl);
+                ND_PRINT((ndo, ", ttl %u", ipds->ip->ip_ttl));
 
 	    /*
 	     * for the firewall guys, print id, offset.
@@ -603,33 +607,33 @@ ip_print(netdissect_options *ndo,
 	     * For unfragmented datagrams, note the don't fragment flag.
 	     */
 
-	    (void)printf(", id %u, offset %u, flags [%s], proto %s (%u)",
+	    ND_PRINT((ndo, ", id %u, offset %u, flags [%s], proto %s (%u)",
                          EXTRACT_16BITS(&ipds->ip->ip_id),
                          (ipds->off & 0x1fff) * 8,
                          bittok2str(ip_frag_values, "none", ipds->off&0xe000),
                          tok2str(ipproto_values,"unknown",ipds->ip->ip_p),
-                         ipds->ip->ip_p);
+                         ipds->ip->ip_p));
 
-            (void)printf(", length %u", EXTRACT_16BITS(&ipds->ip->ip_len));
+            ND_PRINT((ndo, ", length %u", EXTRACT_16BITS(&ipds->ip->ip_len)));
 
             if ((hlen - sizeof(struct ip)) > 0) {
-                printf(", options (");
-                ip_optprint((u_char *)(ipds->ip + 1), hlen - sizeof(struct ip));
-                printf(")");
+                ND_PRINT((ndo, ", options ("));
+                ip_optprint(ndo, (u_char *)(ipds->ip + 1), hlen - sizeof(struct ip));
+                ND_PRINT((ndo, ")"));
             }
 
-	    if (!Kflag && (u_char *)ipds->ip + hlen <= ndo->ndo_snapend) {
+	    if (!ndo->ndo_Kflag && (u_char *)ipds->ip + hlen <= ndo->ndo_snapend) {
 	        vec[0].ptr = (const u_int8_t *)(void *)ipds->ip;
 	        vec[0].len = hlen;
 	        sum = in_cksum(vec, 1);
 		if (sum != 0) {
 		    ip_sum = EXTRACT_16BITS(&ipds->ip->ip_sum);
-		    (void)printf(", bad cksum %x (->%x)!", ip_sum,
-			     in_cksum_shouldbe(ip_sum, sum));
+		    ND_PRINT((ndo, ", bad cksum %x (->%x)!", ip_sum,
+			     in_cksum_shouldbe(ip_sum, sum)));
 		}
 	    }
 
-            printf(")\n    ");
+		ND_PRINT((ndo, ")\n    "));
 	}
 
 	/*
@@ -642,28 +646,28 @@ ip_print(netdissect_options *ndo,
 
 		if (ipds->nh != IPPROTO_TCP && ipds->nh != IPPROTO_UDP &&
 		    ipds->nh != IPPROTO_SCTP && ipds->nh != IPPROTO_DCCP) {
-			(void)printf("%s > %s: ",
+			ND_PRINT((ndo, "%s > %s: ",
 				     ipaddr_string(&ipds->ip->ip_src),
-				     ipaddr_string(&ipds->ip->ip_dst));
+				     ipaddr_string(&ipds->ip->ip_dst)));
 		}
 		ip_print_demux(ndo, ipds);
 	} else {
 	    /* Ultra quiet now means that all this stuff should be suppressed */
-	    if (qflag > 1) return;
+	    if (ndo->ndo_qflag > 1) return;
 
 	    /*
 	     * if this isn't the first frag, we're missing the
 	     * next level protocol header.  print the ip addr
 	     * and the protocol.
 	     */
-	    if (ipds->off & 0x1fff) {
-	        (void)printf("%s > %s:", ipaddr_string(&ipds->ip->ip_src),
-			     ipaddr_string(&ipds->ip->ip_dst));
-		if (!ndo->ndo_nflag && (proto = getprotobynumber(ipds->ip->ip_p)) != NULL)
-		    (void)printf(" %s", proto->p_name);
-		else
-		    (void)printf(" ip-proto-%d", ipds->ip->ip_p);
-	    }
+		if (ipds->off & 0x1fff) {
+			ND_PRINT((ndo, "%s > %s:", ipaddr_string(&ipds->ip->ip_src),
+			          ipaddr_string(&ipds->ip->ip_dst)));
+			if (!ndo->ndo_nflag && (proto = getprotobynumber(ipds->ip->ip_p)) != NULL)
+				ND_PRINT((ndo, " %s", proto->p_name));
+			else
+				ND_PRINT((ndo, " ip-proto-%d", ipds->ip->ip_p));
+		}
 	}
 }
 
@@ -673,7 +677,7 @@ ipN_print(netdissect_options *ndo, register const u_char *bp, register u_int len
 	struct ip hdr;
 
 	if (length < 4) {
-		(void)printf("truncated-ip %d", length);
+		ND_PRINT((ndo, "truncated-ip %d", length));
 		return;
 	}
 	memcpy (&hdr, bp, 4);
@@ -687,7 +691,7 @@ ipN_print(netdissect_options *ndo, register const u_char *bp, register u_int len
 		return;
 #endif
 	default:
-		(void)printf("unknown ip %d", IP_V(&hdr));
+		ND_PRINT((ndo, "unknown ip %d", IP_V(&hdr)));
 		return;
 	}
 }
diff --git a/print-ip6.c b/print-ip6.c
index dbebc4fb..c18b5f00 100644
--- a/print-ip6.c
+++ b/print-ip6.c
@@ -188,7 +188,7 @@ ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
 			nh = *cp;
 			break;
 		case IPPROTO_SCTP:
-			sctp_print(cp, (const u_char *)ip6, len);
+			sctp_print(ndo, cp, (const u_char *)ip6, len);
 			return;
 		case IPPROTO_DCCP:
 			dccp_print(ndo, cp, (const u_char *)ip6, len);
diff --git a/print-sctp.c b/print-sctp.c
index dc7916b3..a90359df 100644
--- a/print-sctp.c
+++ b/print-sctp.c
@@ -33,17 +33,13 @@
  * SUCH DAMAGE.
  */
 
+#define NETDISSECT_REWORKED
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 
-#include <assert.h>
-
-#include <stdio.h>
-#include <string.h>
-
 #include "interface.h"
 #include "addrtoname.h"
 #include "extract.h"			/* must come after interface.h */
@@ -411,9 +407,10 @@ static inline int isForCES_port(u_short Port)
 	return 0;
 }
 
-void sctp_print(const u_char *bp,        /* beginning of sctp packet */
-		const u_char *bp2,       /* beginning of enclosing */
-		u_int sctpPacketLength)  /* ip packet */
+void sctp_print(netdissect_options *ndo,
+                const u_char *bp,        /* beginning of sctp packet */
+                const u_char *bp2,       /* beginning of enclosing */
+                u_int sctpPacketLength)  /* ip packet */
 {
   const struct sctpHeader *sctpPktHdr;
   const struct ip *ip;
@@ -432,8 +429,8 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
   sctpPktHdr = (const struct sctpHeader*) bp;
   endPacketPtr = (const u_char*)sctpPktHdr+sctpPacketLength;
 
-  if( (u_long) endPacketPtr > (u_long) snapend)
-    endPacketPtr = (const void *) snapend;
+  if( (u_long) endPacketPtr > (u_long) ndo->ndo_snapend)
+    endPacketPtr = (const void *) ndo->ndo_snapend;
   ip = (struct ip *)bp2;
 #ifdef INET6
   if (IP_V(ip) == 6)
@@ -441,12 +438,12 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
   else
     ip6 = NULL;
 #endif /*INET6*/
-  TCHECK(*sctpPktHdr);
+  ND_TCHECK(*sctpPktHdr);
 
   if (sctpPacketLength < sizeof(struct sctpHeader))
     {
-      (void)printf("truncated-sctp - %ld bytes missing!",
-		   (long)sctpPacketLength-sizeof(struct sctpHeader));
+      ND_PRINT((ndo, "truncated-sctp - %ld bytes missing!",
+		   (long)sctpPacketLength-sizeof(struct sctpHeader)));
       return;
     }
 
@@ -458,32 +455,32 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 
 #ifdef INET6
   if (ip6) {
-    (void)printf("%s.%d > %s.%d: sctp",
+    ND_PRINT((ndo, "%s.%d > %s.%d: sctp",
       ip6addr_string(&ip6->ip6_src),
       sourcePort,
       ip6addr_string(&ip6->ip6_dst),
-      destPort);
+      destPort));
   } else
 #endif /*INET6*/
   {
-    (void)printf("%s.%d > %s.%d: sctp",
+    ND_PRINT((ndo, "%s.%d > %s.%d: sctp",
       ipaddr_string(&ip->ip_src),
       sourcePort,
       ipaddr_string(&ip->ip_dst),
-      destPort);
+      destPort));
   }
   fflush(stdout);
 
   if (isForCES_port(sourcePort)) {
-         printf("[%s]", tok2str(ForCES_channels, NULL, sourcePort));
+         ND_PRINT((ndo, "[%s]", tok2str(ForCES_channels, NULL, sourcePort)));
          isforces = 1;
   }
   if (isForCES_port(destPort)) {
-         printf("[%s]", tok2str(ForCES_channels, NULL, destPort));
+         ND_PRINT((ndo, "[%s]", tok2str(ForCES_channels, NULL, destPort)));
          isforces = 1;
   }
 
-  if (vflag >= 2)
+  if (ndo->ndo_vflag >= 2)
     sep = "\n\t";
   else
     sep = " (";
@@ -502,14 +499,14 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
       const u_char *chunkEnd;
       u_int16_t align;
 
-      TCHECK(*chunkDescPtr);
+      ND_TCHECK(*chunkDescPtr);
       chunkLength = EXTRACT_16BITS(&chunkDescPtr->chunkLength);
       if (chunkLength < sizeof(*chunkDescPtr)) {
-      	printf("%s%d) [Bad chunk length %u]", sep, chunkCount+1, chunkLength);
-      	break;
+        ND_PRINT((ndo, "%s%d) [Bad chunk length %u]", sep, chunkCount+1, chunkLength));
+        break;
       }
 
-      TCHECK2(*((u_int8_t *)chunkDescPtr), chunkLength);
+      ND_TCHECK2(*((u_int8_t *)chunkDescPtr), chunkLength);
       chunkEnd = ((const u_char*)chunkDescPtr + chunkLength);
 
       align=chunkLength % 4;
@@ -518,26 +515,26 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 
       nextChunk = (const void *) (chunkEnd + align);
 
-      printf("%s%d) ", sep, chunkCount+1);
+      ND_PRINT((ndo, "%s%d) ", sep, chunkCount+1));
       switch (chunkDescPtr->chunkID)
 	{
 	case SCTP_DATA :
 	  {
 	    const struct sctpDataPart *dataHdrPtr;
 
-	    printf("[DATA] ");
+	    ND_PRINT((ndo, "[DATA] "));
 
 	    if ((chunkDescPtr->chunkFlg & SCTP_DATA_UNORDERED)
 		== SCTP_DATA_UNORDERED)
-	      printf("(U)");
+	      ND_PRINT((ndo, "(U)"));
 
 	    if ((chunkDescPtr->chunkFlg & SCTP_DATA_FIRST_FRAG)
 		== SCTP_DATA_FIRST_FRAG)
-	      printf("(B)");
+	      ND_PRINT((ndo, "(B)"));
 
 	    if ((chunkDescPtr->chunkFlg & SCTP_DATA_LAST_FRAG)
 		== SCTP_DATA_LAST_FRAG)
-	      printf("(E)");
+	      ND_PRINT((ndo, "(E)"));
 
 	    if( ((chunkDescPtr->chunkFlg & SCTP_DATA_UNORDERED)
 		 == SCTP_DATA_UNORDERED)
@@ -547,14 +544,14 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 		||
 		((chunkDescPtr->chunkFlg & SCTP_DATA_LAST_FRAG)
 		 == SCTP_DATA_LAST_FRAG) )
-	      printf(" ");
+	      ND_PRINT((ndo, " "));
 
 	    dataHdrPtr=(const struct sctpDataPart*)(chunkDescPtr+1);
 
-	    printf("[TSN: %u] ", EXTRACT_32BITS(&dataHdrPtr->TSN));
-	    printf("[SID: %u] ", EXTRACT_16BITS(&dataHdrPtr->streamId));
-	    printf("[SSEQ %u] ", EXTRACT_16BITS(&dataHdrPtr->sequence));
-	    printf("[PPID 0x%x] ", EXTRACT_32BITS(&dataHdrPtr->payloadtype));
+	    ND_PRINT((ndo, "[TSN: %u] ", EXTRACT_32BITS(&dataHdrPtr->TSN)));
+	    ND_PRINT((ndo, "[SID: %u] ", EXTRACT_16BITS(&dataHdrPtr->streamId)));
+	    ND_PRINT((ndo, "[SSEQ %u] ", EXTRACT_16BITS(&dataHdrPtr->sequence)));
+	    ND_PRINT((ndo, "[PPID 0x%x] ", EXTRACT_32BITS(&dataHdrPtr->payloadtype)));
 	    fflush(stdout);
 	    if (isforces) {
 		const u_char *payloadPtr;
@@ -565,27 +562,27 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 			sizeof(struct sctpDataPart)+
 			sizeof(struct sctpChunkDesc)+1) {
 		/* Less than 1 byte of chunk payload */
-			printf("bogus ForCES chunk length %u]",
-			    EXTRACT_16BITS(&chunkDescPtr->chunkLength));
+			ND_PRINT((ndo, "bogus ForCES chunk length %u]",
+			    EXTRACT_16BITS(&chunkDescPtr->chunkLength)));
 			return;
 		}
 
 		forces_print(payloadPtr, EXTRACT_16BITS(&chunkDescPtr->chunkLength)- chunksize);
-	   } else if (vflag >= 2) {	/* if verbose output is specified */
+	   } else if (ndo->ndo_vflag >= 2) {	/* if verbose output is specified */
 					/* at the command line */
 		const u_char *payloadPtr;
 
-		printf("[Payload");
+		ND_PRINT((ndo, "[Payload"));
 
-		if (!suppress_default_print) {
+		if (!ndo->ndo_suppress_default_print) {
 			payloadPtr = (const u_char *) (++dataHdrPtr);
-			printf(":");
+			ND_PRINT((ndo, ":"));
 			if (EXTRACT_16BITS(&chunkDescPtr->chunkLength) <
 			    sizeof(struct sctpDataPart)+
 			    sizeof(struct sctpChunkDesc)+1) {
 				/* Less than 1 byte of chunk payload */
-				printf("bogus chunk length %u]",
-				    EXTRACT_16BITS(&chunkDescPtr->chunkLength));
+				ND_PRINT((ndo, "bogus chunk length %u]",
+				    EXTRACT_16BITS(&chunkDescPtr->chunkLength)));
 				return;
 			}
 			default_print(payloadPtr,
@@ -593,7 +590,7 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 			      (sizeof(struct sctpDataPart)+
 			      sizeof(struct sctpChunkDesc)));
 		} else
-			printf("]");
+			ND_PRINT((ndo, "]"));
 	      }
 	    break;
 	  }
@@ -601,18 +598,18 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 	  {
 	    const struct sctpInitiation *init;
 
-	    printf("[INIT] ");
+	    ND_PRINT((ndo, "[INIT] "));
 	    init=(const struct sctpInitiation*)(chunkDescPtr+1);
-	    printf("[init tag: %u] ", EXTRACT_32BITS(&init->initTag));
-	    printf("[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit));
-	    printf("[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams));
-	    printf("[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams));
-	    printf("[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN));
+	    ND_PRINT((ndo, "[init tag: %u] ", EXTRACT_32BITS(&init->initTag)));
+	    ND_PRINT((ndo, "[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit)));
+	    ND_PRINT((ndo, "[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams)));
+	    ND_PRINT((ndo, "[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams)));
+	    ND_PRINT((ndo, "[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN)));
 
 #if(0) /* ALC you can add code for optional params here */
 	    if( (init+1) < chunkEnd )
-	      printf(" @@@@@ UNFINISHED @@@@@@%s\n",
-		     "Optional params present, but not printed.");
+	      ND_PRINT((ndo, " @@@@@ UNFINISHED @@@@@@%s\n",
+		     "Optional params present, but not printed."));
 #endif
 	    break;
 	  }
@@ -620,18 +617,18 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 	  {
 	    const struct sctpInitiation *init;
 
-	    printf("[INIT ACK] ");
+	    ND_PRINT((ndo, "[INIT ACK] "));
 	    init=(const struct sctpInitiation*)(chunkDescPtr+1);
-	    printf("[init tag: %u] ", EXTRACT_32BITS(&init->initTag));
-	    printf("[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit));
-	    printf("[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams));
-	    printf("[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams));
-	    printf("[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN));
+	    ND_PRINT((ndo, "[init tag: %u] ", EXTRACT_32BITS(&init->initTag)));
+	    ND_PRINT((ndo, "[rwnd: %u] ", EXTRACT_32BITS(&init->rcvWindowCredit)));
+	    ND_PRINT((ndo, "[OS: %u] ", EXTRACT_16BITS(&init->NumPreopenStreams)));
+	    ND_PRINT((ndo, "[MIS: %u] ", EXTRACT_16BITS(&init->MaxInboundStreams)));
+	    ND_PRINT((ndo, "[init TSN: %u] ", EXTRACT_32BITS(&init->initialTSN)));
 
 #if(0) /* ALC you can add code for optional params here */
 	    if( (init+1) < chunkEnd )
-	      printf(" @@@@@ UNFINISHED @@@@@@%s\n",
-		     "Optional params present, but not printed.");
+	      ND_PRINT((ndo, " @@@@@ UNFINISHED @@@@@@%s\n",
+		     "Optional params present, but not printed."));
 #endif
 	    break;
 	  }
@@ -642,12 +639,12 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 	    int fragNo, tsnNo;
 	    const u_char *dupTSN;
 
-	    printf("[SACK] ");
+	    ND_PRINT((ndo, "[SACK] "));
 	    sack=(const struct sctpSelectiveAck*)(chunkDescPtr+1);
-	    printf("[cum ack %u] ", EXTRACT_32BITS(&sack->highestConseqTSN));
-	    printf("[a_rwnd %u] ", EXTRACT_32BITS(&sack->updatedRwnd));
-	    printf("[#gap acks %u] ", EXTRACT_16BITS(&sack->numberOfdesc));
-	    printf("[#dup tsns %u] ", EXTRACT_16BITS(&sack->numDupTsns));
+	    ND_PRINT((ndo, "[cum ack %u] ", EXTRACT_32BITS(&sack->highestConseqTSN)));
+	    ND_PRINT((ndo, "[a_rwnd %u] ", EXTRACT_32BITS(&sack->updatedRwnd)));
+	    ND_PRINT((ndo, "[#gap acks %u] ", EXTRACT_16BITS(&sack->numberOfdesc)));
+	    ND_PRINT((ndo, "[#dup tsns %u] ", EXTRACT_16BITS(&sack->numDupTsns)));
 
 
 	    /* print gaps */
@@ -656,74 +653,73 @@ void sctp_print(const u_char *bp,        /* beginning of sctp packet */
 		   fragNo=0;
 		 (const void *)frag < nextChunk && fragNo < EXTRACT_16BITS(&sack->numberOfdesc);
 		 frag++, fragNo++)
-	      printf("\n\t\t[gap ack block #%d: start = %u, end = %u] ",
+	      ND_PRINT((ndo, "\n\t\t[gap ack block #%d: start = %u, end = %u] ",
 		     fragNo+1,
 		     EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentStart),
-		     EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentEnd));
+		     EXTRACT_32BITS(&sack->highestConseqTSN) + EXTRACT_16BITS(&frag->fragmentEnd)));
 
 
 	    /* print duplicate TSNs */
 	    for (dupTSN = (const u_char *)frag, tsnNo=0;
 		 (const void *) dupTSN < nextChunk && tsnNo<EXTRACT_16BITS(&sack->numDupTsns);
 		 dupTSN += 4, tsnNo++)
-	      printf("\n\t\t[dup TSN #%u: %u] ", tsnNo+1,
-	          EXTRACT_32BITS(dupTSN));
+	      ND_PRINT((ndo, "\n\t\t[dup TSN #%u: %u] ", tsnNo+1,
+	          EXTRACT_32BITS(dupTSN)));
 
 	    break;
 	  }
 	case SCTP_HEARTBEAT_REQUEST :
-	  printf("[HB REQ] ");
+	  ND_PRINT((ndo, "[HB REQ] "));
 	  break;
 	case SCTP_HEARTBEAT_ACK :
-	  printf("[HB ACK] ");
+	  ND_PRINT((ndo, "[HB ACK] "));
 	  break;
 	case SCTP_ABORT_ASSOCIATION :
-	  printf("[ABORT] ");
+	  ND_PRINT((ndo, "[ABORT] "));
 	  break;
 	case SCTP_SHUTDOWN :
-	  printf("[SHUTDOWN] ");
+	  ND_PRINT((ndo, "[SHUTDOWN] "));
 	  break;
 	case SCTP_SHUTDOWN_ACK :
-	  printf("[SHUTDOWN ACK] ");
+	  ND_PRINT((ndo, "[SHUTDOWN ACK] "));
 	  break;
 	case SCTP_OPERATION_ERR :
-	  printf("[OP ERR] ");
+	  ND_PRINT((ndo, "[OP ERR] "));
 	  break;
 	case SCTP_COOKIE_ECHO :
-	  printf("[COOKIE ECHO] ");
+	  ND_PRINT((ndo, "[COOKIE ECHO] "));
 	  break;
 	case SCTP_COOKIE_ACK :
-	  printf("[COOKIE ACK] ");
+	  ND_PRINT((ndo, "[COOKIE ACK] "));
 	  break;
 	case SCTP_ECN_ECHO :
-	  printf("[ECN ECHO] ");
+	  ND_PRINT((ndo, "[ECN ECHO] "));
 	  break;
 	case SCTP_ECN_CWR :
-	  printf("[ECN CWR] ");
+	  ND_PRINT((ndo, "[ECN CWR] "));
 	  break;
 	case SCTP_SHUTDOWN_COMPLETE :
-	  printf("[SHUTDOWN COMPLETE] ");
+	  ND_PRINT((ndo, "[SHUTDOWN COMPLETE] "));
 	  break;
 	case SCTP_FORWARD_CUM_TSN :
-	  printf("[FOR CUM TSN] ");
+	  ND_PRINT((ndo, "[FOR CUM TSN] "));
 	  break;
 	case SCTP_RELIABLE_CNTL :
-	  printf("[REL CTRL] ");
+	  ND_PRINT((ndo, "[REL CTRL] "));
 	  break;
 	case SCTP_RELIABLE_CNTL_ACK :
-	  printf("[REL CTRL ACK] ");
+	  ND_PRINT((ndo, "[REL CTRL ACK] "));
 	  break;
 	default :
-	  printf("[Unknown chunk type: 0x%x]", chunkDescPtr->chunkID);
+	  ND_PRINT((ndo, "[Unknown chunk type: 0x%x]", chunkDescPtr->chunkID));
 	  return;
 	}
 
-	if (vflag < 2)
+	if (ndo->ndo_vflag < 2)
 	  sep = ", (";
     }
     return;
 
 trunc:
-    printf("[|sctp]");
-    return;
+    ND_PRINT((ndo, "[|sctp]"));
 }
diff --git a/print-tcp.c b/print-tcp.c
index 3adfb323..d475f6da 100644
--- a/print-tcp.c
+++ b/print-tcp.c
@@ -142,7 +142,7 @@ static int tcp_cksum(register const struct ip *ip,
 		     register const struct tcphdr *tp,
 		     register u_int len)
 {
-	return nextproto4_cksum(ip, (const u_int8_t *)tp, len, len,
+	return nextproto4_cksum(gndo, ip, (const u_int8_t *)tp, len, len,
 				IPPROTO_TCP);
 }
 
diff --git a/print-udp.c b/print-udp.c
index da88a0ed..90a53c41 100644
--- a/print-udp.c
+++ b/print-udp.c
@@ -272,11 +272,11 @@ rtcp_print(netdissect_options *ndo, const u_char *hdr, const u_char *ep)
 	return (hdr + len);
 }
 
-static int udp_cksum(register const struct ip *ip,
+static int udp_cksum(netdissect_options *ndo, register const struct ip *ip,
 		     register const struct udphdr *up,
 		     register u_int len)
 {
-	return nextproto4_cksum(ip, (const u_int8_t *)(void *)up, len, len,
+	return nextproto4_cksum(ndo, ip, (const u_int8_t *)(void *)up, len, len,
 				IPPROTO_UDP);
 }
 
@@ -452,7 +452,7 @@ udp_print(netdissect_options *ndo, register const u_char *bp, u_int length,
 
 		case PT_AODV:
 			udpipaddr_print(ndo, ip, sport, dport);
-			aodv_print((const u_char *)(up + 1), length,
+			aodv_print(ndo, (const u_char *)(up + 1), length,
 #ifdef INET6
 			    ip6 != NULL);
 #else
@@ -533,7 +533,7 @@ udp_print(netdissect_options *ndo, register const u_char *bp, u_int length,
 			if (udp_sum == 0) {
 				ND_PRINT((ndo, "[no cksum] "));
 			} else if (ND_TTEST2(cp[0], length)) {
-				sum = udp_cksum(ip, up, length + sizeof(struct udphdr));
+				sum = udp_cksum(ndo, ip, up, length + sizeof(struct udphdr));
 
 	                        if (sum != 0) {
 					ND_PRINT((ndo, "[bad udp cksum 0x%04x -> 0x%04x!] ",
@@ -576,7 +576,7 @@ udp_print(netdissect_options *ndo, register const u_char *bp, u_int length,
 		else if (ISPORT(RIP_PORT))
 			rip_print(ndo, (const u_char *)(up + 1), length);
 		else if (ISPORT(AODV_PORT))
-			aodv_print((const u_char *)(up + 1), length,
+			aodv_print(ndo, (const u_char *)(up + 1), length,
 #ifdef INET6
 			    ip6 != NULL);
 #else
diff --git a/print-vrrp.c b/print-vrrp.c
index 27105bf5..0be12628 100644
--- a/print-vrrp.c
+++ b/print-vrrp.c
@@ -147,7 +147,7 @@ vrrp_print(netdissect_options *ndo,
 		}
 
 		if (version == 3 && ND_TTEST2(bp[0], len)) {
-			u_int16_t cksum = nextproto4_cksum((struct ip *)bp2, bp,
+			u_int16_t cksum = nextproto4_cksum(ndo, (struct ip *)bp2, bp,
 				len, len, IPPROTO_VRRP);
 			if (cksum)
 				ND_PRINT((ndo, ", (bad vrrp cksum %x)",