1/*
2 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
16 * written permission.
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 */
21
22#ifndef lint
23static const char rcsid[] _U_ =
24    "@(#) $Header: /tcpdump/master/tcpdump/print-udp.c,v 1.142 2007-08-08 17:20:58 hannes Exp $ (LBL)";
25#endif
26
27#ifdef HAVE_CONFIG_H
28#include "config.h"
29#endif
30
31#include <tcpdump-stdinc.h>
32
33#ifdef SEGSIZE
34#undef SEGSIZE
35#endif
36
37#include <stdio.h>
38#include <string.h>
39
40#include "interface.h"
41#include "addrtoname.h"
42#include "extract.h"
43#include "appletalk.h"
44
45#include "udp.h"
46
47#include "ip.h"
48#ifdef INET6
49#include "ip6.h"
50#endif
51#include "ipproto.h"
52#include "rpc_auth.h"
53#include "rpc_msg.h"
54
55#include "nameser.h"
56#include "nfs.h"
57#include "bootp.h"
58
59struct rtcphdr {
60	u_int16_t rh_flags;	/* T:2 P:1 CNT:5 PT:8 */
61	u_int16_t rh_len;	/* length of message (in words) */
62	u_int32_t rh_ssrc;	/* synchronization src id */
63};
64
65typedef struct {
66	u_int32_t upper;	/* more significant 32 bits */
67	u_int32_t lower;	/* less significant 32 bits */
68} ntp64;
69
70/*
71 * Sender report.
72 */
73struct rtcp_sr {
74	ntp64 sr_ntp;		/* 64-bit ntp timestamp */
75	u_int32_t sr_ts;	/* reference media timestamp */
76	u_int32_t sr_np;	/* no. packets sent */
77	u_int32_t sr_nb;	/* no. bytes sent */
78};
79
80/*
81 * Receiver report.
82 * Time stamps are middle 32-bits of ntp timestamp.
83 */
84struct rtcp_rr {
85	u_int32_t rr_srcid;	/* sender being reported */
86	u_int32_t rr_nl;	/* no. packets lost */
87	u_int32_t rr_ls;	/* extended last seq number received */
88	u_int32_t rr_dv;	/* jitter (delay variance) */
89	u_int32_t rr_lsr;	/* orig. ts from last rr from this src  */
90	u_int32_t rr_dlsr;	/* time from recpt of last rr to xmit time */
91};
92
93/*XXX*/
94#define RTCP_PT_SR	200
95#define RTCP_PT_RR	201
96#define RTCP_PT_SDES	202
97#define 	RTCP_SDES_CNAME	1
98#define 	RTCP_SDES_NAME	2
99#define 	RTCP_SDES_EMAIL	3
100#define 	RTCP_SDES_PHONE	4
101#define 	RTCP_SDES_LOC	5
102#define 	RTCP_SDES_TOOL	6
103#define 	RTCP_SDES_NOTE	7
104#define 	RTCP_SDES_PRIV	8
105#define RTCP_PT_BYE	203
106#define RTCP_PT_APP	204
107
108static void
109vat_print(const void *hdr, register const struct udphdr *up)
110{
111	/* vat/vt audio */
112	u_int ts = *(u_int16_t *)hdr;
113	if ((ts & 0xf060) != 0) {
114		/* probably vt */
115		(void)printf("udp/vt %u %d / %d",
116			     (u_int32_t)(EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up)),
117			     ts & 0x3ff, ts >> 10);
118	} else {
119		/* probably vat */
120		u_int32_t i0 = EXTRACT_32BITS(&((u_int *)hdr)[0]);
121		u_int32_t i1 = EXTRACT_32BITS(&((u_int *)hdr)[1]);
122		printf("udp/vat %u c%d %u%s",
123			(u_int32_t)(EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up) - 8),
124			i0 & 0xffff,
125			i1, i0 & 0x800000? "*" : "");
126		/* audio format */
127		if (i0 & 0x1f0000)
128			printf(" f%d", (i0 >> 16) & 0x1f);
129		if (i0 & 0x3f000000)
130			printf(" s%d", (i0 >> 24) & 0x3f);
131	}
132}
133
134static void
135rtp_print(const void *hdr, u_int len, register const struct udphdr *up)
136{
137	/* rtp v1 or v2 */
138	u_int *ip = (u_int *)hdr;
139	u_int hasopt, hasext, contype, hasmarker;
140	u_int32_t i0 = EXTRACT_32BITS(&((u_int *)hdr)[0]);
141	u_int32_t i1 = EXTRACT_32BITS(&((u_int *)hdr)[1]);
142	u_int dlen = EXTRACT_16BITS(&up->uh_ulen) - sizeof(*up) - 8;
143	const char * ptype;
144
145	ip += 2;
146	len >>= 2;
147	len -= 2;
148	hasopt = 0;
149	hasext = 0;
150	if ((i0 >> 30) == 1) {
151		/* rtp v1 */
152		hasopt = i0 & 0x800000;
153		contype = (i0 >> 16) & 0x3f;
154		hasmarker = i0 & 0x400000;
155		ptype = "rtpv1";
156	} else {
157		/* rtp v2 */
158		hasext = i0 & 0x10000000;
159		contype = (i0 >> 16) & 0x7f;
160		hasmarker = i0 & 0x800000;
161		dlen -= 4;
162		ptype = "rtp";
163		ip += 1;
164		len -= 1;
165	}
166	printf("udp/%s %d c%d %s%s %d %u",
167		ptype,
168		dlen,
169		contype,
170		(hasopt || hasext)? "+" : "",
171		hasmarker? "*" : "",
172		i0 & 0xffff,
173		i1);
174	if (vflag) {
175		printf(" %u", EXTRACT_32BITS(&((u_int *)hdr)[2]));
176		if (hasopt) {
177			u_int i2, optlen;
178			do {
179				i2 = ip[0];
180				optlen = (i2 >> 16) & 0xff;
181				if (optlen == 0 || optlen > len) {
182					printf(" !opt");
183					return;
184				}
185				ip += optlen;
186				len -= optlen;
187			} while ((int)i2 >= 0);
188		}
189		if (hasext) {
190			u_int i2, extlen;
191			i2 = ip[0];
192			extlen = (i2 & 0xffff) + 1;
193			if (extlen > len) {
194				printf(" !ext");
195				return;
196			}
197			ip += extlen;
198		}
199		if (contype == 0x1f) /*XXX H.261 */
200			printf(" 0x%04x", ip[0] >> 16);
201	}
202}
203
204static const u_char *
205rtcp_print(const u_char *hdr, const u_char *ep)
206{
207	/* rtp v2 control (rtcp) */
208	struct rtcp_rr *rr = 0;
209	struct rtcp_sr *sr;
210	struct rtcphdr *rh = (struct rtcphdr *)hdr;
211	u_int len;
212	u_int16_t flags;
213	int cnt;
214	double ts, dts;
215	if ((u_char *)(rh + 1) > ep) {
216		printf(" [|rtcp]");
217		return (ep);
218	}
219	len = (EXTRACT_16BITS(&rh->rh_len) + 1) * 4;
220	flags = EXTRACT_16BITS(&rh->rh_flags);
221	cnt = (flags >> 8) & 0x1f;
222	switch (flags & 0xff) {
223	case RTCP_PT_SR:
224		sr = (struct rtcp_sr *)(rh + 1);
225		printf(" sr");
226		if (len != cnt * sizeof(*rr) + sizeof(*sr) + sizeof(*rh))
227			printf(" [%d]", len);
228		if (vflag)
229			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
230		if ((u_char *)(sr + 1) > ep) {
231			printf(" [|rtcp]");
232			return (ep);
233		}
234		ts = (double)(EXTRACT_32BITS(&sr->sr_ntp.upper)) +
235		    ((double)(EXTRACT_32BITS(&sr->sr_ntp.lower)) /
236		    4294967296.0);
237		printf(" @%.2f %u %up %ub", ts, EXTRACT_32BITS(&sr->sr_ts),
238		    EXTRACT_32BITS(&sr->sr_np), EXTRACT_32BITS(&sr->sr_nb));
239		rr = (struct rtcp_rr *)(sr + 1);
240		break;
241	case RTCP_PT_RR:
242		printf(" rr");
243		if (len != cnt * sizeof(*rr) + sizeof(*rh))
244			printf(" [%d]", len);
245		rr = (struct rtcp_rr *)(rh + 1);
246		if (vflag)
247			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
248		break;
249	case RTCP_PT_SDES:
250		printf(" sdes %d", len);
251		if (vflag)
252			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
253		cnt = 0;
254		break;
255	case RTCP_PT_BYE:
256		printf(" bye %d", len);
257		if (vflag)
258			printf(" %u", EXTRACT_32BITS(&rh->rh_ssrc));
259		cnt = 0;
260		break;
261	default:
262		printf(" type-0x%x %d", flags & 0xff, len);
263		cnt = 0;
264		break;
265	}
266	if (cnt > 1)
267		printf(" c%d", cnt);
268	while (--cnt >= 0) {
269		if ((u_char *)(rr + 1) > ep) {
270			printf(" [|rtcp]");
271			return (ep);
272		}
273		if (vflag)
274			printf(" %u", EXTRACT_32BITS(&rr->rr_srcid));
275		ts = (double)(EXTRACT_32BITS(&rr->rr_lsr)) / 65536.;
276		dts = (double)(EXTRACT_32BITS(&rr->rr_dlsr)) / 65536.;
277		printf(" %ul %us %uj @%.2f+%.2f",
278		    EXTRACT_32BITS(&rr->rr_nl) & 0x00ffffff,
279		    EXTRACT_32BITS(&rr->rr_ls),
280		    EXTRACT_32BITS(&rr->rr_dv), ts, dts);
281	}
282	return (hdr + len);
283}
284
285static int udp_cksum(register const struct ip *ip,
286		     register const struct udphdr *up,
287		     register u_int len)
288{
289	return (nextproto4_cksum(ip, (const u_int8_t *)(void *)up, len,
290	    IPPROTO_UDP));
291}
292
293#ifdef INET6
294static int udp6_cksum(const struct ip6_hdr *ip6, const struct udphdr *up,
295	u_int len)
296{
297	return (nextproto6_cksum(ip6, (const u_int8_t *)(void *)up, len,
298	    IPPROTO_UDP));
299}
300#endif
301
302static void
303udpipaddr_print(const struct ip *ip, int sport, int dport)
304{
305#ifdef INET6
306	const struct ip6_hdr *ip6;
307
308	if (IP_V(ip) == 6)
309		ip6 = (const struct ip6_hdr *)ip;
310	else
311		ip6 = NULL;
312
313	if (ip6) {
314		if (ip6->ip6_nxt == IPPROTO_UDP) {
315			if (sport == -1) {
316				(void)printf("%s > %s: ",
317					ip6addr_string(&ip6->ip6_src),
318					ip6addr_string(&ip6->ip6_dst));
319			} else {
320				(void)printf("%s.%s > %s.%s: ",
321					ip6addr_string(&ip6->ip6_src),
322					udpport_string(sport),
323					ip6addr_string(&ip6->ip6_dst),
324					udpport_string(dport));
325			}
326		} else {
327			if (sport != -1) {
328				(void)printf("%s > %s: ",
329					udpport_string(sport),
330					udpport_string(dport));
331			}
332		}
333	} else
334#endif /*INET6*/
335	{
336		if (ip->ip_p == IPPROTO_UDP) {
337			if (sport == -1) {
338				(void)printf("%s > %s: ",
339					ipaddr_string(&ip->ip_src),
340					ipaddr_string(&ip->ip_dst));
341			} else {
342				(void)printf("%s.%s > %s.%s: ",
343					ipaddr_string(&ip->ip_src),
344					udpport_string(sport),
345					ipaddr_string(&ip->ip_dst),
346					udpport_string(dport));
347			}
348		} else {
349			if (sport != -1) {
350				(void)printf("%s > %s: ",
351					udpport_string(sport),
352					udpport_string(dport));
353			}
354		}
355	}
356}
357
358void
359udp_print(register const u_char *bp, u_int length,
360	  register const u_char *bp2, int fragmented)
361{
362	register const struct udphdr *up;
363	register const struct ip *ip;
364	register const u_char *cp;
365	register const u_char *ep = bp + length;
366	u_int16_t sport, dport, ulen;
367#ifdef INET6
368	register const struct ip6_hdr *ip6;
369#endif
370
371	if (ep > snapend)
372		ep = snapend;
373	up = (struct udphdr *)bp;
374	ip = (struct ip *)bp2;
375#ifdef INET6
376	if (IP_V(ip) == 6)
377		ip6 = (struct ip6_hdr *)bp2;
378	else
379		ip6 = NULL;
380#endif /*INET6*/
381	cp = (u_char *)(up + 1);
382	if (!TTEST(up->uh_dport)) {
383		udpipaddr_print(ip, -1, -1);
384		(void)printf("[|udp]");
385		return;
386	}
387
388	sport = EXTRACT_16BITS(&up->uh_sport);
389	dport = EXTRACT_16BITS(&up->uh_dport);
390
391	if (length < sizeof(struct udphdr)) {
392		udpipaddr_print(ip, sport, dport);
393		(void)printf("truncated-udp %d", length);
394		return;
395	}
396	length -= sizeof(struct udphdr);
397
398	if (cp > snapend) {
399		udpipaddr_print(ip, sport, dport);
400		(void)printf("[|udp]");
401		return;
402	}
403
404	ulen = EXTRACT_16BITS(&up->uh_ulen);
405	if (ulen < 8) {
406		udpipaddr_print(ip, sport, dport);
407		(void)printf("truncated-udplength %d", ulen);
408		return;
409	}
410	if (packettype) {
411		register struct sunrpc_msg *rp;
412		enum sunrpc_msg_type direction;
413
414		switch (packettype) {
415
416		case PT_VAT:
417			udpipaddr_print(ip, sport, dport);
418			vat_print((void *)(up + 1), up);
419			break;
420
421		case PT_WB:
422			udpipaddr_print(ip, sport, dport);
423			wb_print((void *)(up + 1), length);
424			break;
425
426		case PT_RPC:
427			rp = (struct sunrpc_msg *)(up + 1);
428			direction = (enum sunrpc_msg_type)EXTRACT_32BITS(&rp->rm_direction);
429			if (direction == SUNRPC_CALL)
430				sunrpcrequest_print((u_char *)rp, length,
431				    (u_char *)ip);
432			else
433				nfsreply_print((u_char *)rp, length,
434				    (u_char *)ip);			/*XXX*/
435			break;
436
437		case PT_RTP:
438			udpipaddr_print(ip, sport, dport);
439			rtp_print((void *)(up + 1), length, up);
440			break;
441
442		case PT_RTCP:
443			udpipaddr_print(ip, sport, dport);
444			while (cp < ep)
445				cp = rtcp_print(cp, ep);
446			break;
447
448		case PT_SNMP:
449			udpipaddr_print(ip, sport, dport);
450			snmp_print((const u_char *)(up + 1), length);
451			break;
452
453		case PT_CNFP:
454			udpipaddr_print(ip, sport, dport);
455			cnfp_print(cp, (const u_char *)ip);
456			break;
457
458		case PT_TFTP:
459			udpipaddr_print(ip, sport, dport);
460			tftp_print(cp, length);
461			break;
462
463		case PT_AODV:
464			udpipaddr_print(ip, sport, dport);
465			aodv_print((const u_char *)(up + 1), length,
466#ifdef INET6
467			    ip6 != NULL);
468#else
469			    0);
470#endif
471			break;
472
473		case PT_RADIUS:
474			udpipaddr_print(ip, sport, dport);
475			radius_print(cp, length);
476			break;
477
478		case PT_VXLAN:
479			udpipaddr_print(ip, sport, dport);
480			vxlan_print((const u_char *)(up + 1), length);
481			break;
482
483		case PT_PGM:
484		case PT_PGM_ZMTP1:
485			udpipaddr_print(ip, sport, dport);
486			pgm_print(cp, length, bp2);
487			break;
488		case PT_LMP:
489			udpipaddr_print(ip, sport, dport);
490			lmp_print(cp, length);
491			break;
492		}
493		return;
494	}
495
496	if (!qflag) {
497		register struct sunrpc_msg *rp;
498		enum sunrpc_msg_type direction;
499
500		rp = (struct sunrpc_msg *)(up + 1);
501		if (TTEST(rp->rm_direction)) {
502			direction = (enum sunrpc_msg_type)EXTRACT_32BITS(&rp->rm_direction);
503			if (dport == NFS_PORT && direction == SUNRPC_CALL) {
504				nfsreq_print((u_char *)rp, length,
505				    (u_char *)ip);
506				return;
507			}
508			if (sport == NFS_PORT && direction == SUNRPC_REPLY) {
509				nfsreply_print((u_char *)rp, length,
510				    (u_char *)ip);
511				return;
512			}
513#ifdef notdef
514			if (dport == SUNRPC_PORT && direction == SUNRPC_CALL) {
515				sunrpcrequest_print((u_char *)rp, length, (u_char *)ip);
516				return;
517			}
518#endif
519		}
520		if (TTEST(((struct LAP *)cp)->type) &&
521		    ((struct LAP *)cp)->type == lapDDP &&
522		    (atalk_port(sport) || atalk_port(dport))) {
523			if (vflag)
524				fputs("kip ", stdout);
525			llap_print(cp, length);
526			return;
527		}
528	}
529	udpipaddr_print(ip, sport, dport);
530
531	if (vflag && !Kflag && !fragmented) {
532                /* Check the checksum, if possible. */
533                u_int16_t sum, udp_sum;
534
535		/*
536		 * XXX - do this even if vflag == 1?
537		 * TCP does, and we do so for UDP-over-IPv6.
538		 */
539	        if (IP_V(ip) == 4 && (vflag > 1)) {
540			udp_sum = EXTRACT_16BITS(&up->uh_sum);
541			if (udp_sum == 0) {
542				(void)printf("[no cksum] ");
543			} else if (TTEST2(cp[0], length)) {
544				sum = udp_cksum(ip, up, length + sizeof(struct udphdr));
545
546	                        if (sum != 0) {
547        	                        (void)printf("[bad udp cksum 0x%04x -> 0x%04x!] ",
548					    udp_sum,
549					    in_cksum_shouldbe(udp_sum, sum));
550				} else
551					(void)printf("[udp sum ok] ");
552			}
553		}
554#ifdef INET6
555		else if (IP_V(ip) == 6 && ip6->ip6_plen) {
556			/* for IPv6, UDP checksum is mandatory */
557			if (TTEST2(cp[0], length)) {
558				sum = udp6_cksum(ip6, up, length + sizeof(struct udphdr));
559				udp_sum = EXTRACT_16BITS(&up->uh_sum);
560
561	                        if (sum != 0) {
562        	                        (void)printf("[bad udp cksum 0x%04x -> 0x%04x!] ",
563					    udp_sum,
564					    in_cksum_shouldbe(udp_sum, sum));
565				} else
566					(void)printf("[udp sum ok] ");
567			}
568		}
569#endif
570	}
571
572	if (!qflag) {
573#define ISPORT(p) (dport == (p) || sport == (p))
574		if (ISPORT(NAMESERVER_PORT))
575			ns_print((const u_char *)(up + 1), length, 0);
576		else if (ISPORT(MULTICASTDNS_PORT))
577			ns_print((const u_char *)(up + 1), length, 1);
578		else if (ISPORT(TIMED_PORT))
579			timed_print((const u_char *)(up + 1));
580		else if (ISPORT(TFTP_PORT))
581			tftp_print((const u_char *)(up + 1), length);
582		else if (ISPORT(IPPORT_BOOTPC) || ISPORT(IPPORT_BOOTPS))
583			bootp_print((const u_char *)(up + 1), length);
584		else if (ISPORT(RIP_PORT))
585			rip_print((const u_char *)(up + 1), length);
586		else if (ISPORT(AODV_PORT))
587			aodv_print((const u_char *)(up + 1), length,
588#ifdef INET6
589			    ip6 != NULL);
590#else
591			    0);
592#endif
593	        else if (ISPORT(ISAKMP_PORT))
594			 isakmp_print(gndo, (const u_char *)(up + 1), length, bp2);
595  	        else if (ISPORT(ISAKMP_PORT_NATT))
596			 isakmp_rfc3948_print(gndo, (const u_char *)(up + 1), length, bp2);
597#if 1 /*???*/
598   	        else if (ISPORT(ISAKMP_PORT_USER1) || ISPORT(ISAKMP_PORT_USER2))
599			isakmp_print(gndo, (const u_char *)(up + 1), length, bp2);
600#endif
601		else if (ISPORT(SNMP_PORT) || ISPORT(SNMPTRAP_PORT))
602			snmp_print((const u_char *)(up + 1), length);
603		else if (ISPORT(NTP_PORT))
604			ntp_print((const u_char *)(up + 1), length);
605		else if (ISPORT(KERBEROS_PORT) || ISPORT(KERBEROS_SEC_PORT))
606			krb_print((const void *)(up + 1));
607		else if (ISPORT(L2TP_PORT))
608			l2tp_print((const u_char *)(up + 1), length);
609#ifdef TCPDUMP_DO_SMB
610		else if (ISPORT(NETBIOS_NS_PORT))
611			nbt_udp137_print((const u_char *)(up + 1), length);
612		else if (ISPORT(NETBIOS_DGRAM_PORT))
613			nbt_udp138_print((const u_char *)(up + 1), length);
614#endif
615		else if (dport == VAT_PORT)
616			vat_print((const void *)(up + 1), up);
617		else if (ISPORT(ZEPHYR_SRV_PORT) || ISPORT(ZEPHYR_CLT_PORT))
618			zephyr_print((const void *)(up + 1), length);
619		/*
620		 * Since there are 10 possible ports to check, I think
621		 * a <> test would be more efficient
622		 */
623		else if ((sport >= RX_PORT_LOW && sport <= RX_PORT_HIGH) ||
624			 (dport >= RX_PORT_LOW && dport <= RX_PORT_HIGH))
625			rx_print((const void *)(up + 1), length, sport, dport,
626				 (u_char *) ip);
627#ifdef INET6
628		else if (ISPORT(RIPNG_PORT))
629			ripng_print((const u_char *)(up + 1), length);
630		else if (ISPORT(DHCP6_SERV_PORT) || ISPORT(DHCP6_CLI_PORT))
631			dhcp6_print((const u_char *)(up + 1), length);
632		else if (ISPORT(BABEL_PORT) || ISPORT(BABEL_PORT_OLD))
633			babel_print((const u_char *)(up + 1), length);
634#endif /*INET6*/
635		/*
636		 * Kludge in test for whiteboard packets.
637		 */
638		else if (dport == WB_PORT)
639			wb_print((const void *)(up + 1), length);
640		else if (ISPORT(CISCO_AUTORP_PORT))
641			cisco_autorp_print((const void *)(up + 1), length);
642		else if (ISPORT(RADIUS_PORT) ||
643			 ISPORT(RADIUS_NEW_PORT) ||
644			 ISPORT(RADIUS_ACCOUNTING_PORT) ||
645			 ISPORT(RADIUS_NEW_ACCOUNTING_PORT) )
646			radius_print((const u_char *)(up+1), length);
647		else if (dport == HSRP_PORT)
648			hsrp_print((const u_char *)(up + 1), length);
649		else if (ISPORT(LWRES_PORT))
650			lwres_print((const u_char *)(up + 1), length);
651		else if (ISPORT(LDP_PORT))
652			ldp_print((const u_char *)(up + 1), length);
653		else if (ISPORT(OLSR_PORT))
654			olsr_print((const u_char *)(up + 1), length,
655#if INET6
656					(IP_V(ip) == 6) ? 1 : 0);
657#else
658					0);
659#endif
660		else if (ISPORT(MPLS_LSP_PING_PORT))
661			lspping_print((const u_char *)(up + 1), length);
662		else if (dport == BFD_CONTROL_PORT ||
663			 dport == BFD_ECHO_PORT )
664			bfd_print((const u_char *)(up+1), length, dport);
665                else if (ISPORT(LMP_PORT))
666			lmp_print((const u_char *)(up + 1), length);
667		else if (ISPORT(VQP_PORT))
668			vqp_print((const u_char *)(up + 1), length);
669                else if (ISPORT(SFLOW_PORT))
670                        sflow_print((const u_char *)(up + 1), length);
671	        else if (dport == LWAPP_CONTROL_PORT)
672			lwapp_control_print((const u_char *)(up + 1), length, 1);
673                else if (sport == LWAPP_CONTROL_PORT)
674                        lwapp_control_print((const u_char *)(up + 1), length, 0);
675                else if (ISPORT(LWAPP_DATA_PORT))
676                        lwapp_data_print((const u_char *)(up + 1), length);
677                else if (ISPORT(SIP_PORT))
678			sip_print((const u_char *)(up + 1), length);
679                else if (ISPORT(SYSLOG_PORT))
680			syslog_print((const u_char *)(up + 1), length);
681                else if (ISPORT(OTV_PORT))
682			otv_print((const u_char *)(up + 1), length);
683                else if (ISPORT(VXLAN_PORT))
684			vxlan_print((const u_char *)(up + 1), length);
685		else
686			(void)printf("UDP, length %u",
687			    (u_int32_t)(ulen - sizeof(*up)));
688#undef ISPORT
689	} else
690		(void)printf("UDP, length %u", (u_int32_t)(ulen - sizeof(*up)));
691}
692
693
694/*
695 * Local Variables:
696 * c-style: whitesmith
697 * c-basic-offset: 8
698 * End:
699 */
700
701