/* * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997 *	The Regents of the University of California.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that: (1) source code distributions * retain the above copyright notice and this paragraph in its entirety, (2) * distributions including binary code include the above copyright notice and * this paragraph in its entirety in the documentation or other materials * provided with the distribution, and (3) all advertising materials mentioning * features or use of this software display the following acknowledgement: * ``This product includes software developed by the University of California, * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of * the University nor the names of its contributors may be used to endorse * or promote products derived from this software without specific prior * written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */#ifndef lintstatic const char rcsid[] _U_ =    "@(#) $Header: /tcpdump/master/tcpdump/print-udp.c,v 1.142 2007-08-08 17:20:58 hannes Exp $ (LBL)";#endif#ifdef HAVE_CONFIG_H#include "config.h"#endif#include <tcpdump-stdinc.h>#ifdef SEGSIZE#undef SEGSIZE#endif#include <arpa/tftp.h>#include <stdio.h>#include <string.h>#include "interface.h"#include "addrtoname.h"#include "extract.h"#include "appletalk.h"#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"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 */};typedef struct {	u_int32_t upper;	/* more significant 32 bits */	u_int32_t lower;	/* less significant 32 bits */} ntp64;/* * Sender report. */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 */};/* * Receiver report. * 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 */};/*XXX*/#define RTCP_PT_SR	200#define RTCP_PT_RR	201#define RTCP_PT_SDES	202#define 	RTCP_SDES_CNAME	1#define 	RTCP_SDES_NAME	2#define 	RTCP_SDES_EMAIL	3#define 	RTCP_SDES_PHONE	4#define 	RTCP_SDES_LOC	5#define 	RTCP_SDES_TOOL	6#define 	RTCP_SDES_NOTE	7#define 	RTCP_SDES_PRIV	8#define RTCP_PT_BYE	203#define RTCP_PT_APP	204static voidvat_print(const void *hdr, register const struct udphdr *up){	/* vat/vt audio */	u_int ts = *(u_int16_t *)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);	} 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),			i0 & 0xffff,			i1, i0 & 0x800000? "*" : "");		/* audio format */		if (i0 & 0x1f0000)			printf(" f%d", (i0 >> 16) & 0x1f);		if (i0 & 0x3f000000)			printf(" s%d", (i0 >> 24) & 0x3f);	}}static voidrtp_print(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 char * ptype;	ip += 2;	len >>= 2;	len -= 2;	hasopt = 0;	hasext = 0;	if ((i0 >> 30) == 1) {		/* rtp v1 */		hasopt = i0 & 0x800000;		contype = (i0 >> 16) & 0x3f;		hasmarker = i0 & 0x400000;		ptype = "rtpv1";	} else {		/* rtp v2 */		hasext = i0 & 0x10000000;		contype = (i0 >> 16) & 0x7f;		hasmarker = i0 & 0x800000;		dlen -= 4;		ptype = "rtp";		ip += 1;		len -= 1;	}	printf("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]));		if (hasopt) {			u_int i2, optlen;			do {				i2 = ip[0];				optlen = (i2 >> 16) & 0xff;				if (optlen == 0 || optlen > len) {					printf(" !opt");					return;				}				ip += optlen;				len -= optlen;			} while ((int)i2 >= 0);		}		if (hasext) {			u_int i2, extlen;			i2 = ip[0];			extlen = (i2 & 0xffff) + 1;			if (extlen > len) {				printf(" !ext");				return;			}			ip += extlen;		}		if (contype == 0x1f) /*XXX H.261 */			printf(" 0x%04x", ip[0] >> 16);	}}static const u_char *rtcp_print(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;	u_int len;	u_int16_t flags;	int cnt;	double ts, dts;	if ((u_char *)(rh + 1) > ep) {		printf(" [|rtcp]");		return (ep);	}	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");		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);		}		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);		break;	case RTCP_PT_RR:		printf(" 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));		break;	case RTCP_PT_SDES:		printf(" sdes %d", len);		if (vflag)			printf(" %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));		cnt = 0;		break;	default:		printf(" type-0x%x %d", flags & 0xff, len);		cnt = 0;		break;	}	if (cnt > 1)		printf(" 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));		ts = (double)(EXTRACT_32BITS(&rr->rr_lsr)) / 65536.;		dts = (double)(EXTRACT_32BITS(&rr->rr_dlsr)) / 65536.;		printf(" %ul %us %uj @%.2f+%.2f",		    EXTRACT_32BITS(&rr->rr_nl) & 0x00ffffff,		    EXTRACT_32BITS(&rr->rr_ls),		    EXTRACT_32BITS(&rr->rr_dv), ts, dts);	}	return (hdr + len);}static int udp_cksum(register const struct ip *ip,		     register const struct udphdr *up,		     register u_int len){	union phu {		struct phdr {			u_int32_t src;			u_int32_t dst;			u_char mbz;			u_char proto;			u_int16_t len;		} ph;		u_int16_t pa[6];	} phu;	register const u_int16_t *sp;	/* pseudo-header.. */	phu.ph.len = htons((u_int16_t)len);	phu.ph.mbz = 0;	phu.ph.proto = IPPROTO_UDP;	memcpy(&phu.ph.src, &ip->ip_src.s_addr, sizeof(u_int32_t));	if (IP_HL(ip) == 5)		memcpy(&phu.ph.dst, &ip->ip_dst.s_addr, sizeof(u_int32_t));	else		phu.ph.dst = ip_finddst(ip);	sp = &phu.pa[0];	return in_cksum((u_short *)up, len,			sp[0]+sp[1]+sp[2]+sp[3]+sp[4]+sp[5]);}#ifdef INET6static int udp6_cksum(const struct ip6_hdr *ip6, const struct udphdr *up,	u_int len){	size_t i;	register const u_int16_t *sp;	u_int32_t sum;	union {		struct {			struct in6_addr ph_src;			struct in6_addr ph_dst;			u_int32_t	ph_len;			u_int8_t	ph_zero[3];			u_int8_t	ph_nxt;		} ph;		u_int16_t pa[20];	} phu;	/* pseudo-header */	memset(&phu, 0, sizeof(phu));	phu.ph.ph_src = ip6->ip6_src;	phu.ph.ph_dst = ip6->ip6_dst;	phu.ph.ph_len = htonl(len);	phu.ph.ph_nxt = IPPROTO_UDP;	sum = 0;	for (i = 0; i < sizeof(phu.pa) / sizeof(phu.pa[0]); i++)		sum += phu.pa[i];	sp = (const u_int16_t *)up;	for (i = 0; i < (len & ~1); i += 2)		sum += *sp++;	if (len & 1)		sum += htons((*(const u_int8_t *)sp) << 8);	while (sum > 0xffff)		sum = (sum & 0xffff) + (sum >> 16);	sum = ~sum & 0xffff;	return (sum);