1 /* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2003-2010 Marcel Holtmann <marcel (at) holtmann.org> 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 21 * 22 */ 23 24 #ifdef HAVE_CONFIG_H 25 #include <config.h> 26 #endif 27 28 #define _GNU_SOURCE 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 <syslog.h> 36 #include <signal.h> 37 #include <getopt.h> 38 #include <sys/poll.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 #include <bluetooth/l2cap.h> 46 #include <bluetooth/sdp.h> 47 #include <bluetooth/hidp.h> 48 49 #include "sdp.h" 50 #include "hidd.h" 51 52 #ifdef NEED_PPOLL 53 #include "ppoll.h" 54 #endif 55 56 enum { 57 NONE, 58 SHOW, 59 SERVER, 60 SEARCH, 61 CONNECT, 62 KILL 63 }; 64 65 static volatile sig_atomic_t __io_canceled = 0; 66 67 static void sig_hup(int sig) 68 { 69 } 70 71 static void sig_term(int sig) 72 { 73 __io_canceled = 1; 74 } 75 76 static int l2cap_connect(bdaddr_t *src, bdaddr_t *dst, unsigned short psm) 77 { 78 struct sockaddr_l2 addr; 79 struct l2cap_options opts; 80 int sk; 81 82 if ((sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP)) < 0) 83 return -1; 84 85 memset(&addr, 0, sizeof(addr)); 86 addr.l2_family = AF_BLUETOOTH; 87 bacpy(&addr.l2_bdaddr, src); 88 89 if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 90 close(sk); 91 return -1; 92 } 93 94 memset(&opts, 0, sizeof(opts)); 95 opts.imtu = HIDP_DEFAULT_MTU; 96 opts.omtu = HIDP_DEFAULT_MTU; 97 opts.flush_to = 0xffff; 98 99 setsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, sizeof(opts)); 100 101 memset(&addr, 0, sizeof(addr)); 102 addr.l2_family = AF_BLUETOOTH; 103 bacpy(&addr.l2_bdaddr, dst); 104 addr.l2_psm = htobs(psm); 105 106 if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 107 close(sk); 108 return -1; 109 } 110 111 return sk; 112 } 113 114 static int l2cap_listen(const bdaddr_t *bdaddr, unsigned short psm, int lm, int backlog) 115 { 116 struct sockaddr_l2 addr; 117 struct l2cap_options opts; 118 int sk; 119 120 if ((sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP)) < 0) 121 return -1; 122 123 memset(&addr, 0, sizeof(addr)); 124 addr.l2_family = AF_BLUETOOTH; 125 bacpy(&addr.l2_bdaddr, bdaddr); 126 addr.l2_psm = htobs(psm); 127 128 if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 129 close(sk); 130 return -1; 131 } 132 133 setsockopt(sk, SOL_L2CAP, L2CAP_LM, &lm, sizeof(lm)); 134 135 memset(&opts, 0, sizeof(opts)); 136 opts.imtu = HIDP_DEFAULT_MTU; 137 opts.omtu = HIDP_DEFAULT_MTU; 138 opts.flush_to = 0xffff; 139 140 setsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, sizeof(opts)); 141 142 if (listen(sk, backlog) < 0) { 143 close(sk); 144 return -1; 145 } 146 147 return sk; 148 } 149 150 static int l2cap_accept(int sk, bdaddr_t *bdaddr) 151 { 152 struct sockaddr_l2 addr; 153 socklen_t addrlen; 154 int nsk; 155 156 memset(&addr, 0, sizeof(addr)); 157 addrlen = sizeof(addr); 158 159 if ((nsk = accept(sk, (struct sockaddr *) &addr, &addrlen)) < 0) 160 return -1; 161 162 if (bdaddr) 163 bacpy(bdaddr, &addr.l2_bdaddr); 164 165 return nsk; 166 } 167 168 static int request_authentication(bdaddr_t *src, bdaddr_t *dst) 169 { 170 struct hci_conn_info_req *cr; 171 char addr[18]; 172 int err, dd, dev_id; 173 174 ba2str(src, addr); 175 dev_id = hci_devid(addr); 176 if (dev_id < 0) 177 return dev_id; 178 179 dd = hci_open_dev(dev_id); 180 if (dd < 0) 181 return dd; 182 183 cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info)); 184 if (!cr) 185 return -ENOMEM; 186 187 bacpy(&cr->bdaddr, dst); 188 cr->type = ACL_LINK; 189 err = ioctl(dd, HCIGETCONNINFO, (unsigned long) cr); 190 if (err < 0) { 191 free(cr); 192 hci_close_dev(dd); 193 return err; 194 } 195 196 err = hci_authenticate_link(dd, htobs(cr->conn_info->handle), 25000); 197 198 free(cr); 199 hci_close_dev(dd); 200 201 return err; 202 } 203 204 static int request_encryption(bdaddr_t *src, bdaddr_t *dst) 205 { 206 struct hci_conn_info_req *cr; 207 char addr[18]; 208 int err, dd, dev_id; 209 210 ba2str(src, addr); 211 dev_id = hci_devid(addr); 212 if (dev_id < 0) 213 return dev_id; 214 215 dd = hci_open_dev(dev_id); 216 if (dd < 0) 217 return dd; 218 219 cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info)); 220 if (!cr) 221 return -ENOMEM; 222 223 bacpy(&cr->bdaddr, dst); 224 cr->type = ACL_LINK; 225 err = ioctl(dd, HCIGETCONNINFO, (unsigned long) cr); 226 if (err < 0) { 227 free(cr); 228 hci_close_dev(dd); 229 return err; 230 } 231 232 err = hci_encrypt_link(dd, htobs(cr->conn_info->handle), 1, 25000); 233 234 free(cr); 235 hci_close_dev(dd); 236 237 return err; 238 } 239 240 static void enable_sixaxis(int csk) 241 { 242 const unsigned char buf[] = { 243 0x53 /*HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE*/, 244 0xf4, 0x42, 0x03, 0x00, 0x00 }; 245 int err; 246 247 err = write(csk, buf, sizeof(buf)); 248 } 249 250 static int create_device(int ctl, int csk, int isk, uint8_t subclass, int nosdp, int nocheck, int bootonly, int encrypt, int timeout) 251 { 252 struct hidp_connadd_req req; 253 struct sockaddr_l2 addr; 254 socklen_t addrlen; 255 bdaddr_t src, dst; 256 char bda[18]; 257 int err; 258 259 memset(&addr, 0, sizeof(addr)); 260 addrlen = sizeof(addr); 261 262 if (getsockname(csk, (struct sockaddr *) &addr, &addrlen) < 0) 263 return -1; 264 265 bacpy(&src, &addr.l2_bdaddr); 266 267 memset(&addr, 0, sizeof(addr)); 268 addrlen = sizeof(addr); 269 270 if (getpeername(csk, (struct sockaddr *) &addr, &addrlen) < 0) 271 return -1; 272 273 bacpy(&dst, &addr.l2_bdaddr); 274 275 memset(&req, 0, sizeof(req)); 276 req.ctrl_sock = csk; 277 req.intr_sock = isk; 278 req.flags = 0; 279 req.idle_to = timeout * 60; 280 281 err = get_stored_device_info(&src, &dst, &req); 282 if (!err) 283 goto create; 284 285 if (!nocheck) { 286 ba2str(&dst, bda); 287 syslog(LOG_ERR, "Rejected connection from unknown device %s", bda); 288 /* Return no error to avoid run_server() complaining too */ 289 return 0; 290 } 291 292 if (!nosdp) { 293 err = get_sdp_device_info(&src, &dst, &req); 294 if (err < 0) 295 goto error; 296 } else { 297 struct l2cap_conninfo conn; 298 socklen_t size; 299 uint8_t class[3]; 300 301 memset(&conn, 0, sizeof(conn)); 302 size = sizeof(conn); 303 if (getsockopt(csk, SOL_L2CAP, L2CAP_CONNINFO, &conn, &size) < 0) 304 memset(class, 0, 3); 305 else 306 memcpy(class, conn.dev_class, 3); 307 308 if (class[1] == 0x25 && (class[2] == 0x00 || class[2] == 0x01)) 309 req.subclass = class[0]; 310 else 311 req.subclass = 0xc0; 312 } 313 314 create: 315 if (subclass != 0x00) 316 req.subclass = subclass; 317 318 ba2str(&dst, bda); 319 syslog(LOG_INFO, "New HID device %s (%s)", bda, req.name); 320 321 if (encrypt && (req.subclass & 0x40)) { 322 err = request_authentication(&src, &dst); 323 if (err < 0) { 324 syslog(LOG_ERR, "Authentication for %s failed", bda); 325 goto error; 326 } 327 328 err = request_encryption(&src, &dst); 329 if (err < 0) 330 syslog(LOG_ERR, "Encryption for %s failed", bda); 331 } 332 333 if (bootonly) { 334 req.rd_size = 0; 335 req.flags |= (1 << HIDP_BOOT_PROTOCOL_MODE); 336 } 337 338 if (req.vendor == 0x054c && req.product == 0x0268) 339 enable_sixaxis(csk); 340 341 err = ioctl(ctl, HIDPCONNADD, &req); 342 343 error: 344 if (req.rd_data) 345 free(req.rd_data); 346 347 return err; 348 } 349 350 static void run_server(int ctl, int csk, int isk, uint8_t subclass, int nosdp, int nocheck, int bootonly, int encrypt, int timeout) 351 { 352 struct pollfd p[2]; 353 sigset_t sigs; 354 short events; 355 int err, ncsk, nisk; 356 357 sigfillset(&sigs); 358 sigdelset(&sigs, SIGCHLD); 359 sigdelset(&sigs, SIGPIPE); 360 sigdelset(&sigs, SIGTERM); 361 sigdelset(&sigs, SIGINT); 362 sigdelset(&sigs, SIGHUP); 363 364 p[0].fd = csk; 365 p[0].events = POLLIN | POLLERR | POLLHUP; 366 367 p[1].fd = isk; 368 p[1].events = POLLIN | POLLERR | POLLHUP; 369 370 while (!__io_canceled) { 371 p[0].revents = 0; 372 p[1].revents = 0; 373 374 if (ppoll(p, 2, NULL, &sigs) < 1) 375 continue; 376 377 events = p[0].revents | p[1].revents; 378 379 if (events & POLLIN) { 380 ncsk = l2cap_accept(csk, NULL); 381 nisk = l2cap_accept(isk, NULL); 382 383 err = create_device(ctl, ncsk, nisk, subclass, nosdp, nocheck, bootonly, encrypt, timeout); 384 if (err < 0) 385 syslog(LOG_ERR, "HID create error %d (%s)", 386 errno, strerror(errno)); 387 388 close(nisk); 389 sleep(1); 390 close(ncsk); 391 } 392 } 393 } 394 395 static char *hidp_state[] = { 396 "unknown", 397 "connected", 398 "open", 399 "bound", 400 "listening", 401 "connecting", 402 "connecting", 403 "config", 404 "disconnecting", 405 "closed" 406 }; 407 408 static char *hidp_flagstostr(uint32_t flags) 409 { 410 static char str[100]; 411 str[0] = 0; 412 413 strcat(str, "["); 414 415 if (flags & (1 << HIDP_BOOT_PROTOCOL_MODE)) 416 strcat(str, "boot-protocol"); 417 418 strcat(str, "]"); 419 420 return str; 421 } 422 423 static void do_show(int ctl) 424 { 425 struct hidp_connlist_req req; 426 struct hidp_conninfo ci[16]; 427 char addr[18]; 428 unsigned int i; 429 430 req.cnum = 16; 431 req.ci = ci; 432 433 if (ioctl(ctl, HIDPGETCONNLIST, &req) < 0) { 434 perror("Can't get connection list"); 435 close(ctl); 436 exit(1); 437 } 438 439 for (i = 0; i < req.cnum; i++) { 440 ba2str(&ci[i].bdaddr, addr); 441 printf("%s %s [%04x:%04x] %s %s\n", addr, ci[i].name, 442 ci[i].vendor, ci[i].product, hidp_state[ci[i].state], 443 ci[i].flags ? hidp_flagstostr(ci[i].flags) : ""); 444 } 445 } 446 447 static void do_connect(int ctl, bdaddr_t *src, bdaddr_t *dst, uint8_t subclass, int fakehid, int bootonly, int encrypt, int timeout) 448 { 449 struct hidp_connadd_req req; 450 uint16_t uuid = HID_SVCLASS_ID; 451 uint8_t channel = 0; 452 char name[256]; 453 int csk, isk, err; 454 455 memset(&req, 0, sizeof(req)); 456 name[0] = '\0'; 457 458 err = get_sdp_device_info(src, dst, &req); 459 if (err < 0 && fakehid) 460 err = get_alternate_device_info(src, dst, 461 &uuid, &channel, name, sizeof(name) - 1); 462 463 if (err < 0) { 464 perror("Can't get device information"); 465 close(ctl); 466 exit(1); 467 } 468 469 switch (uuid) { 470 case HID_SVCLASS_ID: 471 goto connect; 472 473 case SERIAL_PORT_SVCLASS_ID: 474 if (subclass == 0x40 || !strcmp(name, "Cable Replacement")) { 475 if (epox_presenter(src, dst, channel) < 0) { 476 close(ctl); 477 exit(1); 478 } 479 break; 480 } 481 if (subclass == 0x1f || !strcmp(name, "SPP slave")) { 482 if (jthree_keyboard(src, dst, channel) < 0) { 483 close(ctl); 484 exit(1); 485 } 486 break; 487 } 488 if (subclass == 0x02 || !strcmp(name, "Serial Port")) { 489 if (celluon_keyboard(src, dst, channel) < 0) { 490 close(ctl); 491 exit(1); 492 } 493 break; 494 } 495 break; 496 497 case HEADSET_SVCLASS_ID: 498 case HANDSFREE_SVCLASS_ID: 499 if (headset_presenter(src, dst, channel) < 0) { 500 close(ctl); 501 exit(1); 502 } 503 break; 504 } 505 506 return; 507 508 connect: 509 csk = l2cap_connect(src, dst, L2CAP_PSM_HIDP_CTRL); 510 if (csk < 0) { 511 perror("Can't create HID control channel"); 512 close(ctl); 513 exit(1); 514 } 515 516 isk = l2cap_connect(src, dst, L2CAP_PSM_HIDP_INTR); 517 if (isk < 0) { 518 perror("Can't create HID interrupt channel"); 519 close(csk); 520 close(ctl); 521 exit(1); 522 } 523 524 err = create_device(ctl, csk, isk, subclass, 1, 1, bootonly, encrypt, timeout); 525 if (err < 0) { 526 fprintf(stderr, "HID create error %d (%s)\n", 527 errno, strerror(errno)); 528 close(isk); 529 sleep(1); 530 close(csk); 531 close(ctl); 532 exit(1); 533 } 534 } 535 536 static void do_search(int ctl, bdaddr_t *bdaddr, uint8_t subclass, int fakehid, int bootonly, int encrypt, int timeout) 537 { 538 inquiry_info *info = NULL; 539 bdaddr_t src, dst; 540 int i, dev_id, num_rsp, length, flags; 541 char addr[18]; 542 uint8_t class[3]; 543 544 ba2str(bdaddr, addr); 545 dev_id = hci_devid(addr); 546 if (dev_id < 0) { 547 dev_id = hci_get_route(NULL); 548 hci_devba(dev_id, &src); 549 } else 550 bacpy(&src, bdaddr); 551 552 length = 8; /* ~10 seconds */ 553 num_rsp = 0; 554 flags = IREQ_CACHE_FLUSH; 555 556 printf("Searching ...\n"); 557 558 num_rsp = hci_inquiry(dev_id, length, num_rsp, NULL, &info, flags); 559 560 for (i = 0; i < num_rsp; i++) { 561 memcpy(class, (info+i)->dev_class, 3); 562 if (class[1] == 0x25 && (class[2] == 0x00 || class[2] == 0x01)) { 563 bacpy(&dst, &(info+i)->bdaddr); 564 ba2str(&dst, addr); 565 566 printf("\tConnecting to device %s\n", addr); 567 do_connect(ctl, &src, &dst, subclass, fakehid, bootonly, encrypt, timeout); 568 } 569 } 570 571 if (!fakehid) 572 goto done; 573 574 for (i = 0; i < num_rsp; i++) { 575 memcpy(class, (info+i)->dev_class, 3); 576 if ((class[0] == 0x00 && class[2] == 0x00 && 577 (class[1] == 0x40 || class[1] == 0x1f)) || 578 (class[0] == 0x10 && class[1] == 0x02 && class[2] == 0x40)) { 579 bacpy(&dst, &(info+i)->bdaddr); 580 ba2str(&dst, addr); 581 582 printf("\tConnecting to device %s\n", addr); 583 do_connect(ctl, &src, &dst, subclass, 1, bootonly, 0, timeout); 584 } 585 } 586 587 done: 588 bt_free(info); 589 590 if (!num_rsp) { 591 fprintf(stderr, "\tNo devices in range or visible\n"); 592 close(ctl); 593 exit(1); 594 } 595 } 596 597 static void do_kill(int ctl, bdaddr_t *bdaddr, uint32_t flags) 598 { 599 struct hidp_conndel_req req; 600 struct hidp_connlist_req cl; 601 struct hidp_conninfo ci[16]; 602 unsigned int i; 603 604 if (!bacmp(bdaddr, BDADDR_ALL)) { 605 cl.cnum = 16; 606 cl.ci = ci; 607 608 if (ioctl(ctl, HIDPGETCONNLIST, &cl) < 0) { 609 perror("Can't get connection list"); 610 close(ctl); 611 exit(1); 612 } 613 614 for (i = 0; i < cl.cnum; i++) { 615 bacpy(&req.bdaddr, &ci[i].bdaddr); 616 req.flags = flags; 617 618 if (ioctl(ctl, HIDPCONNDEL, &req) < 0) { 619 perror("Can't release connection"); 620 close(ctl); 621 exit(1); 622 } 623 } 624 625 } else { 626 bacpy(&req.bdaddr, bdaddr); 627 req.flags = flags; 628 629 if (ioctl(ctl, HIDPCONNDEL, &req) < 0) { 630 perror("Can't release connection"); 631 close(ctl); 632 exit(1); 633 } 634 } 635 } 636 637 static void usage(void) 638 { 639 printf("hidd - Bluetooth HID daemon version %s\n\n", VERSION); 640 641 printf("Usage:\n" 642 "\thidd [options] [commands]\n" 643 "\n"); 644 645 printf("Options:\n" 646 "\t-i <hciX|bdaddr> Local HCI device or BD Address\n" 647 "\t-t <timeout> Set idle timeout (in minutes)\n" 648 "\t-b <subclass> Overwrite the boot mode subclass\n" 649 "\t-n, --nodaemon Don't fork daemon to background\n" 650 "\t-h, --help Display help\n" 651 "\n"); 652 653 printf("Commands:\n" 654 "\t--server Start HID server\n" 655 "\t--search Search for HID devices\n" 656 "\t--connect <bdaddr> Connect remote HID device\n" 657 "\t--unplug <bdaddr> Unplug the HID connection\n" 658 "\t--kill <bdaddr> Terminate HID connection\n" 659 "\t--killall Terminate all connections\n" 660 "\t--show List current HID connections\n" 661 "\n"); 662 } 663 664 static struct option main_options[] = { 665 { "help", 0, 0, 'h' }, 666 { "nodaemon", 0, 0, 'n' }, 667 { "subclass", 1, 0, 'b' }, 668 { "timeout", 1, 0, 't' }, 669 { "device", 1, 0, 'i' }, 670 { "master", 0, 0, 'M' }, 671 { "encrypt", 0, 0, 'E' }, 672 { "nosdp", 0, 0, 'D' }, 673 { "nocheck", 0, 0, 'Z' }, 674 { "bootonly", 0, 0, 'B' }, 675 { "hidonly", 0, 0, 'H' }, 676 { "show", 0, 0, 'l' }, 677 { "list", 0, 0, 'l' }, 678 { "server", 0, 0, 'd' }, 679 { "listen", 0, 0, 'd' }, 680 { "search", 0, 0, 's' }, 681 { "create", 1, 0, 'c' }, 682 { "connect", 1, 0, 'c' }, 683 { "disconnect", 1, 0, 'k' }, 684 { "terminate", 1, 0, 'k' }, 685 { "release", 1, 0, 'k' }, 686 { "kill", 1, 0, 'k' }, 687 { "killall", 0, 0, 'K' }, 688 { "unplug", 1, 0, 'u' }, 689 { 0, 0, 0, 0 } 690 }; 691 692 int main(int argc, char *argv[]) 693 { 694 struct sigaction sa; 695 bdaddr_t bdaddr, dev; 696 uint32_t flags = 0; 697 uint8_t subclass = 0x00; 698 char addr[18]; 699 int log_option = LOG_NDELAY | LOG_PID; 700 int opt, ctl, csk, isk; 701 int mode = SHOW, detach = 1, nosdp = 0, nocheck = 0, bootonly = 0; 702 int fakehid = 1, encrypt = 0, timeout = 30, lm = 0; 703 704 bacpy(&bdaddr, BDADDR_ANY); 705 706 while ((opt = getopt_long(argc, argv, "+i:nt:b:MEDZBHldsc:k:Ku:h", main_options, NULL)) != -1) { 707 switch(opt) { 708 case 'i': 709 if (!strncasecmp(optarg, "hci", 3)) 710 hci_devba(atoi(optarg + 3), &bdaddr); 711 else 712 str2ba(optarg, &bdaddr); 713 break; 714 case 'n': 715 detach = 0; 716 break; 717 case 't': 718 timeout = atoi(optarg); 719 break; 720 case 'b': 721 if (!strncasecmp(optarg, "0x", 2)) 722 subclass = (uint8_t) strtol(optarg, NULL, 16); 723 else 724 subclass = atoi(optarg); 725 break; 726 case 'M': 727 lm |= L2CAP_LM_MASTER; 728 break; 729 case 'E': 730 encrypt = 1; 731 break; 732 case 'D': 733 nosdp = 1; 734 break; 735 case 'Z': 736 nocheck = 1; 737 break; 738 case 'B': 739 bootonly = 1; 740 break; 741 case 'H': 742 fakehid = 0; 743 break; 744 case 'l': 745 mode = SHOW; 746 break; 747 case 'd': 748 mode = SERVER; 749 break; 750 case 's': 751 mode = SEARCH; 752 break; 753 case 'c': 754 str2ba(optarg, &dev); 755 mode = CONNECT; 756 break; 757 case 'k': 758 str2ba(optarg, &dev); 759 mode = KILL; 760 break; 761 case 'K': 762 bacpy(&dev, BDADDR_ALL); 763 mode = KILL; 764 break; 765 case 'u': 766 str2ba(optarg, &dev); 767 flags = (1 << HIDP_VIRTUAL_CABLE_UNPLUG); 768 mode = KILL; 769 break; 770 case 'h': 771 usage(); 772 exit(0); 773 default: 774 exit(0); 775 } 776 } 777 778 ba2str(&bdaddr, addr); 779 780 ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HIDP); 781 if (ctl < 0) { 782 perror("Can't open HIDP control socket"); 783 exit(1); 784 } 785 786 switch (mode) { 787 case SERVER: 788 csk = l2cap_listen(&bdaddr, L2CAP_PSM_HIDP_CTRL, lm, 10); 789 if (csk < 0) { 790 perror("Can't listen on HID control channel"); 791 close(ctl); 792 exit(1); 793 } 794 795 isk = l2cap_listen(&bdaddr, L2CAP_PSM_HIDP_INTR, lm, 10); 796 if (isk < 0) { 797 perror("Can't listen on HID interrupt channel"); 798 close(ctl); 799 close(csk); 800 exit(1); 801 } 802 break; 803 804 case SEARCH: 805 do_search(ctl, &bdaddr, subclass, fakehid, bootonly, encrypt, timeout); 806 close(ctl); 807 exit(0); 808 809 case CONNECT: 810 do_connect(ctl, &bdaddr, &dev, subclass, fakehid, bootonly, encrypt, timeout); 811 close(ctl); 812 exit(0); 813 814 case KILL: 815 do_kill(ctl, &dev, flags); 816 close(ctl); 817 exit(0); 818 819 default: 820 do_show(ctl); 821 close(ctl); 822 exit(0); 823 } 824 825 if (detach) { 826 if (daemon(0, 0)) { 827 perror("Can't start daemon"); 828 exit(1); 829 } 830 } else 831 log_option |= LOG_PERROR; 832 833 openlog("hidd", log_option, LOG_DAEMON); 834 835 if (bacmp(&bdaddr, BDADDR_ANY)) 836 syslog(LOG_INFO, "Bluetooth HID daemon (%s)", addr); 837 else 838 syslog(LOG_INFO, "Bluetooth HID daemon"); 839 840 memset(&sa, 0, sizeof(sa)); 841 sa.sa_flags = SA_NOCLDSTOP; 842 843 sa.sa_handler = sig_term; 844 sigaction(SIGTERM, &sa, NULL); 845 sigaction(SIGINT, &sa, NULL); 846 sa.sa_handler = sig_hup; 847 sigaction(SIGHUP, &sa, NULL); 848 849 sa.sa_handler = SIG_IGN; 850 sigaction(SIGCHLD, &sa, NULL); 851 sigaction(SIGPIPE, &sa, NULL); 852 853 run_server(ctl, csk, isk, subclass, nosdp, nocheck, bootonly, encrypt, timeout); 854 855 syslog(LOG_INFO, "Exit"); 856 857 close(csk); 858 close(isk); 859 close(ctl); 860 861 return 0; 862 } 863
