Imported Upstream version 4.9.2upstream/4.9.2

Change-Id: I490892f19c71ba126fa4e1d3d78e730429a3b454

1 files changed, 366 insertions, 324 deletions

diff --git a/print-udp.c b/print-udp.c
index 885d42e..5a74ff2 100644
--- a/print-udp.c
+++ b/print-udp.c
@@ -19,25 +19,15 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
-#ifndef lint
-static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-udp.c,v 1.142 2007-08-08 17:20:58 hannes Exp $ (LBL)";
-#endif
+/* \summary: UDP printer */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <tcpdump-stdinc.h>
-
-#ifdef SEGSIZE
-#undef SEGSIZE
-#endif
-
-#include <stdio.h>
-#include <string.h>
+#include <netdissect-stdinc.h>
 
-#include "interface.h"
+#include "netdissect.h"
 #include "addrtoname.h"
 #include "extract.h"
 #include "appletalk.h"
@@ -45,26 +35,27 @@ static const char rcsid[] _U_ =
 #include "udp.h"
 
 #include "ip.h"
-#ifdef INET6
 #include "ip6.h"
-#endif
 #include "ipproto.h"
 #include "rpc_auth.h"
 #include "rpc_msg.h"
 
-#include "nameser.h"
 #include "nfs.h"
-#include "bootp.h"
+
+static const char vat_tstr[] = " [|vat]";
+static const char rtp_tstr[] = " [|rtp]";
+static const char rtcp_tstr[] = " [|rtcp]";
+static const char udp_tstr[] = " [|udp]";
 
 struct rtcphdr {
-	u_int16_t rh_flags;	/* T:2 P:1 CNT:5 PT:8 */
-	u_int16_t rh_len;	/* length of message (in words) */
-	u_int32_t rh_ssrc;	/* synchronization src id */
+	uint16_t rh_flags;	/* T:2 P:1 CNT:5 PT:8 */
+	uint16_t rh_len;	/* length of message (in words) */
+	uint32_t rh_ssrc;	/* synchronization src id */
 };
 
 typedef struct {
-	u_int32_t upper;	/* more significant 32 bits */
-	u_int32_t lower;	/* less significant 32 bits */
+	uint32_t upper;	/* more significant 32 bits */
+	uint32_t lower;	/* less significant 32 bits */
 } ntp64;
 
 /*
@@ -72,9 +63,9 @@ typedef struct {
  */
 struct rtcp_sr {
 	ntp64 sr_ntp;		/* 64-bit ntp timestamp */
-	u_int32_t sr_ts;	/* reference media timestamp */
-	u_int32_t sr_np;	/* no. packets sent */
-	u_int32_t sr_nb;	/* no. bytes sent */
+	uint32_t sr_ts;	/* reference media timestamp */
+	uint32_t sr_np;	/* no. packets sent */
+	uint32_t sr_nb;	/* no. bytes sent */
 };
 
 /*
@@ -82,12 +73,12 @@ struct rtcp_sr {
  * Time stamps are middle 32-bits of ntp timestamp.
  */
 struct rtcp_rr {
-	u_int32_t rr_srcid;	/* sender being reported */
-	u_int32_t rr_nl;	/* no. packets lost */
-	u_int32_t rr_ls;	/* extended last seq number received */
-	u_int32_t rr_dv;	/* jitter (delay variance) */
-	u_int32_t rr_lsr;	/* orig. ts from last rr from this src  */
-	u_int32_t rr_dlsr;	/* time from recpt of last rr to xmit time */
+	uint32_t rr_srcid;	/* sender being reported */
+	uint32_t rr_nl;	/* no. packets lost */
+	uint32_t rr_ls;	/* extended last seq number received */
+	uint32_t rr_dv;	/* jitter (delay variance) */
+	uint32_t rr_lsr;	/* orig. ts from last rr from this src  */
+	uint32_t rr_dlsr;	/* time from recpt of last rr to xmit time */
 };
 
 /*XXX*/
@@ -106,55 +97,72 @@ struct rtcp_rr {
 #define RTCP_PT_APP	204
 
 static void
-vat_print(const void *hdr, register const struct udphdr *up)
+vat_print(netdissect_options *ndo, const void *hdr, register const struct udphdr *up)
 {
 	/* vat/vt audio */
-	u_int ts = *(u_int16_t *)hdr;
+	u_int ts;
+
+	ND_TCHECK_16BITS((const u_int *)hdr);
+	ts = EXTRACT_16BITS(hdr);
 	if ((ts & 0xf060) != 0) {
 		/* probably vt */
-		(void)printf("udp/vt %u %d / %d",
-			     (u_int32_t)(EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up)),
-			     ts & 0x3ff, ts >> 10);
+		ND_TCHECK_16BITS(&up->uh_ulen);
+		ND_PRINT((ndo, "udp/vt %u %d / %d",
+			     (uint32_t)(EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up)),
+			     ts & 0x3ff, ts >> 10));
 	} else {
 		/* probably vat */
-		u_int32_t i0 = EXTRACT_32BITS(&((u_int *)hdr)[0]);
-		u_int32_t i1 = EXTRACT_32BITS(&((u_int *)hdr)[1]);
-		printf("udp/vat %u c%d %u%s",
-			(u_int32_t)(EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up) - 8),
+		uint32_t i0, i1;
+
+		ND_TCHECK_32BITS(&((const u_int *)hdr)[0]);
+		i0 = EXTRACT_32BITS(&((const u_int *)hdr)[0]);
+		ND_TCHECK_32BITS(&((const u_int *)hdr)[1]);
+		i1 = EXTRACT_32BITS(&((const u_int *)hdr)[1]);
+		ND_TCHECK_16BITS(&up->uh_ulen);
+		ND_PRINT((ndo, "udp/vat %u c%d %u%s",
+			(uint32_t)(EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up) - 8),
 			i0 & 0xffff,
-			i1, i0 & 0x800000? "*" : "");
+			i1, i0 & 0x800000? "*" : ""));
 		/* audio format */
 		if (i0 & 0x1f0000)
-			printf(" f%d", (i0 >> 16) & 0x1f);
+			ND_PRINT((ndo, " f%d", (i0 >> 16) & 0x1f));
 		if (i0 & 0x3f000000)
-			printf(" s%d", (i0 >> 24) & 0x3f);
+			ND_PRINT((ndo, " s%d", (i0 >> 24) & 0x3f));
 	}
+
+trunc:
+	ND_PRINT((ndo, "%s", vat_tstr));
 }
 
 static void
-rtp_print(const void *hdr, u_int len, register const struct udphdr *up)
+rtp_print(netdissect_options *ndo, const void *hdr, u_int len,
+          register const struct udphdr *up)
 {
 	/* rtp v1 or v2 */
-	u_int *ip = (u_int *)hdr;
-	u_int hasopt, hasext, contype, hasmarker;
-	u_int32_t i0 = EXTRACT_32BITS(&((u_int *)hdr)[0]);
-	u_int32_t i1 = EXTRACT_32BITS(&((u_int *)hdr)[1]);
-	u_int dlen = EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up) - 8;
+	const u_int *ip = (const u_int *)hdr;
+	u_int hasopt, hasext, contype, hasmarker, dlen;
+	uint32_t i0, i1;
 	const char * ptype;
 
+	ND_TCHECK_32BITS(&((const u_int *)hdr)[0]);
+	i0 = EXTRACT_32BITS(&((const u_int *)hdr)[0]);
+	ND_TCHECK_32BITS(&((const u_int *)hdr)[1]);
+	i1 = EXTRACT_32BITS(&((const u_int *)hdr)[1]);
+	ND_TCHECK_16BITS(&up->uh_ulen);
+	dlen = EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up) - 8;
 	ip += 2;
 	len >>= 2;
 	len -= 2;
 	hasopt = 0;
 	hasext = 0;
 	if ((i0 >> 30) == 1) {
-		/* rtp v1 */
+		/* rtp v1 - draft-ietf-avt-rtp-04 */
 		hasopt = i0 & 0x800000;
 		contype = (i0 >> 16) & 0x3f;
 		hasmarker = i0 & 0x400000;
 		ptype = "rtpv1";
 	} else {
-		/* rtp v2 */
+		/* rtp v2 - RFC 3550 */
 		hasext = i0 & 0x10000000;
 		contype = (i0 >> 16) & 0x7f;
 		hasmarker = i0 & 0x800000;
@@ -163,23 +171,25 @@ rtp_print(const void *hdr, u_int len, register const struct udphdr *up)
 		ip += 1;
 		len -= 1;
 	}
-	printf("udp/%s %d c%d %s%s %d %u",
+	ND_PRINT((ndo, "udp/%s %d c%d %s%s %d %u",
 		ptype,
 		dlen,
 		contype,
 		(hasopt || hasext)? "+" : "",
 		hasmarker? "*" : "",
 		i0 & 0xffff,
-		i1);
-	if (vflag) {
-		printf(" %u", EXTRACT_32BITS(&((u_int *)hdr)[2]));
+		i1));
+	if (ndo->ndo_vflag) {
+		ND_TCHECK_32BITS(&((const u_int *)hdr)[2]);
+		ND_PRINT((ndo, " %u", EXTRACT_32BITS(&((const u_int *)hdr)[2])));
 		if (hasopt) {
 			u_int i2, optlen;
 			do {
-				i2 = ip[0];
+				ND_TCHECK_32BITS(ip);
+				i2 = EXTRACT_32BITS(ip);
 				optlen = (i2 >> 16) & 0xff;
 				if (optlen == 0 || optlen > len) {
-					printf(" !opt");
+					ND_PRINT((ndo, " !opt"));
 					return;
 				}
 				ip += optlen;
@@ -188,121 +198,124 @@ rtp_print(const void *hdr, u_int len, register const struct udphdr *up)
 		}
 		if (hasext) {
 			u_int i2, extlen;
-			i2 = ip[0];
+			ND_TCHECK_32BITS(ip);
+			i2 = EXTRACT_32BITS(ip);
 			extlen = (i2 & 0xffff) + 1;
 			if (extlen > len) {
-				printf(" !ext");
+				ND_PRINT((ndo, " !ext"));
 				return;
 			}
 			ip += extlen;
 		}
+		ND_TCHECK_32BITS(ip);
 		if (contype == 0x1f) /*XXX H.261 */
-			printf(" 0x%04x", ip[0] >> 16);
+			ND_PRINT((ndo, " 0x%04x", EXTRACT_32BITS(ip) >> 16));
 	}
+
+trunc:
+	ND_PRINT((ndo, "%s", rtp_tstr));
 }
 
 static const u_char *
-rtcp_print(const u_char *hdr, const u_char *ep)
+rtcp_print(netdissect_options *ndo, const u_char *hdr, const u_char *ep)
 {
 	/* rtp v2 control (rtcp) */
-	struct rtcp_rr *rr = 0;
-	struct rtcp_sr *sr;
-	struct rtcphdr *rh = (struct rtcphdr *)hdr;
+	const struct rtcp_rr *rr = 0;
+	const struct rtcp_sr *sr;
+	const struct rtcphdr *rh = (const struct rtcphdr *)hdr;
 	u_int len;
-	u_int16_t flags;
+	uint16_t flags;
 	int cnt;
 	double ts, dts;
-	if ((u_char *)(rh + 1) > ep) {
-		printf(" [|rtcp]");
-		return (ep);
-	}
+	if ((const u_char *)(rh + 1) > ep)
+		goto trunc;
+	ND_TCHECK(*rh);
 	len = (EXTRACT_16BITS(&rh->rh_len) + 1) * 4;
 	flags = EXTRACT_16BITS(&rh->rh_flags);
 	cnt = (flags >> 8) & 0x1f;
 	switch (flags & 0xff) {
 	case RTCP_PT_SR:
-		sr = (struct rtcp_sr *)(rh + 1);
-		printf(" sr");
+		sr = (const struct rtcp_sr *)(rh + 1);
+		ND_PRINT((ndo, " sr"));
 		if (len != cnt * sizeof(*rr) + sizeof(*sr) + sizeof(*rh))
-			printf(" [%d]", len);
-		if (vflag)
-			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
-		if ((u_char *)(sr + 1) > ep) {
-			printf(" [|rtcp]");
-			return (ep);
-		}
+			ND_PRINT((ndo, " [%d]", len));
+		if (ndo->ndo_vflag)
+			ND_PRINT((ndo, " %u", EXTRACT_32BITS(&rh->rh_ssrc)));
+		if ((const u_char *)(sr + 1) > ep)
+			goto trunc;
+		ND_TCHECK(*sr);
 		ts = (double)(EXTRACT_32BITS(&sr->sr_ntp.upper)) +
 		    ((double)(EXTRACT_32BITS(&sr->sr_ntp.lower)) /
 		    4294967296.0);
-		printf(" @%.2f %u %up %ub", ts, EXTRACT_32BITS(&sr->sr_ts),
-		    EXTRACT_32BITS(&sr->sr_np), EXTRACT_32BITS(&sr->sr_nb));
-		rr = (struct rtcp_rr *)(sr + 1);
+		ND_PRINT((ndo, " @%.2f %u %up %ub", ts, EXTRACT_32BITS(&sr->sr_ts),
+		    EXTRACT_32BITS(&sr->sr_np), EXTRACT_32BITS(&sr->sr_nb)));
+		rr = (const struct rtcp_rr *)(sr + 1);
 		break;
 	case RTCP_PT_RR:
-		printf(" rr");
+		ND_PRINT((ndo, " rr"));
 		if (len != cnt * sizeof(*rr) + sizeof(*rh))
-			printf(" [%d]", len);
-		rr = (struct rtcp_rr *)(rh + 1);
-		if (vflag)
-			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
+			ND_PRINT((ndo, " [%d]", len));
+		rr = (const struct rtcp_rr *)(rh + 1);
+		if (ndo->ndo_vflag)
+			ND_PRINT((ndo, " %u", EXTRACT_32BITS(&rh->rh_ssrc)));
 		break;
 	case RTCP_PT_SDES:
-		printf(" sdes %d", len);
-		if (vflag)
-			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
+		ND_PRINT((ndo, " sdes %d", len));
+		if (ndo->ndo_vflag)
+			ND_PRINT((ndo, " %u", EXTRACT_32BITS(&rh->rh_ssrc)));
 		cnt = 0;
 		break;
 	case RTCP_PT_BYE:
-		printf(" bye %d", len);
-		if (vflag)
-			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
+		ND_PRINT((ndo, " bye %d", len));
+		if (ndo->ndo_vflag)
+			ND_PRINT((ndo, " %u", EXTRACT_32BITS(&rh->rh_ssrc)));
 		cnt = 0;
 		break;
 	default:
-		printf(" type-0x%x %d", flags & 0xff, len);
+		ND_PRINT((ndo, " type-0x%x %d", flags & 0xff, len));
 		cnt = 0;
 		break;
 	}
 	if (cnt > 1)
-		printf(" c%d", cnt);
+		ND_PRINT((ndo, " c%d", cnt));
 	while (--cnt >= 0) {
-		if ((u_char *)(rr + 1) > ep) {
-			printf(" [|rtcp]");
-			return (ep);
-		}
-		if (vflag)
-			printf(" %u", EXTRACT_32BITS(&rr->rr_srcid));
+		if ((const u_char *)(rr + 1) > ep)
+			goto trunc;
+		ND_TCHECK(*rr);
+		if (ndo->ndo_vflag)
+			ND_PRINT((ndo, " %u", EXTRACT_32BITS(&rr->rr_srcid)));
 		ts = (double)(EXTRACT_32BITS(&rr->rr_lsr)) / 65536.;
 		dts = (double)(EXTRACT_32BITS(&rr->rr_dlsr)) / 65536.;
-		printf(" %ul %us %uj @%.2f+%.2f",
+		ND_PRINT((ndo, " %ul %us %uj @%.2f+%.2f",
 		    EXTRACT_32BITS(&rr->rr_nl) & 0x00ffffff,
 		    EXTRACT_32BITS(&rr->rr_ls),
-		    EXTRACT_32BITS(&rr->rr_dv), ts, dts);
+		    EXTRACT_32BITS(&rr->rr_dv), ts, dts));
 	}
 	return (hdr + len);
+
+trunc:
+	ND_PRINT((ndo, "%s", rtcp_tstr));
+	return ep;
 }
 
-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,
-	    IPPROTO_UDP));
+	return nextproto4_cksum(ndo, ip, (const uint8_t *)(const void *)up, len, len,
+				IPPROTO_UDP);
 }
 
-#ifdef INET6
-static int udp6_cksum(const struct ip6_hdr *ip6, const struct udphdr *up,
-	u_int len)
+static int udp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6,
+		      const struct udphdr *up, u_int len)
 {
-	return (nextproto6_cksum(ip6, (const u_int8_t *)(void *)up, len,
-	    IPPROTO_UDP));
+	return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)up, len, len,
+				IPPROTO_UDP);
 }
-#endif
 
 static void
-udpipaddr_print(const struct ip *ip, int sport, int dport)
+udpipaddr_print(netdissect_options *ndo, const struct ip *ip, int sport, int dport)
 {
-#ifdef INET6
 	const struct ip6_hdr *ip6;
 
 	if (IP_V(ip) == 6)
@@ -313,357 +326,387 @@ udpipaddr_print(const struct ip *ip, int sport, int dport)
 	if (ip6) {
 		if (ip6->ip6_nxt == IPPROTO_UDP) {
 			if (sport == -1) {
-				(void)printf("%s > %s: ",
-					ip6addr_string(&ip6->ip6_src),
-					ip6addr_string(&ip6->ip6_dst));
+				ND_PRINT((ndo, "%s > %s: ",
+					ip6addr_string(ndo, &ip6->ip6_src),
+					ip6addr_string(ndo, &ip6->ip6_dst)));
 			} else {
-				(void)printf("%s.%s > %s.%s: ",
-					ip6addr_string(&ip6->ip6_src),
-					udpport_string(sport),
-					ip6addr_string(&ip6->ip6_dst),
-					udpport_string(dport));
+				ND_PRINT((ndo, "%s.%s > %s.%s: ",
+					ip6addr_string(ndo, &ip6->ip6_src),
+					udpport_string(ndo, sport),
+					ip6addr_string(ndo, &ip6->ip6_dst),
+					udpport_string(ndo, dport)));
 			}
 		} else {
 			if (sport != -1) {
-				(void)printf("%s > %s: ",
-					udpport_string(sport),
-					udpport_string(dport));
+				ND_PRINT((ndo, "%s > %s: ",
+					udpport_string(ndo, sport),
+					udpport_string(ndo, dport)));
 			}
 		}
-	} else
-#endif /*INET6*/
-	{
+	} else {
 		if (ip->ip_p == IPPROTO_UDP) {
 			if (sport == -1) {
-				(void)printf("%s > %s: ",
-					ipaddr_string(&ip->ip_src),
-					ipaddr_string(&ip->ip_dst));
+				ND_PRINT((ndo, "%s > %s: ",
+					ipaddr_string(ndo, &ip->ip_src),
+					ipaddr_string(ndo, &ip->ip_dst)));
 			} else {
-				(void)printf("%s.%s > %s.%s: ",
-					ipaddr_string(&ip->ip_src),
-					udpport_string(sport),
-					ipaddr_string(&ip->ip_dst),
-					udpport_string(dport));
+				ND_PRINT((ndo, "%s.%s > %s.%s: ",
+					ipaddr_string(ndo, &ip->ip_src),
+					udpport_string(ndo, sport),
+					ipaddr_string(ndo, &ip->ip_dst),
+					udpport_string(ndo, dport)));
 			}
 		} else {
 			if (sport != -1) {
-				(void)printf("%s > %s: ",
-					udpport_string(sport),
-					udpport_string(dport));
+				ND_PRINT((ndo, "%s > %s: ",
+					udpport_string(ndo, sport),
+					udpport_string(ndo, dport)));
 			}
 		}
 	}
 }
 
 void
-udp_print(register const u_char *bp, u_int length,
+udp_print(netdissect_options *ndo, register const u_char *bp, u_int length,
 	  register const u_char *bp2, int fragmented)
 {
 	register const struct udphdr *up;
 	register const struct ip *ip;
 	register const u_char *cp;
 	register const u_char *ep = bp + length;
-	u_int16_t sport, dport, ulen;
-#ifdef INET6
+	uint16_t sport, dport, ulen;
 	register const struct ip6_hdr *ip6;
-#endif
 
-	if (ep > snapend)
-		ep = snapend;
-	up = (struct udphdr *)bp;
-	ip = (struct ip *)bp2;
-#ifdef INET6
+	if (ep > ndo->ndo_snapend)
+		ep = ndo->ndo_snapend;
+	up = (const struct udphdr *)bp;
+	ip = (const struct ip *)bp2;
 	if (IP_V(ip) == 6)
-		ip6 = (struct ip6_hdr *)bp2;
+		ip6 = (const struct ip6_hdr *)bp2;
 	else
 		ip6 = NULL;
-#endif /*INET6*/
-	cp = (u_char *)(up + 1);
-	if (!TTEST(up->uh_dport)) {
-		udpipaddr_print(ip, -1, -1);
-		(void)printf("[|udp]");
-		return;
+	if (!ND_TTEST(up->uh_dport)) {
+		udpipaddr_print(ndo, ip, -1, -1);
+		goto trunc;
 	}
 
 	sport = EXTRACT_16BITS(&up->uh_sport);
 	dport = EXTRACT_16BITS(&up->uh_dport);
 
 	if (length < sizeof(struct udphdr)) {
-		udpipaddr_print(ip, sport, dport);
-		(void)printf("truncated-udp %d", length);
+		udpipaddr_print(ndo, ip, sport, dport);
+		ND_PRINT((ndo, "truncated-udp %d", length));
 		return;
 	}
-	length -= sizeof(struct udphdr);
-
-	if (cp > snapend) {
-		udpipaddr_print(ip, sport, dport);
-		(void)printf("[|udp]");
-		return;
+	if (!ND_TTEST(up->uh_ulen)) {
+		udpipaddr_print(ndo, ip, sport, dport);
+		goto trunc;
 	}
-
 	ulen = EXTRACT_16BITS(&up->uh_ulen);
-	if (ulen < 8) {
-		udpipaddr_print(ip, sport, dport);
-		(void)printf("truncated-udplength %d", ulen);
+	if (ulen < sizeof(struct udphdr)) {
+		udpipaddr_print(ndo, ip, sport, dport);
+		ND_PRINT((ndo, "truncated-udplength %d", ulen));
 		return;
 	}
-	if (packettype) {
-		register struct sunrpc_msg *rp;
+	ulen -= sizeof(struct udphdr);
+	length -= sizeof(struct udphdr);
+	if (ulen < length)
+		length = ulen;
+
+	cp = (const u_char *)(up + 1);
+	if (cp > ndo->ndo_snapend) {
+		udpipaddr_print(ndo, ip, sport, dport);
+		goto trunc;
+	}
+
+	if (ndo->ndo_packettype) {
+		register const struct sunrpc_msg *rp;
 		enum sunrpc_msg_type direction;
 
-		switch (packettype) {
+		switch (ndo->ndo_packettype) {
 
 		case PT_VAT:
-			udpipaddr_print(ip, sport, dport);
-			vat_print((void *)(up + 1), up);
+			udpipaddr_print(ndo, ip, sport, dport);
+			vat_print(ndo, (const void *)(up + 1), up);
 			break;
 
 		case PT_WB:
-			udpipaddr_print(ip, sport, dport);
-			wb_print((void *)(up + 1), length);
+			udpipaddr_print(ndo, ip, sport, dport);
+			wb_print(ndo, (const void *)(up + 1), length);
 			break;
 
 		case PT_RPC:
-			rp = (struct sunrpc_msg *)(up + 1);
+			rp = (const struct sunrpc_msg *)(up + 1);
 			direction = (enum sunrpc_msg_type)EXTRACT_32BITS(&rp->rm_direction);
 			if (direction == SUNRPC_CALL)
-				sunrpcrequest_print((u_char *)rp, length,
-				    (u_char *)ip);
+				sunrpcrequest_print(ndo, (const u_char *)rp, length,
+				    (const u_char *)ip);
 			else
-				nfsreply_print((u_char *)rp, length,
-				    (u_char *)ip);			/*XXX*/
+				nfsreply_print(ndo, (const u_char *)rp, length,
+				    (const u_char *)ip);			/*XXX*/
 			break;
 
 		case PT_RTP:
-			udpipaddr_print(ip, sport, dport);
-			rtp_print((void *)(up + 1), length, up);
+			udpipaddr_print(ndo, ip, sport, dport);
+			rtp_print(ndo, (const void *)(up + 1), length, up);
 			break;
 
 		case PT_RTCP:
-			udpipaddr_print(ip, sport, dport);
+			udpipaddr_print(ndo, ip, sport, dport);
 			while (cp < ep)
-				cp = rtcp_print(cp, ep);
+				cp = rtcp_print(ndo, cp, ep);
 			break;
 
 		case PT_SNMP:
-			udpipaddr_print(ip, sport, dport);
-			snmp_print((const u_char *)(up + 1), length);
+			udpipaddr_print(ndo, ip, sport, dport);
+			snmp_print(ndo, (const u_char *)(up + 1), length);
 			break;
 
 		case PT_CNFP:
-			udpipaddr_print(ip, sport, dport);
-			cnfp_print(cp, (const u_char *)ip);
+			udpipaddr_print(ndo, ip, sport, dport);
+			cnfp_print(ndo, cp);
 			break;
 
 		case PT_TFTP:
-			udpipaddr_print(ip, sport, dport);
-			tftp_print(cp, length);
+			udpipaddr_print(ndo, ip, sport, dport);
+			tftp_print(ndo, cp, length);
 			break;
 
 		case PT_AODV:
-			udpipaddr_print(ip, sport, dport);
-			aodv_print((const u_char *)(up + 1), length,
-#ifdef INET6
+			udpipaddr_print(ndo, ip, sport, dport);
+			aodv_print(ndo, (const u_char *)(up + 1), length,
 			    ip6 != NULL);
-#else
-			    0);
-#endif
+			break;
+
+		case PT_RADIUS:
+			udpipaddr_print(ndo, ip, sport, dport);
+			radius_print(ndo, cp, length);
+			break;
+
+		case PT_VXLAN:
+			udpipaddr_print(ndo, ip, sport, dport);
+			vxlan_print(ndo, (const u_char *)(up + 1), length);
+			break;
+
+		case PT_PGM:
+		case PT_PGM_ZMTP1:
+			udpipaddr_print(ndo, ip, sport, dport);
+			pgm_print(ndo, cp, length, bp2);
+			break;
+		case PT_LMP:
+			udpipaddr_print(ndo, ip, sport, dport);
+			lmp_print(ndo, cp, length);
 			break;
 		}
 		return;
 	}
 
-	if (!qflag) {
-		register struct sunrpc_msg *rp;
+	udpipaddr_print(ndo, ip, sport, dport);
+	if (!ndo->ndo_qflag) {
+		register const struct sunrpc_msg *rp;
 		enum sunrpc_msg_type direction;
 
-		rp = (struct sunrpc_msg *)(up + 1);
-		if (TTEST(rp->rm_direction)) {
+		rp = (const struct sunrpc_msg *)(up + 1);
+		if (ND_TTEST(rp->rm_direction)) {
 			direction = (enum sunrpc_msg_type)EXTRACT_32BITS(&rp->rm_direction);
 			if (dport == NFS_PORT && direction == SUNRPC_CALL) {
-				nfsreq_print((u_char *)rp, length,
-				    (u_char *)ip);
+				ND_PRINT((ndo, "NFS request xid %u ", EXTRACT_32BITS(&rp->rm_xid)));
+				nfsreq_print_noaddr(ndo, (const u_char *)rp, length,
+				    (const u_char *)ip);
 				return;
 			}
 			if (sport == NFS_PORT && direction == SUNRPC_REPLY) {
-				nfsreply_print((u_char *)rp, length,
-				    (u_char *)ip);
+				ND_PRINT((ndo, "NFS reply xid %u ", EXTRACT_32BITS(&rp->rm_xid)));
+				nfsreply_print_noaddr(ndo, (const u_char *)rp, length,
+				    (const u_char *)ip);
 				return;
 			}
 #ifdef notdef
 			if (dport == SUNRPC_PORT && direction == SUNRPC_CALL) {
-				sunrpcrequest_print((u_char *)rp, length, (u_char *)ip);
+				sunrpcrequest_print((const u_char *)rp, length, (const u_char *)ip);
 				return;
 			}
 #endif
 		}
-		if (TTEST(((struct LAP *)cp)->type) &&
-		    ((struct LAP *)cp)->type == lapDDP &&
-		    (atalk_port(sport) || atalk_port(dport))) {
-			if (vflag)
-				fputs("kip ", stdout);
-			llap_print(cp, length);
-			return;
-		}
 	}
-	udpipaddr_print(ip, sport, dport);
 
-	if (vflag && !Kflag && !fragmented) {
+	if (ndo->ndo_vflag && !ndo->ndo_Kflag && !fragmented) {
                 /* Check the checksum, if possible. */
-                u_int16_t sum, udp_sum;
+                uint16_t sum, udp_sum;
 
 		/*
 		 * XXX - do this even if vflag == 1?
 		 * TCP does, and we do so for UDP-over-IPv6.
 		 */
-	        if (IP_V(ip) == 4 && (vflag > 1)) {
+	        if (IP_V(ip) == 4 && (ndo->ndo_vflag > 1)) {
 			udp_sum = EXTRACT_16BITS(&up->uh_sum);
 			if (udp_sum == 0) {
-				(void)printf("[no cksum] ");
-			} else if (TTEST2(cp[0], length)) {
-				sum = udp_cksum(ip, up, length + sizeof(struct udphdr));
+				ND_PRINT((ndo, "[no cksum] "));
+			} else if (ND_TTEST2(cp[0], length)) {
+				sum = udp_cksum(ndo, ip, up, length + sizeof(struct udphdr));
 
 	                        if (sum != 0) {
-        	                        (void)printf("[bad udp cksum 0x%04x -> 0x%04x!] ",
+					ND_PRINT((ndo, "[bad udp cksum 0x%04x -> 0x%04x!] ",
 					    udp_sum,
-					    in_cksum_shouldbe(udp_sum, sum));
+					    in_cksum_shouldbe(udp_sum, sum)));
 				} else
-					(void)printf("[udp sum ok] ");
+					ND_PRINT((ndo, "[udp sum ok] "));
 			}
 		}
-#ifdef INET6
 		else if (IP_V(ip) == 6 && ip6->ip6_plen) {
 			/* for IPv6, UDP checksum is mandatory */
-			if (TTEST2(cp[0], length)) {
-				sum = udp6_cksum(ip6, up, length + sizeof(struct udphdr));
+			if (ND_TTEST2(cp[0], length)) {
+				sum = udp6_cksum(ndo, ip6, up, length + sizeof(struct udphdr));
 				udp_sum = EXTRACT_16BITS(&up->uh_sum);
 
 	                        if (sum != 0) {
-        	                        (void)printf("[bad udp cksum 0x%04x -> 0x%04x!] ",
+					ND_PRINT((ndo, "[bad udp cksum 0x%04x -> 0x%04x!] ",
 					    udp_sum,
-					    in_cksum_shouldbe(udp_sum, sum));
+					    in_cksum_shouldbe(udp_sum, sum)));
 				} else
-					(void)printf("[udp sum ok] ");
+					ND_PRINT((ndo, "[udp sum ok] "));
 			}
 		}
-#endif
 	}
 
-	if (!qflag) {
-#define ISPORT(p) (dport == (p) || sport == (p))
-		if (ISPORT(NAMESERVER_PORT))
-			ns_print((const u_char *)(up + 1), length, 0);
-		else if (ISPORT(MULTICASTDNS_PORT))
-			ns_print((const u_char *)(up + 1), length, 1);
-		else if (ISPORT(TIMED_PORT))
-			timed_print((const u_char *)(up + 1));
-		else if (ISPORT(TFTP_PORT))
-			tftp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(IPPORT_BOOTPC) || ISPORT(IPPORT_BOOTPS))
-			bootp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(RIP_PORT))
-			rip_print((const u_char *)(up + 1), length);
-		else if (ISPORT(AODV_PORT))
-			aodv_print((const u_char *)(up + 1), length,
-#ifdef INET6
+	if (!ndo->ndo_qflag) {
+		if (IS_SRC_OR_DST_PORT(NAMESERVER_PORT))
+			ns_print(ndo, (const u_char *)(up + 1), length, 0);
+		else if (IS_SRC_OR_DST_PORT(MULTICASTDNS_PORT))
+			ns_print(ndo, (const u_char *)(up + 1), length, 1);
+		else if (IS_SRC_OR_DST_PORT(TIMED_PORT))
+			timed_print(ndo, (const u_char *)(up + 1));
+		else if (IS_SRC_OR_DST_PORT(TFTP_PORT))
+			tftp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(BOOTPC_PORT) || IS_SRC_OR_DST_PORT(BOOTPS_PORT))
+			bootp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(RIP_PORT))
+			rip_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(AODV_PORT))
+			aodv_print(ndo, (const u_char *)(up + 1), length,
 			    ip6 != NULL);
-#else
-			    0);
-#endif
-	        else if (ISPORT(ISAKMP_PORT))
-			 isakmp_print(gndo, (const u_char *)(up + 1), length, bp2);
-  	        else if (ISPORT(ISAKMP_PORT_NATT))
-			 isakmp_rfc3948_print(gndo, (const u_char *)(up + 1), length, bp2);
+	        else if (IS_SRC_OR_DST_PORT(ISAKMP_PORT))
+			 isakmp_print(ndo, (const u_char *)(up + 1), length, bp2);
+	        else if (IS_SRC_OR_DST_PORT(ISAKMP_PORT_NATT))
+			 isakmp_rfc3948_print(ndo, (const u_char *)(up + 1), length, bp2);
 #if 1 /*???*/
-   	        else if (ISPORT(ISAKMP_PORT_USER1) || ISPORT(ISAKMP_PORT_USER2))
-			isakmp_print(gndo, (const u_char *)(up + 1), length, bp2);
+	        else if (IS_SRC_OR_DST_PORT(ISAKMP_PORT_USER1) || IS_SRC_OR_DST_PORT(ISAKMP_PORT_USER2))
+			isakmp_print(ndo, (const u_char *)(up + 1), length, bp2);
 #endif
-		else if (ISPORT(SNMP_PORT) || ISPORT(SNMPTRAP_PORT))
-			snmp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(NTP_PORT))
-			ntp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(KERBEROS_PORT) || ISPORT(KERBEROS_SEC_PORT))
-			krb_print((const void *)(up + 1));
-		else if (ISPORT(L2TP_PORT))
-			l2tp_print((const u_char *)(up + 1), length);
-#ifdef TCPDUMP_DO_SMB
-		else if (ISPORT(NETBIOS_NS_PORT))
-			nbt_udp137_print((const u_char *)(up + 1), length);
-		else if (ISPORT(NETBIOS_DGRAM_PORT))
-			nbt_udp138_print((const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(SNMP_PORT) || IS_SRC_OR_DST_PORT(SNMPTRAP_PORT))
+			snmp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(NTP_PORT))
+			ntp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(KERBEROS_PORT) || IS_SRC_OR_DST_PORT(KERBEROS_SEC_PORT))
+			krb_print(ndo, (const void *)(up + 1));
+		else if (IS_SRC_OR_DST_PORT(L2TP_PORT))
+			l2tp_print(ndo, (const u_char *)(up + 1), length);
+#ifdef ENABLE_SMB
+		else if (IS_SRC_OR_DST_PORT(NETBIOS_NS_PORT))
+			nbt_udp137_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(NETBIOS_DGRAM_PORT))
+			nbt_udp138_print(ndo, (const u_char *)(up + 1), length);
 #endif
-		else if (dport == 3456)
-			vat_print((const void *)(up + 1), up);
-		else if (ISPORT(ZEPHYR_SRV_PORT) || ISPORT(ZEPHYR_CLT_PORT))
-			zephyr_print((const void *)(up + 1), length);
+		else if (dport == VAT_PORT)
+			vat_print(ndo, (const void *)(up + 1), up);
+		else if (IS_SRC_OR_DST_PORT(ZEPHYR_SRV_PORT) || IS_SRC_OR_DST_PORT(ZEPHYR_CLT_PORT))
+			zephyr_print(ndo, (const void *)(up + 1), length);
 		/*
 		 * Since there are 10 possible ports to check, I think
 		 * a <> test would be more efficient
 		 */
 		else if ((sport >= RX_PORT_LOW && sport <= RX_PORT_HIGH) ||
 			 (dport >= RX_PORT_LOW && dport <= RX_PORT_HIGH))
-			rx_print((const void *)(up + 1), length, sport, dport,
-				 (u_char *) ip);
-#ifdef INET6
-		else if (ISPORT(RIPNG_PORT))
-			ripng_print((const u_char *)(up + 1), length);
-		else if (ISPORT(DHCP6_SERV_PORT) || ISPORT(DHCP6_CLI_PORT))
-			dhcp6_print((const u_char *)(up + 1), length);
-		else if (ISPORT(BABEL_PORT) || ISPORT(BABEL_PORT_OLD))
-			babel_print((const u_char *)(up + 1), length);
-#endif /*INET6*/
+			rx_print(ndo, (const void *)(up + 1), length, sport, dport,
+				 (const u_char *) ip);
+		else if (IS_SRC_OR_DST_PORT(RIPNG_PORT))
+			ripng_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(DHCP6_SERV_PORT) || IS_SRC_OR_DST_PORT(DHCP6_CLI_PORT))
+			dhcp6_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(AHCP_PORT))
+			ahcp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(BABEL_PORT) || IS_SRC_OR_DST_PORT(BABEL_PORT_OLD))
+			babel_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(HNCP_PORT))
+			hncp_print(ndo, (const u_char *)(up + 1), length);
 		/*
 		 * Kludge in test for whiteboard packets.
 		 */
-		else if (dport == 4567)
-			wb_print((const void *)(up + 1), length);
-		else if (ISPORT(CISCO_AUTORP_PORT))
-			cisco_autorp_print((const void *)(up + 1), length);
-		else if (ISPORT(RADIUS_PORT) ||
-			 ISPORT(RADIUS_NEW_PORT) ||
-			 ISPORT(RADIUS_ACCOUNTING_PORT) ||
-			 ISPORT(RADIUS_NEW_ACCOUNTING_PORT) )
-			radius_print((const u_char *)(up+1), length);
+		else if (dport == WB_PORT)
+			wb_print(ndo, (const void *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(CISCO_AUTORP_PORT))
+			cisco_autorp_print(ndo, (const void *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(RADIUS_PORT) ||
+			 IS_SRC_OR_DST_PORT(RADIUS_NEW_PORT) ||
+			 IS_SRC_OR_DST_PORT(RADIUS_ACCOUNTING_PORT) ||
+			 IS_SRC_OR_DST_PORT(RADIUS_NEW_ACCOUNTING_PORT) ||
+			 IS_SRC_OR_DST_PORT(RADIUS_CISCO_COA_PORT) ||
+			 IS_SRC_OR_DST_PORT(RADIUS_COA_PORT) )
+			radius_print(ndo, (const u_char *)(up+1), length);
 		else if (dport == HSRP_PORT)
-			hsrp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(LWRES_PORT))
-			lwres_print((const u_char *)(up + 1), length);
-		else if (ISPORT(LDP_PORT))
-			ldp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(OLSR_PORT))
-			olsr_print((const u_char *)(up + 1), length,
-#if INET6
+			hsrp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(LWRES_PORT))
+			lwres_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(LDP_PORT))
+			ldp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(OLSR_PORT))
+			olsr_print(ndo, (const u_char *)(up + 1), length,
 					(IP_V(ip) == 6) ? 1 : 0);
-#else
-					0);
-#endif
-		else if (ISPORT(MPLS_LSP_PING_PORT))
-			lspping_print((const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(MPLS_LSP_PING_PORT))
+			lspping_print(ndo, (const u_char *)(up + 1), length);
 		else if (dport == BFD_CONTROL_PORT ||
 			 dport == BFD_ECHO_PORT )
-			bfd_print((const u_char *)(up+1), length, dport);
-                else if (ISPORT(LMP_PORT))
-			lmp_print((const u_char *)(up + 1), length);
-		else if (ISPORT(VQP_PORT))
-			vqp_print((const u_char *)(up + 1), length);
-                else if (ISPORT(SFLOW_PORT))
-                        sflow_print((const u_char *)(up + 1), length);
+			bfd_print(ndo, (const u_char *)(up+1), length, dport);
+                else if (IS_SRC_OR_DST_PORT(LMP_PORT))
+			lmp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(VQP_PORT))
+			vqp_print(ndo, (const u_char *)(up + 1), length);
+                else if (IS_SRC_OR_DST_PORT(SFLOW_PORT))
+                        sflow_print(ndo, (const u_char *)(up + 1), length);
 	        else if (dport == LWAPP_CONTROL_PORT)
-			lwapp_control_print((const u_char *)(up + 1), length, 1);
+			lwapp_control_print(ndo, (const u_char *)(up + 1), length, 1);
                 else if (sport == LWAPP_CONTROL_PORT)
-                        lwapp_control_print((const u_char *)(up + 1), length, 0);
-                else if (ISPORT(LWAPP_DATA_PORT))
-                        lwapp_data_print((const u_char *)(up + 1), length);
-                else if (ISPORT(SIP_PORT))
-			sip_print((const u_char *)(up + 1), length);
-                else if (ISPORT(SYSLOG_PORT))
-			syslog_print((const u_char *)(up + 1), length);
+                        lwapp_control_print(ndo, (const u_char *)(up + 1), length, 0);
+                else if (IS_SRC_OR_DST_PORT(LWAPP_DATA_PORT))
+                        lwapp_data_print(ndo, (const u_char *)(up + 1), length);
+                else if (IS_SRC_OR_DST_PORT(SIP_PORT))
+			sip_print(ndo, (const u_char *)(up + 1), length);
+                else if (IS_SRC_OR_DST_PORT(SYSLOG_PORT))
+			syslog_print(ndo, (const u_char *)(up + 1), length);
+                else if (IS_SRC_OR_DST_PORT(OTV_PORT))
+			otv_print(ndo, (const u_char *)(up + 1), length);
+                else if (IS_SRC_OR_DST_PORT(VXLAN_PORT))
+			vxlan_print(ndo, (const u_char *)(up + 1), length);
+                else if (IS_SRC_OR_DST_PORT(GENEVE_PORT))
+			geneve_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(LISP_CONTROL_PORT))
+			lisp_print(ndo, (const u_char *)(up + 1), length);
+		else if (IS_SRC_OR_DST_PORT(VXLAN_GPE_PORT))
+			vxlan_gpe_print(ndo, (const u_char *)(up + 1), length);
+		else if (ND_TTEST(((const struct LAP *)cp)->type) &&
+		    ((const struct LAP *)cp)->type == lapDDP &&
+		    (atalk_port(sport) || atalk_port(dport))) {
+			if (ndo->ndo_vflag)
+				ND_PRINT((ndo, "kip "));
+			llap_print(ndo, cp, length);
+		} else {
+			if (ulen > length)
+				ND_PRINT((ndo, "UDP, bad length %u > %u",
+				    ulen, length));
+			else
+				ND_PRINT((ndo, "UDP, length %u", ulen));
+		}
+	} else {
+		if (ulen > length)
+			ND_PRINT((ndo, "UDP, bad length %u > %u",
+			    ulen, length));
 		else
-			(void)printf("UDP, length %u",
-			    (u_int32_t)(ulen - sizeof(*up)));
-#undef ISPORT
-	} else
-		(void)printf("UDP, length %u", (u_int32_t)(ulen - sizeof(*up)));
+			ND_PRINT((ndo, "UDP, length %u", ulen));
+	}
+	return;
+
+trunc:
+	ND_PRINT((ndo, "%s", udp_tstr));
 }
 
 
@@ -673,4 +716,3 @@ udp_print(register const u_char *bp, u_int length,
  * c-basic-offset: 8
  * End:
  */
-