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.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 59 struct 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 65 typedef 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 */ 73 struct 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 */ 84 struct 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 108 static void 109 vat_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 134 static void 135 rtp_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 204 static const u_char * 205 rtcp_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 285 static 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 294 static 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 302 static void 303 udpipaddr_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 358 void 359 udp_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 return; 474 } 475 476 if (!qflag) { 477 register struct sunrpc_msg *rp; 478 enum sunrpc_msg_type direction; 479 480 rp = (struct sunrpc_msg *)(up + 1); 481 if (TTEST(rp->rm_direction)) { 482 direction = (enum sunrpc_msg_type)EXTRACT_32BITS(&rp->rm_direction); 483 if (dport == NFS_PORT && direction == SUNRPC_CALL) { 484 nfsreq_print((u_char *)rp, length, 485 (u_char *)ip); 486 return; 487 } 488 if (sport == NFS_PORT && direction == SUNRPC_REPLY) { 489 nfsreply_print((u_char *)rp, length, 490 (u_char *)ip); 491 return; 492 } 493 #ifdef notdef 494 if (dport == SUNRPC_PORT && direction == SUNRPC_CALL) { 495 sunrpcrequest_print((u_char *)rp, length, (u_char *)ip); 496 return; 497 } 498 #endif 499 } 500 if (TTEST(((struct LAP *)cp)->type) && 501 ((struct LAP *)cp)->type == lapDDP && 502 (atalk_port(sport) || atalk_port(dport))) { 503 if (vflag) 504 fputs("kip ", stdout); 505 llap_print(cp, length); 506 return; 507 } 508 } 509 udpipaddr_print(ip, sport, dport); 510 511 if (vflag && !Kflag && !fragmented) { 512 /* Check the checksum, if possible. */ 513 u_int16_t sum, udp_sum; 514 515 /* 516 * XXX - do this even if vflag == 1? 517 * TCP does, and we do so for UDP-over-IPv6. 518 */ 519 if (IP_V(ip) == 4 && (vflag > 1)) { 520 udp_sum = EXTRACT_16BITS(&up->uh_sum); 521 if (udp_sum == 0) { 522 (void)printf("[no cksum] "); 523 } else if (TTEST2(cp[0], length)) { 524 sum = udp_cksum(ip, up, length + sizeof(struct udphdr)); 525 526 if (sum != 0) { 527 (void)printf("[bad udp cksum 0x%04x -> 0x%04x!] ", 528 udp_sum, 529 in_cksum_shouldbe(udp_sum, sum)); 530 } else 531 (void)printf("[udp sum ok] "); 532 } 533 } 534 #ifdef INET6 535 else if (IP_V(ip) == 6 && ip6->ip6_plen) { 536 /* for IPv6, UDP checksum is mandatory */ 537 if (TTEST2(cp[0], length)) { 538 sum = udp6_cksum(ip6, up, length + sizeof(struct udphdr)); 539 udp_sum = EXTRACT_16BITS(&up->uh_sum); 540 541 if (sum != 0) { 542 (void)printf("[bad udp cksum 0x%04x -> 0x%04x!] ", 543 udp_sum, 544 in_cksum_shouldbe(udp_sum, sum)); 545 } else 546 (void)printf("[udp sum ok] "); 547 } 548 } 549 #endif 550 } 551 552 if (!qflag) { 553 #define ISPORT(p) (dport == (p) || sport == (p)) 554 if (ISPORT(NAMESERVER_PORT)) 555 ns_print((const u_char *)(up + 1), length, 0); 556 else if (ISPORT(MULTICASTDNS_PORT)) 557 ns_print((const u_char *)(up + 1), length, 1); 558 else if (ISPORT(TIMED_PORT)) 559 timed_print((const u_char *)(up + 1)); 560 else if (ISPORT(TFTP_PORT)) 561 tftp_print((const u_char *)(up + 1), length); 562 else if (ISPORT(IPPORT_BOOTPC) || ISPORT(IPPORT_BOOTPS)) 563 bootp_print((const u_char *)(up + 1), length); 564 else if (ISPORT(RIP_PORT)) 565 rip_print((const u_char *)(up + 1), length); 566 else if (ISPORT(AODV_PORT)) 567 aodv_print((const u_char *)(up + 1), length, 568 #ifdef INET6 569 ip6 != NULL); 570 #else 571 0); 572 #endif 573 else if (ISPORT(ISAKMP_PORT)) 574 isakmp_print(gndo, (const u_char *)(up + 1), length, bp2); 575 else if (ISPORT(ISAKMP_PORT_NATT)) 576 isakmp_rfc3948_print(gndo, (const u_char *)(up + 1), length, bp2); 577 #if 1 /*???*/ 578 else if (ISPORT(ISAKMP_PORT_USER1) || ISPORT(ISAKMP_PORT_USER2)) 579 isakmp_print(gndo, (const u_char *)(up + 1), length, bp2); 580 #endif 581 else if (ISPORT(SNMP_PORT) || ISPORT(SNMPTRAP_PORT)) 582 snmp_print((const u_char *)(up + 1), length); 583 else if (ISPORT(NTP_PORT)) 584 ntp_print((const u_char *)(up + 1), length); 585 else if (ISPORT(KERBEROS_PORT) || ISPORT(KERBEROS_SEC_PORT)) 586 krb_print((const void *)(up + 1)); 587 else if (ISPORT(L2TP_PORT)) 588 l2tp_print((const u_char *)(up + 1), length); 589 #ifdef TCPDUMP_DO_SMB 590 else if (ISPORT(NETBIOS_NS_PORT)) 591 nbt_udp137_print((const u_char *)(up + 1), length); 592 else if (ISPORT(NETBIOS_DGRAM_PORT)) 593 nbt_udp138_print((const u_char *)(up + 1), length); 594 #endif 595 else if (dport == 3456) 596 vat_print((const void *)(up + 1), up); 597 else if (ISPORT(ZEPHYR_SRV_PORT) || ISPORT(ZEPHYR_CLT_PORT)) 598 zephyr_print((const void *)(up + 1), length); 599 /* 600 * Since there are 10 possible ports to check, I think 601 * a <> test would be more efficient 602 */ 603 else if ((sport >= RX_PORT_LOW && sport <= RX_PORT_HIGH) || 604 (dport >= RX_PORT_LOW && dport <= RX_PORT_HIGH)) 605 rx_print((const void *)(up + 1), length, sport, dport, 606 (u_char *) ip); 607 #ifdef INET6 608 else if (ISPORT(RIPNG_PORT)) 609 ripng_print((const u_char *)(up + 1), length); 610 else if (ISPORT(DHCP6_SERV_PORT) || ISPORT(DHCP6_CLI_PORT)) 611 dhcp6_print((const u_char *)(up + 1), length); 612 else if (ISPORT(BABEL_PORT) || ISPORT(BABEL_PORT_OLD)) 613 babel_print((const u_char *)(up + 1), length); 614 #endif /*INET6*/ 615 /* 616 * Kludge in test for whiteboard packets. 617 */ 618 else if (dport == 4567) 619 wb_print((const void *)(up + 1), length); 620 else if (ISPORT(CISCO_AUTORP_PORT)) 621 cisco_autorp_print((const void *)(up + 1), length); 622 else if (ISPORT(RADIUS_PORT) || 623 ISPORT(RADIUS_NEW_PORT) || 624 ISPORT(RADIUS_ACCOUNTING_PORT) || 625 ISPORT(RADIUS_NEW_ACCOUNTING_PORT) ) 626 radius_print((const u_char *)(up+1), length); 627 else if (dport == HSRP_PORT) 628 hsrp_print((const u_char *)(up + 1), length); 629 else if (ISPORT(LWRES_PORT)) 630 lwres_print((const u_char *)(up + 1), length); 631 else if (ISPORT(LDP_PORT)) 632 ldp_print((const u_char *)(up + 1), length); 633 else if (ISPORT(OLSR_PORT)) 634 olsr_print((const u_char *)(up + 1), length, 635 #if INET6 636 (IP_V(ip) == 6) ? 1 : 0); 637 #else 638 0); 639 #endif 640 else if (ISPORT(MPLS_LSP_PING_PORT)) 641 lspping_print((const u_char *)(up + 1), length); 642 else if (dport == BFD_CONTROL_PORT || 643 dport == BFD_ECHO_PORT ) 644 bfd_print((const u_char *)(up+1), length, dport); 645 else if (ISPORT(LMP_PORT)) 646 lmp_print((const u_char *)(up + 1), length); 647 else if (ISPORT(VQP_PORT)) 648 vqp_print((const u_char *)(up + 1), length); 649 else if (ISPORT(SFLOW_PORT)) 650 sflow_print((const u_char *)(up + 1), length); 651 else if (dport == LWAPP_CONTROL_PORT) 652 lwapp_control_print((const u_char *)(up + 1), length, 1); 653 else if (sport == LWAPP_CONTROL_PORT) 654 lwapp_control_print((const u_char *)(up + 1), length, 0); 655 else if (ISPORT(LWAPP_DATA_PORT)) 656 lwapp_data_print((const u_char *)(up + 1), length); 657 else if (ISPORT(SIP_PORT)) 658 sip_print((const u_char *)(up + 1), length); 659 else if (ISPORT(SYSLOG_PORT)) 660 syslog_print((const u_char *)(up + 1), length); 661 else 662 (void)printf("UDP, length %u", 663 (u_int32_t)(ulen - sizeof(*up))); 664 #undef ISPORT 665 } else 666 (void)printf("UDP, length %u", (u_int32_t)(ulen - sizeof(*up))); 667 } 668 669 670 /* 671 * Local Variables: 672 * c-style: whitesmith 673 * c-basic-offset: 8 674 * End: 675 */ 676 677