1 /* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2000-2002 Maxim Krasnyansky <maxk (at) qualcomm.com> 6 * Copyright (C) 2003-2007 Marcel Holtmann <marcel (at) holtmann.org> 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * 23 */ 24 25 #ifdef HAVE_CONFIG_H 26 #include <config.h> 27 #endif 28 29 #include <stdio.h> 30 #include <errno.h> 31 #include <fcntl.h> 32 #include <unistd.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <getopt.h> 36 #include <sys/poll.h> 37 #include <sys/stat.h> 38 #include <sys/types.h> 39 #include <sys/ioctl.h> 40 #include <sys/socket.h> 41 42 #include <bluetooth/bluetooth.h> 43 #include <bluetooth/hci.h> 44 #include <bluetooth/hci_lib.h> 45 46 #include <arpa/inet.h> 47 #include <netinet/in.h> 48 #include <netdb.h> 49 50 #include "parser/parser.h" 51 #include "parser/sdp.h" 52 53 #if __BYTE_ORDER == __LITTLE_ENDIAN 54 static inline uint64_t ntoh64(uint64_t n) 55 { 56 uint64_t h; 57 uint64_t tmp = ntohl(n & 0x00000000ffffffff); 58 h = ntohl(n >> 32); 59 h |= tmp << 32; 60 return h; 61 } 62 #elif __BYTE_ORDER == __BIG_ENDIAN 63 #define ntoh64(x) (x) 64 #else 65 #error "Unknown byte order" 66 #endif 67 #define hton64(x) ntoh64(x) 68 69 #define SNAP_LEN HCI_MAX_FRAME_SIZE 70 #define DEFAULT_PORT "10839"; 71 72 /* Modes */ 73 enum { 74 PARSE, 75 READ, 76 WRITE, 77 RECEIVE, 78 SEND, 79 SERVER, 80 PPPDUMP, 81 AUDIO 82 }; 83 84 /* Default options */ 85 static int snap_len = SNAP_LEN; 86 static int mode = PARSE; 87 static int permcheck = 1; 88 static int noappend = 0; 89 static char *dump_file = NULL; 90 static char *pppdump_file = NULL; 91 static char *audio_file = NULL; 92 static char *dump_addr; 93 static char *dump_port = DEFAULT_PORT; 94 static int af = AF_UNSPEC; 95 96 struct hcidump_hdr { 97 uint16_t len; 98 uint8_t in; 99 uint8_t pad; 100 uint32_t ts_sec; 101 uint32_t ts_usec; 102 } __attribute__ ((packed)); 103 #define HCIDUMP_HDR_SIZE (sizeof(struct hcidump_hdr)) 104 105 struct btsnoop_hdr { 106 uint8_t id[8]; /* Identification Pattern */ 107 uint32_t version; /* Version Number = 1 */ 108 uint32_t type; /* Datalink Type */ 109 } __attribute__ ((packed)); 110 #define BTSNOOP_HDR_SIZE (sizeof(struct btsnoop_hdr)) 111 112 struct btsnoop_pkt { 113 uint32_t size; /* Original Length */ 114 uint32_t len; /* Included Length */ 115 uint32_t flags; /* Packet Flags */ 116 uint32_t drops; /* Cumulative Drops */ 117 uint64_t ts; /* Timestamp microseconds */ 118 uint8_t data[0]; /* Packet Data */ 119 } __attribute__ ((packed)); 120 #define BTSNOOP_PKT_SIZE (sizeof(struct btsnoop_pkt)) 121 122 static uint8_t btsnoop_id[] = { 0x62, 0x74, 0x73, 0x6e, 0x6f, 0x6f, 0x70, 0x00 }; 123 124 static uint32_t btsnoop_version = 0; 125 static uint32_t btsnoop_type = 0; 126 127 struct pktlog_hdr { 128 uint32_t len; 129 uint64_t ts; 130 uint8_t type; 131 } __attribute__ ((packed)); 132 #define PKTLOG_HDR_SIZE (sizeof(struct pktlog_hdr)) 133 134 static inline int read_n(int fd, char *buf, int len) 135 { 136 int t = 0, w; 137 138 while (len > 0) { 139 if ((w = read(fd, buf, len)) < 0) { 140 if (errno == EINTR || errno == EAGAIN) 141 continue; 142 return -1; 143 } 144 if (!w) 145 return 0; 146 len -= w; buf += w; t += w; 147 } 148 return t; 149 } 150 151 static inline int write_n(int fd, char *buf, int len) 152 { 153 int t = 0, w; 154 155 while (len > 0) { 156 if ((w = write(fd, buf, len)) < 0) { 157 if (errno == EINTR || errno == EAGAIN) 158 continue; 159 return -1; 160 } 161 if (!w) 162 return 0; 163 len -= w; buf += w; t += w; 164 } 165 return t; 166 } 167 168 static int process_frames(int dev, int sock, int fd, unsigned long flags) 169 { 170 struct cmsghdr *cmsg; 171 struct msghdr msg; 172 struct iovec iv; 173 struct hcidump_hdr *dh; 174 struct btsnoop_pkt *dp; 175 struct frame frm; 176 struct pollfd fds[2]; 177 int nfds = 0; 178 char *buf, *ctrl; 179 int len, hdr_size = HCIDUMP_HDR_SIZE; 180 181 if (sock < 0) 182 return -1; 183 184 if (mode == SERVER) 185 flags |= DUMP_BTSNOOP; 186 187 if (snap_len < SNAP_LEN) 188 snap_len = SNAP_LEN; 189 190 if (flags & DUMP_BTSNOOP) 191 hdr_size = BTSNOOP_PKT_SIZE; 192 193 buf = malloc(snap_len + hdr_size); 194 if (!buf) { 195 perror("Can't allocate data buffer"); 196 return -1; 197 } 198 199 dh = (void *) buf; 200 dp = (void *) buf; 201 frm.data = buf + hdr_size; 202 203 ctrl = malloc(100); 204 if (!ctrl) { 205 free(buf); 206 perror("Can't allocate control buffer"); 207 return -1; 208 } 209 210 if (dev == HCI_DEV_NONE) 211 printf("system: "); 212 else 213 printf("device: hci%d ", dev); 214 215 printf("snap_len: %d filter: 0x%lx\n", snap_len, parser.filter); 216 217 memset(&msg, 0, sizeof(msg)); 218 219 if (mode == SERVER) { 220 struct btsnoop_hdr *hdr = (void *) buf; 221 222 btsnoop_version = 1; 223 btsnoop_type = 1002; 224 225 memcpy(hdr->id, btsnoop_id, sizeof(btsnoop_id)); 226 hdr->version = htonl(btsnoop_version); 227 hdr->type = htonl(btsnoop_type); 228 229 printf("btsnoop version: %d datalink type: %d\n", 230 btsnoop_version, btsnoop_type); 231 232 len = write(fd, buf, BTSNOOP_HDR_SIZE); 233 if (len < 0) { 234 perror("Can't create dump header"); 235 return -1; 236 } 237 238 if (len != BTSNOOP_HDR_SIZE) { 239 fprintf(stderr, "Header size mismatch\n"); 240 return -1; 241 } 242 243 fds[nfds].fd = fd; 244 fds[nfds].events = POLLIN; 245 fds[nfds].revents = 0; 246 nfds++; 247 } 248 249 fds[nfds].fd = sock; 250 fds[nfds].events = POLLIN; 251 fds[nfds].revents = 0; 252 nfds++; 253 254 while (1) { 255 int i, n = poll(fds, nfds, -1); 256 if (n <= 0) 257 continue; 258 259 for (i = 0; i < nfds; i++) { 260 if (fds[i].revents & (POLLHUP | POLLERR | POLLNVAL)) { 261 if (fds[i].fd == sock) 262 printf("device: disconnected\n"); 263 else 264 printf("client: disconnect\n"); 265 return 0; 266 } 267 } 268 269 if (mode == SERVER) { 270 len = recv(fd, buf, snap_len, MSG_DONTWAIT); 271 if (len == 0) { 272 printf("client: disconnect\n"); 273 return 0; 274 } 275 if (len < 0 && errno != EAGAIN && errno != EINTR) { 276 perror("Connection read failure"); 277 return -1; 278 } 279 } 280 281 iv.iov_base = frm.data; 282 iv.iov_len = snap_len; 283 284 msg.msg_iov = &iv; 285 msg.msg_iovlen = 1; 286 msg.msg_control = ctrl; 287 msg.msg_controllen = 100; 288 289 len = recvmsg(sock, &msg, MSG_DONTWAIT); 290 if (len < 0) { 291 if (errno == EAGAIN || errno == EINTR) 292 continue; 293 perror("Receive failed"); 294 return -1; 295 } 296 297 /* Process control message */ 298 frm.data_len = len; 299 frm.dev_id = dev; 300 frm.in = 0; 301 frm.pppdump_fd = parser.pppdump_fd; 302 frm.audio_fd = parser.audio_fd; 303 304 cmsg = CMSG_FIRSTHDR(&msg); 305 while (cmsg) { 306 switch (cmsg->cmsg_type) { 307 case HCI_CMSG_DIR: 308 frm.in = *((int *) CMSG_DATA(cmsg)); 309 break; 310 case HCI_CMSG_TSTAMP: 311 frm.ts = *((struct timeval *) CMSG_DATA(cmsg)); 312 break; 313 } 314 cmsg = CMSG_NXTHDR(&msg, cmsg); 315 } 316 317 frm.ptr = frm.data; 318 frm.len = frm.data_len; 319 320 switch (mode) { 321 case WRITE: 322 case SEND: 323 case SERVER: 324 /* Save or send dump */ 325 if (flags & DUMP_BTSNOOP) { 326 uint64_t ts; 327 uint8_t pkt_type = ((uint8_t *) frm.data)[0]; 328 dp->size = htonl(frm.data_len); 329 dp->len = dp->size; 330 dp->flags = ntohl(frm.in & 0x01); 331 dp->drops = 0; 332 ts = (frm.ts.tv_sec - 946684800ll) * 1000000ll + frm.ts.tv_usec; 333 dp->ts = hton64(ts + 0x00E03AB44A676000ll); 334 if (pkt_type == HCI_COMMAND_PKT || 335 pkt_type == HCI_EVENT_PKT) 336 dp->flags |= ntohl(0x02); 337 } else { 338 dh->len = htobs(frm.data_len); 339 dh->in = frm.in; 340 dh->ts_sec = htobl(frm.ts.tv_sec); 341 dh->ts_usec = htobl(frm.ts.tv_usec); 342 } 343 344 if (write_n(fd, buf, frm.data_len + hdr_size) < 0) { 345 perror("Write error"); 346 return -1; 347 } 348 break; 349 350 default: 351 /* Parse and print */ 352 parse(&frm); 353 break; 354 } 355 } 356 357 return 0; 358 } 359 360 static void read_dump(int fd) 361 { 362 struct hcidump_hdr dh; 363 struct btsnoop_pkt dp; 364 struct pktlog_hdr ph; 365 struct frame frm; 366 uint8_t pkt_type; 367 int err; 368 369 frm.data = malloc(HCI_MAX_FRAME_SIZE); 370 if (!frm.data) { 371 perror("Can't allocate data buffer"); 372 exit(1); 373 } 374 375 while (1) { 376 if (parser.flags & DUMP_PKTLOG) 377 err = read_n(fd, (void *) &ph, PKTLOG_HDR_SIZE); 378 else if (parser.flags & DUMP_BTSNOOP) 379 err = read_n(fd, (void *) &dp, BTSNOOP_PKT_SIZE); 380 else 381 err = read_n(fd, (void *) &dh, HCIDUMP_HDR_SIZE); 382 383 if (err < 0) 384 goto failed; 385 if (!err) 386 return; 387 388 if (parser.flags & DUMP_PKTLOG) { 389 switch (ph.type) { 390 case 0x00: 391 ((uint8_t *) frm.data)[0] = HCI_COMMAND_PKT; 392 frm.in = 0; 393 break; 394 case 0x01: 395 ((uint8_t *) frm.data)[0] = HCI_EVENT_PKT; 396 frm.in = 1; 397 break; 398 case 0x02: 399 ((uint8_t *) frm.data)[0] = HCI_ACLDATA_PKT; 400 frm.in = 0; 401 break; 402 case 0x03: 403 ((uint8_t *) frm.data)[0] = HCI_ACLDATA_PKT; 404 frm.in = 1; 405 break; 406 default: 407 lseek(fd, ntohl(ph.len) - 9, SEEK_CUR); 408 continue; 409 } 410 411 frm.data_len = ntohl(ph.len) - 8; 412 err = read_n(fd, frm.data + 1, frm.data_len - 1); 413 } else if (parser.flags & DUMP_BTSNOOP) { 414 switch (btsnoop_type) { 415 case 1001: 416 if (ntohl(dp.flags) & 0x02) { 417 if (ntohl(dp.flags) & 0x01) 418 pkt_type = HCI_EVENT_PKT; 419 else 420 pkt_type = HCI_COMMAND_PKT; 421 } else 422 pkt_type = HCI_ACLDATA_PKT; 423 424 ((uint8_t *) frm.data)[0] = pkt_type; 425 426 frm.data_len = ntohl(dp.len) + 1; 427 err = read_n(fd, frm.data + 1, frm.data_len - 1); 428 break; 429 430 case 1002: 431 frm.data_len = ntohl(dp.len); 432 err = read_n(fd, frm.data, frm.data_len); 433 break; 434 } 435 } else { 436 frm.data_len = btohs(dh.len); 437 err = read_n(fd, frm.data, frm.data_len); 438 } 439 440 if (err < 0) 441 goto failed; 442 if (!err) 443 return; 444 445 frm.ptr = frm.data; 446 frm.len = frm.data_len; 447 448 if (parser.flags & DUMP_PKTLOG) { 449 uint64_t ts; 450 ts = ntoh64(ph.ts); 451 frm.ts.tv_sec = ts >> 32; 452 frm.ts.tv_usec = ts & 0xffffffff; 453 } else if (parser.flags & DUMP_BTSNOOP) { 454 uint64_t ts; 455 frm.in = ntohl(dp.flags) & 0x01; 456 ts = ntoh64(dp.ts) - 0x00E03AB44A676000ll; 457 frm.ts.tv_sec = (ts / 1000000ll) + 946684800ll; 458 frm.ts.tv_usec = ts % 1000000ll; 459 } else { 460 frm.in = dh.in; 461 frm.ts.tv_sec = btohl(dh.ts_sec); 462 frm.ts.tv_usec = btohl(dh.ts_usec); 463 } 464 465 parse(&frm); 466 } 467 468 failed: 469 perror("Read failed"); 470 exit(1); 471 } 472 473 static int open_file(char *file, int mode, unsigned long flags) 474 { 475 unsigned char buf[BTSNOOP_HDR_SIZE]; 476 struct btsnoop_hdr *hdr = (struct btsnoop_hdr *) buf; 477 int fd, len, open_flags; 478 479 if (mode == WRITE || mode == PPPDUMP || mode == AUDIO) { 480 if (noappend || flags & DUMP_BTSNOOP) 481 open_flags = O_WRONLY | O_CREAT | O_TRUNC; 482 else 483 open_flags = O_WRONLY | O_CREAT | O_APPEND; 484 } else 485 open_flags = O_RDONLY; 486 487 fd = open(file, open_flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); 488 if (fd < 0) { 489 perror("Can't open dump file"); 490 exit(1); 491 } 492 493 if (mode == READ) { 494 len = read(fd, buf, BTSNOOP_HDR_SIZE); 495 if (len != BTSNOOP_HDR_SIZE) { 496 lseek(fd, 0, SEEK_SET); 497 return fd; 498 } 499 500 if (!memcmp(hdr->id, btsnoop_id, sizeof(btsnoop_id))) { 501 parser.flags |= DUMP_BTSNOOP; 502 503 btsnoop_version = ntohl(hdr->version); 504 btsnoop_type = ntohl(hdr->type); 505 506 printf("btsnoop version: %d datalink type: %d\n", 507 btsnoop_version, btsnoop_type); 508 509 if (btsnoop_version != 1) { 510 fprintf(stderr, "Unsupported BTSnoop version\n"); 511 exit(1); 512 } 513 514 if (btsnoop_type != 1001 && btsnoop_type != 1002) { 515 fprintf(stderr, "Unsupported BTSnoop datalink type\n"); 516 exit(1); 517 } 518 } else { 519 if (buf[0] == 0x00 && buf[1] == 0x00) { 520 parser.flags |= DUMP_PKTLOG; 521 printf("packet logger data format\n"); 522 } 523 524 parser.flags &= ~DUMP_BTSNOOP; 525 lseek(fd, 0, SEEK_SET); 526 return fd; 527 } 528 } else { 529 if (flags & DUMP_BTSNOOP) { 530 btsnoop_version = 1; 531 btsnoop_type = 1002; 532 533 memcpy(hdr->id, btsnoop_id, sizeof(btsnoop_id)); 534 hdr->version = htonl(btsnoop_version); 535 hdr->type = htonl(btsnoop_type); 536 537 printf("btsnoop version: %d datalink type: %d\n", 538 btsnoop_version, btsnoop_type); 539 540 len = write(fd, buf, BTSNOOP_HDR_SIZE); 541 if (len < 0) { 542 perror("Can't create dump header"); 543 exit(1); 544 } 545 546 if (len != BTSNOOP_HDR_SIZE) { 547 fprintf(stderr, "Header size mismatch\n"); 548 exit(1); 549 } 550 } 551 } 552 553 return fd; 554 } 555 556 static int open_socket(int dev, unsigned long flags) 557 { 558 struct sockaddr_hci addr; 559 struct hci_filter flt; 560 struct hci_dev_info di; 561 int sk, dd, opt; 562 563 if (permcheck && dev != HCI_DEV_NONE) { 564 dd = hci_open_dev(dev); 565 if (dd < 0) { 566 perror("Can't open device"); 567 return -1; 568 } 569 570 if (hci_devinfo(dev, &di) < 0) { 571 perror("Can't get device info"); 572 return -1; 573 } 574 575 opt = hci_test_bit(HCI_RAW, &di.flags); 576 if (ioctl(dd, HCISETRAW, opt) < 0) { 577 if (errno == EACCES) { 578 perror("Can't access device"); 579 return -1; 580 } 581 } 582 583 hci_close_dev(dd); 584 } 585 586 /* Create HCI socket */ 587 sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 588 if (sk < 0) { 589 perror("Can't create raw socket"); 590 return -1; 591 } 592 593 opt = 1; 594 if (setsockopt(sk, SOL_HCI, HCI_DATA_DIR, &opt, sizeof(opt)) < 0) { 595 perror("Can't enable data direction info"); 596 return -1; 597 } 598 599 opt = 1; 600 if (setsockopt(sk, SOL_HCI, HCI_TIME_STAMP, &opt, sizeof(opt)) < 0) { 601 perror("Can't enable time stamp"); 602 return -1; 603 } 604 605 /* Setup filter */ 606 hci_filter_clear(&flt); 607 hci_filter_all_ptypes(&flt); 608 hci_filter_all_events(&flt); 609 if (setsockopt(sk, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) { 610 perror("Can't set filter"); 611 return -1; 612 } 613 614 /* Bind socket to the HCI device */ 615 addr.hci_family = AF_BLUETOOTH; 616 addr.hci_dev = dev; 617 if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 618 printf("Can't attach to device hci%d. %s(%d)\n", 619 dev, strerror(errno), errno); 620 return -1; 621 } 622 623 return sk; 624 } 625 626 static int open_connection(char *addr, char *port) 627 { 628 struct sockaddr_storage ss; 629 struct addrinfo hints, *res0, *res; 630 int sk = -1, opt = 1; 631 632 memset(&hints, 0, sizeof(hints)); 633 hints.ai_family = af; 634 hints.ai_socktype = SOCK_STREAM; 635 hints.ai_protocol = IPPROTO_TCP; 636 637 if (getaddrinfo(addr, port, &hints, &res0)) 638 if(getaddrinfo(NULL, port, &hints, &res0)) { 639 perror("getaddrinfo"); 640 exit(1); 641 } 642 643 for (res = res0; res; res = res->ai_next) { 644 sk = socket(res->ai_family, res->ai_socktype, res->ai_protocol); 645 if (sk < 0) { 646 if (res->ai_next) 647 continue; 648 649 perror("Can't create socket"); 650 freeaddrinfo(res0); 651 exit(1); 652 } 653 654 setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); 655 656 memcpy(&ss, res->ai_addr, res->ai_addrlen); 657 658 switch(ss.ss_family) { 659 case AF_INET: 660 ((struct sockaddr_in *) &ss)->sin_addr.s_addr = htonl(INADDR_ANY); 661 ((struct sockaddr_in *) &ss)->sin_port = 0; 662 break; 663 #ifdef HAS_INET6 664 case AF_INET6: 665 memcpy(&((struct sockaddr_in6 *) &ss)->sin6_addr, 666 &in6addr_any, sizeof(in6addr_any)); 667 ((struct sockaddr_in6 *) &ss)->sin6_port = 0; 668 break; 669 #endif 670 } 671 if (bind(sk, (struct sockaddr *) &ss, sizeof(ss)) < 0) { 672 perror("Can't bind socket"); 673 close(sk); 674 freeaddrinfo(res0); 675 exit(1); 676 } 677 678 if (connect(sk, res->ai_addr, res->ai_addrlen) < 0) { 679 perror("Can't connect socket"); 680 close(sk); 681 freeaddrinfo(res0); 682 exit(1); 683 } 684 } 685 686 freeaddrinfo(res0); 687 688 return sk; 689 } 690 691 static int create_datagram(unsigned short port) 692 { 693 struct sockaddr_in addr; 694 int sk, opt = 1; 695 696 sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); 697 if (sk < 0) 698 return -1; 699 700 if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) { 701 close(sk); 702 return -1; 703 } 704 705 memset(&addr, 0, sizeof(addr)); 706 addr.sin_family = AF_INET; 707 addr.sin_port = htons(port); 708 addr.sin_addr.s_addr = htonl(INADDR_BROADCAST); 709 710 if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 711 close(sk); 712 return -1; 713 } 714 715 return sk; 716 } 717 718 static unsigned char ping_data[] = { 'p', 'i', 'n', 'g' }; 719 static unsigned char pong_data[] = { 'p', 'o', 'n', 'g' }; 720 721 static void handle_datagram(int sk) 722 { 723 struct sockaddr_in addr; 724 socklen_t addr_len = sizeof(addr); 725 unsigned char buf[64]; 726 ssize_t len; 727 728 len = recvfrom(sk, buf, sizeof(buf), MSG_DONTWAIT, 729 (struct sockaddr *) &addr, &addr_len); 730 731 if (len != sizeof(ping_data)) 732 return; 733 734 if (memcmp(buf, ping_data, sizeof(ping_data)) != 0) 735 return; 736 737 len = sendto(sk, pong_data, sizeof(pong_data), 0, 738 (struct sockaddr *) &addr, sizeof(addr)); 739 } 740 741 static int wait_connection(char *addr, char *port) 742 { 743 char hname[100], hport[10]; 744 struct addrinfo *ai, *runp; 745 struct addrinfo hints; 746 struct pollfd fds[3]; 747 int err, opt, datagram, nfds = 0; 748 749 memset(&hints, 0, sizeof (hints)); 750 hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; 751 hints.ai_socktype = SOCK_STREAM; 752 hints.ai_protocol = IPPROTO_TCP; 753 754 err = getaddrinfo(dump_addr, dump_port, &hints, &ai); 755 if (err < 0) { 756 printf("Can't get address info: %s\n", gai_strerror(err)); 757 return -1; 758 } 759 760 runp = ai; 761 762 datagram = create_datagram(atoi(dump_port)); 763 if (datagram < 0) { 764 printf("server: no discover protocol\n"); 765 } else { 766 fds[nfds].fd = datagram; 767 fds[nfds].events = POLLIN; 768 nfds++; 769 } 770 771 while (runp != NULL && nfds < sizeof(fds) / sizeof(fds[0])) { 772 fds[nfds].fd = socket(runp->ai_family, runp->ai_socktype, 773 runp->ai_protocol); 774 if (fds[nfds].fd < 0) { 775 perror("Can't create socket"); 776 return -1; 777 } 778 779 fds[nfds].events = POLLIN; 780 781 opt = 1; 782 setsockopt(fds[nfds].fd, SOL_SOCKET, SO_REUSEADDR, 783 &opt, sizeof(opt)); 784 785 opt = 0; 786 setsockopt(fds[nfds].fd, SOL_SOCKET, SO_KEEPALIVE, 787 &opt, sizeof(opt)); 788 789 if (bind(fds[nfds].fd, runp->ai_addr, runp->ai_addrlen) < 0) { 790 if (errno != EADDRINUSE) { 791 perror("Can't bind socket"); 792 return -1; 793 } 794 795 close(fds[nfds].fd); 796 } else { 797 if (listen(fds[nfds].fd, SOMAXCONN) < 0) { 798 perror("Can't listen on socket"); 799 return -1; 800 } 801 802 getnameinfo(runp->ai_addr, runp->ai_addrlen, 803 hname, sizeof(hname), 804 hport, sizeof(hport), 805 NI_NUMERICSERV); 806 807 printf("server: %s:%s snap_len: %d filter: 0x%lx\n", 808 hname, hport, snap_len, parser.filter); 809 810 nfds++; 811 } 812 813 runp = runp->ai_next; 814 } 815 816 freeaddrinfo(ai); 817 818 while (1) { 819 int i, n = poll(fds, nfds, -1); 820 if (n <= 0) 821 continue; 822 823 for (i = 0; i < nfds; i++) { 824 struct sockaddr_storage rem; 825 socklen_t remlen = sizeof(rem); 826 int sk; 827 828 if (!(fds[i].revents & POLLIN)) 829 continue; 830 831 if (fds[i].fd == datagram) { 832 handle_datagram(datagram); 833 continue; 834 } 835 836 sk = accept(fds[i].fd, (struct sockaddr *) &rem, &remlen); 837 if (sk < 0) 838 continue; 839 840 getnameinfo((struct sockaddr *) &rem, remlen, 841 hname, sizeof(hname), 842 hport, sizeof(hport), 843 NI_NUMERICSERV); 844 845 printf("client: %s:%s snap_len: %d filter: 0x%lx\n", 846 hname, hport, snap_len, parser.filter); 847 848 for (n = 0; n < nfds; n++) 849 close(fds[n].fd); 850 851 return sk; 852 } 853 } 854 855 return -1; 856 } 857 858 static int run_server(int dev, char *addr, char *port, unsigned long flags) 859 { 860 while (1) { 861 int dd, sk; 862 863 sk = wait_connection(addr, port); 864 if (sk < 0) 865 continue; 866 867 //fcntl(sk, F_SETFL, O_NONBLOCK); 868 869 dd = open_socket(dev, flags); 870 if (dd < 0) { 871 close(sk); 872 continue; 873 } 874 875 process_frames(dev, dd, sk, flags); 876 877 close(dd); 878 close(sk); 879 } 880 881 return 0; 882 } 883 884 static struct { 885 char *name; 886 int flag; 887 } filters[] = { 888 { "lmp", FILT_LMP }, 889 { "hci", FILT_HCI }, 890 { "sco", FILT_SCO }, 891 { "l2cap", FILT_L2CAP }, 892 { "rfcomm", FILT_RFCOMM }, 893 { "sdp", FILT_SDP }, 894 { "bnep", FILT_BNEP }, 895 { "cmtp", FILT_CMTP }, 896 { "hidp", FILT_HIDP }, 897 { "hcrp", FILT_HCRP }, 898 { "avdtp", FILT_AVDTP }, 899 { "avctp", FILT_AVCTP }, 900 { "obex", FILT_OBEX }, 901 { "capi", FILT_CAPI }, 902 { "ppp", FILT_PPP }, 903 { "csr", FILT_CSR }, 904 { "dga", FILT_DGA }, 905 { 0 } 906 }; 907 908 static unsigned long parse_filter(int argc, char **argv) 909 { 910 unsigned long filter = 0; 911 int i,n; 912 913 for (i = 0; i < argc; i++) { 914 for (n = 0; filters[n].name; n++) { 915 if (!strcasecmp(filters[n].name, argv[i])) { 916 filter |= filters[n].flag; 917 break; 918 } 919 } 920 } 921 922 return filter; 923 } 924 925 static void usage(void) 926 { 927 printf( 928 "Usage: hcidump [OPTION...] [filter]\n" 929 " -i, --device=hci_dev HCI device\n" 930 " -l, --snap-len=len Snap len (in bytes)\n" 931 " -p, --psm=psm Default PSM\n" 932 " -m, --manufacturer=compid Default manufacturer\n" 933 " -w, --save-dump=file Save dump to a file\n" 934 " -r, --read-dump=file Read dump from a file\n" 935 " -s, --send-dump=host Send dump to a host\n" 936 " -n, --recv-dump=host Receive dump on a host\n" 937 " -d, --wait-dump=host Wait on a host and send\n" 938 " -t, --ts Display time stamps\n" 939 " -a, --ascii Dump data in ascii\n" 940 " -x, --hex Dump data in hex\n" 941 " -X, --ext Dump data in hex and ascii\n" 942 " -R, --raw Dump raw data\n" 943 " -C, --cmtp=psm PSM for CMTP\n" 944 " -H, --hcrp=psm PSM for HCRP\n" 945 " -O, --obex=channel Channel for OBEX\n" 946 " -P, --ppp=channel Channel for PPP\n" 947 " -D, --pppdump=file Extract PPP traffic\n" 948 " -A, --audio=file Extract SCO audio data\n" 949 " -B, --btsnoop Use BTSnoop file format\n" 950 " -V, --verbose Verbose decoding\n" 951 " -Y, --novendor No vendor commands or events\n" 952 " -N, --noappend No appending to existing files\n" 953 " -4, --ipv4 Use IPv4 as transport\n" 954 " -6 --ipv6 Use IPv6 as transport\n" 955 " -h, --help Give this help list\n" 956 " --usage Give a short usage message\n" 957 ); 958 } 959 960 static struct option main_options[] = { 961 { "device", 1, 0, 'i' }, 962 { "snap-len", 1, 0, 'l' }, 963 { "psm", 1, 0, 'p' }, 964 { "manufacturer", 1, 0, 'm' }, 965 { "save-dump", 1, 0, 'w' }, 966 { "read-dump", 1, 0, 'r' }, 967 { "send-dump", 1, 0, 's' }, 968 { "recv-dump", 1, 0, 'n' }, 969 { "wait-dump", 1, 0, 'd' }, 970 { "timestamp", 0, 0, 't' }, 971 { "ascii", 0, 0, 'a' }, 972 { "hex", 0, 0, 'x' }, 973 { "ext", 0, 0, 'X' }, 974 { "raw", 0, 0, 'R' }, 975 { "cmtp", 1, 0, 'C' }, 976 { "hcrp", 1, 0, 'H' }, 977 { "obex", 1, 0, 'O' }, 978 { "ppp", 1, 0, 'P' }, 979 { "pppdump", 1, 0, 'D' }, 980 { "audio", 1, 0, 'A' }, 981 { "btsnoop", 0, 0, 'B' }, 982 { "verbose", 0, 0, 'V' }, 983 { "novendor", 0, 0, 'Y' }, 984 { "nopermcheck", 0, 0, 'Z' }, 985 { "noappend", 0, 0, 'N' }, 986 { "ipv4", 0, 0, '4' }, 987 { "ipv6", 0, 0, '6' }, 988 { "help", 0, 0, 'h' }, 989 { 0 } 990 }; 991 992 int main(int argc, char *argv[]) 993 { 994 unsigned long flags = 0; 995 unsigned long filter = 0; 996 int device = 0; 997 int defpsm = 0; 998 int defcompid = DEFAULT_COMPID; 999 int opt, pppdump_fd = -1, audio_fd = -1; 1000 1001 printf("HCI sniffer - Bluetooth packet analyzer ver %s\n", VERSION); 1002 1003 while ((opt=getopt_long(argc, argv, "i:l:p:m:w:r:s:n:d:taxXRC:H:O:P:D:A:BVYZN46h", main_options, NULL)) != -1) { 1004 switch(opt) { 1005 case 'i': 1006 if (strcasecmp(optarg, "none") && strcasecmp(optarg, "system")) 1007 device = atoi(optarg + 3); 1008 else 1009 device = HCI_DEV_NONE; 1010 break; 1011 1012 case 'l': 1013 snap_len = atoi(optarg); 1014 break; 1015 1016 case 'p': 1017 defpsm = atoi(optarg); 1018 break; 1019 1020 case 'm': 1021 defcompid = atoi(optarg); 1022 break; 1023 1024 case 'w': 1025 mode = WRITE; 1026 dump_file = strdup(optarg); 1027 break; 1028 1029 case 'r': 1030 mode = READ; 1031 dump_file = strdup(optarg); 1032 break; 1033 1034 case 's': 1035 mode = SEND; 1036 dump_addr = optarg; 1037 break; 1038 1039 case 'n': 1040 mode = RECEIVE; 1041 dump_addr = optarg; 1042 break; 1043 1044 case 'd': 1045 mode = SERVER; 1046 dump_addr = optarg; 1047 break; 1048 1049 case 't': 1050 flags |= DUMP_TSTAMP; 1051 break; 1052 1053 case 'a': 1054 flags |= DUMP_ASCII; 1055 break; 1056 1057 case 'x': 1058 flags |= DUMP_HEX; 1059 break; 1060 1061 case 'X': 1062 flags |= DUMP_EXT; 1063 break; 1064 1065 case 'R': 1066 flags |= DUMP_RAW; 1067 break; 1068 1069 case 'C': 1070 set_proto(0, atoi(optarg), 0, SDP_UUID_CMTP); 1071 break; 1072 1073 case 'H': 1074 set_proto(0, atoi(optarg), 0, SDP_UUID_HARDCOPY_CONTROL_CHANNEL); 1075 break; 1076 1077 case 'O': 1078 set_proto(0, 0, atoi(optarg), SDP_UUID_OBEX); 1079 break; 1080 1081 case 'P': 1082 set_proto(0, 0, atoi(optarg), SDP_UUID_LAN_ACCESS_PPP); 1083 break; 1084 1085 case 'D': 1086 pppdump_file = strdup(optarg); 1087 break; 1088 1089 case 'A': 1090 audio_file = strdup(optarg); 1091 break; 1092 1093 case 'B': 1094 flags |= DUMP_BTSNOOP; 1095 break; 1096 1097 case 'V': 1098 flags |= DUMP_VERBOSE; 1099 break; 1100 1101 case 'Y': 1102 flags |= DUMP_NOVENDOR; 1103 break; 1104 1105 case 'Z': 1106 permcheck = 0; 1107 break; 1108 1109 case 'N': 1110 noappend = 1; 1111 break; 1112 1113 case '4': 1114 af = AF_INET; 1115 break; 1116 1117 case '6': 1118 af = AF_INET6; 1119 break; 1120 1121 case 'h': 1122 default: 1123 usage(); 1124 exit(0); 1125 } 1126 } 1127 1128 argc -= optind; 1129 argv += optind; 1130 optind = 0; 1131 1132 if (argc > 0) 1133 filter = parse_filter(argc, argv); 1134 1135 /* Default settings */ 1136 if (!filter) 1137 filter = ~0L; 1138 1139 if (pppdump_file) 1140 pppdump_fd = open_file(pppdump_file, PPPDUMP, flags); 1141 1142 if (audio_file) 1143 audio_fd = open_file(audio_file, AUDIO, flags); 1144 1145 switch (mode) { 1146 case PARSE: 1147 init_parser(flags, filter, defpsm, defcompid, pppdump_fd, audio_fd); 1148 process_frames(device, open_socket(device, flags), -1, flags); 1149 break; 1150 1151 case READ: 1152 init_parser(flags, filter, defpsm, defcompid, pppdump_fd, audio_fd); 1153 read_dump(open_file(dump_file, mode, flags)); 1154 break; 1155 1156 case WRITE: 1157 process_frames(device, open_socket(device, flags), 1158 open_file(dump_file, mode, flags), flags); 1159 break; 1160 1161 case RECEIVE: 1162 init_parser(flags, filter, defpsm, defcompid, pppdump_fd, audio_fd); 1163 read_dump(wait_connection(dump_addr, dump_port)); 1164 break; 1165 1166 case SEND: 1167 process_frames(device, open_socket(device, flags), 1168 open_connection(dump_addr, dump_port), flags); 1169 break; 1170 1171 case SERVER: 1172 init_parser(flags, filter, defpsm, defcompid, pppdump_fd, audio_fd); 1173 run_server(device, dump_addr, dump_port, flags); 1174 break; 1175 } 1176 1177 return 0; 1178 } 1179
