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.138 2005/04/07 00:28:17 mcr 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 60struct 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 66typedef 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 */ 74struct 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 */ 85struct 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 109static void 110vat_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 135static void 136rtp_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 205static const u_char * 206rtcp_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 286static 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 318static 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 362static void 363udpipaddr_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 418void 419udp_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(MPLS_LSP_PING_PORT)) 678 lspping_print((const u_char *)(up + 1), length); 679 else if (dport == BFD_CONTROL_PORT || 680 dport == BFD_ECHO_PORT ) 681 bfd_print((const u_char *)(up+1), length, dport); 682 else if (ISPORT(LMP_PORT)) 683 lmp_print((const u_char *)(up + 1), length); 684 else if (ISPORT(SIP_PORT)) 685 sip_print((const u_char *)(up + 1), length); 686 else if (ISPORT(SYSLOG_PORT)) 687 syslog_print((const u_char *)(up + 1), length); 688 else 689 (void)printf("UDP, length %u", 690 (u_int32_t)(ulen - sizeof(*up))); 691#undef ISPORT 692 } else 693 (void)printf("UDP, length %u", (u_int32_t)(ulen - sizeof(*up))); 694} 695 696 697/* 698 * Local Variables: 699 * c-style: whitesmith 700 * c-basic-offset: 8 701 * End: 702 */ 703 704