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