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 int 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 246 return write(csk, buf, sizeof(buf)); 247 } 248 249 static int create_device(int ctl, int csk, int isk, uint8_t subclass, int nosdp, int nocheck, int bootonly, int encrypt, int timeout) 250 { 251 struct hidp_connadd_req req; 252 struct sockaddr_l2 addr; 253 socklen_t addrlen; 254 bdaddr_t src, dst; 255 char bda[18]; 256 int err; 257 258 memset(&addr, 0, sizeof(addr)); 259 addrlen = sizeof(addr); 260 261 if (getsockname(csk, (struct sockaddr *) &addr, &addrlen) < 0) 262 return -1; 263 264 bacpy(&src, &addr.l2_bdaddr); 265 266 memset(&addr, 0, sizeof(addr)); 267 addrlen = sizeof(addr); 268 269 if (getpeername(csk, (struct sockaddr *) &addr, &addrlen) < 0) 270 return -1; 271 272 bacpy(&dst, &addr.l2_bdaddr); 273 274 memset(&req, 0, sizeof(req)); 275 req.ctrl_sock = csk; 276 req.intr_sock = isk; 277 req.flags = 0; 278 req.idle_to = timeout * 60; 279 280 err = get_stored_device_info(&src, &dst, &req); 281 if (!err) 282 goto create; 283 284 if (!nocheck) { 285 ba2str(&dst, bda); 286 syslog(LOG_ERR, "Rejected connection from unknown device %s", bda); 287 /* Return no error to avoid run_server() complaining too */ 288 return 0; 289 } 290 291 if (!nosdp) { 292 err = get_sdp_device_info(&src, &dst, &req); 293 if (err < 0) 294 goto error; 295 } else { 296 struct l2cap_conninfo conn; 297 socklen_t size; 298 uint8_t class[3]; 299 300 memset(&conn, 0, sizeof(conn)); 301 size = sizeof(conn); 302 if (getsockopt(csk, SOL_L2CAP, L2CAP_CONNINFO, &conn, &size) < 0) 303 memset(class, 0, 3); 304 else 305 memcpy(class, conn.dev_class, 3); 306 307 if (class[1] == 0x25 && (class[2] == 0x00 || class[2] == 0x01)) 308 req.subclass = class[0]; 309 else 310 req.subclass = 0xc0; 311 } 312 313 create: 314 if (subclass != 0x00) 315 req.subclass = subclass; 316 317 ba2str(&dst, bda); 318 syslog(LOG_INFO, "New HID device %s (%s)", bda, req.name); 319 320 if (encrypt && (req.subclass & 0x40)) { 321 err = request_authentication(&src, &dst); 322 if (err < 0) { 323 syslog(LOG_ERR, "Authentication for %s failed", bda); 324 goto error; 325 } 326 327 err = request_encryption(&src, &dst); 328 if (err < 0) 329 syslog(LOG_ERR, "Encryption for %s failed", bda); 330 } 331 332 if (bootonly) { 333 req.rd_size = 0; 334 req.flags |= (1 << HIDP_BOOT_PROTOCOL_MODE); 335 } 336 337 if (req.vendor == 0x054c && req.product == 0x0268) 338 enable_sixaxis(csk); 339 340 err = ioctl(ctl, HIDPCONNADD, &req); 341 342 error: 343 free(req.rd_data); 344 345 return err; 346 } 347 348 static void run_server(int ctl, int csk, int isk, uint8_t subclass, int nosdp, int nocheck, int bootonly, int encrypt, int timeout) 349 { 350 struct pollfd p[2]; 351 sigset_t sigs; 352 short events; 353 int err, ncsk, nisk; 354 355 sigfillset(&sigs); 356 sigdelset(&sigs, SIGCHLD); 357 sigdelset(&sigs, SIGPIPE); 358 sigdelset(&sigs, SIGTERM); 359 sigdelset(&sigs, SIGINT); 360 sigdelset(&sigs, SIGHUP); 361 362 p[0].fd = csk; 363 p[0].events = POLLIN | POLLERR | POLLHUP; 364 365 p[1].fd = isk; 366 p[1].events = POLLIN | POLLERR | POLLHUP; 367 368 while (!__io_canceled) { 369 p[0].revents = 0; 370 p[1].revents = 0; 371 372 if (ppoll(p, 2, NULL, &sigs) < 1) 373 continue; 374 375 events = p[0].revents | p[1].revents; 376 377 if (events & POLLIN) { 378 ncsk = l2cap_accept(csk, NULL); 379 nisk = l2cap_accept(isk, NULL); 380 381 err = create_device(ctl, ncsk, nisk, subclass, nosdp, nocheck, bootonly, encrypt, timeout); 382 if (err < 0) 383 syslog(LOG_ERR, "HID create error %d (%s)", 384 errno, strerror(errno)); 385 386 close(nisk); 387 sleep(1); 388 close(ncsk); 389 } 390 } 391 } 392 393 static char *hidp_state[] = { 394 "unknown", 395 "connected", 396 "open", 397 "bound", 398 "listening", 399 "connecting", 400 "connecting", 401 "config", 402 "disconnecting", 403 "closed" 404 }; 405 406 static char *hidp_flagstostr(uint32_t flags) 407 { 408 static char str[100]; 409 str[0] = 0; 410 411 strcat(str, "["); 412 413 if (flags & (1 << HIDP_BOOT_PROTOCOL_MODE)) 414 strcat(str, "boot-protocol"); 415 416 strcat(str, "]"); 417 418 return str; 419 } 420 421 static void do_show(int ctl) 422 { 423 struct hidp_connlist_req req; 424 struct hidp_conninfo ci[16]; 425 char addr[18]; 426 unsigned int i; 427 428 req.cnum = 16; 429 req.ci = ci; 430 431 if (ioctl(ctl, HIDPGETCONNLIST, &req) < 0) { 432 perror("Can't get connection list"); 433 close(ctl); 434 exit(1); 435 } 436 437 for (i = 0; i < req.cnum; i++) { 438 ba2str(&ci[i].bdaddr, addr); 439 printf("%s %s [%04x:%04x] %s %s\n", addr, ci[i].name, 440 ci[i].vendor, ci[i].product, hidp_state[ci[i].state], 441 ci[i].flags ? hidp_flagstostr(ci[i].flags) : ""); 442 } 443 } 444 445 static void do_connect(int ctl, bdaddr_t *src, bdaddr_t *dst, uint8_t subclass, int fakehid, int bootonly, int encrypt, int timeout) 446 { 447 struct hidp_connadd_req req; 448 uint16_t uuid = HID_SVCLASS_ID; 449 uint8_t channel = 0; 450 char name[256]; 451 int csk, isk, err; 452 453 memset(&req, 0, sizeof(req)); 454 name[0] = '\0'; 455 456 err = get_sdp_device_info(src, dst, &req); 457 if (err < 0 && fakehid) 458 err = get_alternate_device_info(src, dst, 459 &uuid, &channel, name, sizeof(name) - 1); 460 461 if (err < 0) { 462 perror("Can't get device information"); 463 close(ctl); 464 exit(1); 465 } 466 467 switch (uuid) { 468 case HID_SVCLASS_ID: 469 goto connect; 470 471 case SERIAL_PORT_SVCLASS_ID: 472 if (subclass == 0x40 || !strcmp(name, "Cable Replacement")) { 473 if (epox_presenter(src, dst, channel) < 0) { 474 close(ctl); 475 exit(1); 476 } 477 break; 478 } 479 if (subclass == 0x1f || !strcmp(name, "SPP slave")) { 480 if (jthree_keyboard(src, dst, channel) < 0) { 481 close(ctl); 482 exit(1); 483 } 484 break; 485 } 486 if (subclass == 0x02 || !strcmp(name, "Serial Port")) { 487 if (celluon_keyboard(src, dst, channel) < 0) { 488 close(ctl); 489 exit(1); 490 } 491 break; 492 } 493 break; 494 495 case HEADSET_SVCLASS_ID: 496 case HANDSFREE_SVCLASS_ID: 497 if (headset_presenter(src, dst, channel) < 0) { 498 close(ctl); 499 exit(1); 500 } 501 break; 502 } 503 504 return; 505 506 connect: 507 csk = l2cap_connect(src, dst, L2CAP_PSM_HIDP_CTRL); 508 if (csk < 0) { 509 perror("Can't create HID control channel"); 510 close(ctl); 511 exit(1); 512 } 513 514 isk = l2cap_connect(src, dst, L2CAP_PSM_HIDP_INTR); 515 if (isk < 0) { 516 perror("Can't create HID interrupt channel"); 517 close(csk); 518 close(ctl); 519 exit(1); 520 } 521 522 err = create_device(ctl, csk, isk, subclass, 1, 1, bootonly, encrypt, timeout); 523 if (err < 0) { 524 fprintf(stderr, "HID create error %d (%s)\n", 525 errno, strerror(errno)); 526 close(isk); 527 sleep(1); 528 close(csk); 529 close(ctl); 530 exit(1); 531 } 532 } 533 534 static void do_search(int ctl, bdaddr_t *bdaddr, uint8_t subclass, int fakehid, int bootonly, int encrypt, int timeout) 535 { 536 inquiry_info *info = NULL; 537 bdaddr_t src, dst; 538 int i, dev_id, num_rsp, length, flags; 539 char addr[18]; 540 uint8_t class[3]; 541 542 ba2str(bdaddr, addr); 543 dev_id = hci_devid(addr); 544 if (dev_id < 0) { 545 dev_id = hci_get_route(NULL); 546 hci_devba(dev_id, &src); 547 } else 548 bacpy(&src, bdaddr); 549 550 length = 8; /* ~10 seconds */ 551 num_rsp = 0; 552 flags = IREQ_CACHE_FLUSH; 553 554 printf("Searching ...\n"); 555 556 num_rsp = hci_inquiry(dev_id, length, num_rsp, NULL, &info, flags); 557 558 for (i = 0; i < num_rsp; i++) { 559 memcpy(class, (info+i)->dev_class, 3); 560 if (class[1] == 0x25 && (class[2] == 0x00 || class[2] == 0x01)) { 561 bacpy(&dst, &(info+i)->bdaddr); 562 ba2str(&dst, addr); 563 564 printf("\tConnecting to device %s\n", addr); 565 do_connect(ctl, &src, &dst, subclass, fakehid, bootonly, encrypt, timeout); 566 } 567 } 568 569 if (!fakehid) 570 goto done; 571 572 for (i = 0; i < num_rsp; i++) { 573 memcpy(class, (info+i)->dev_class, 3); 574 if ((class[0] == 0x00 && class[2] == 0x00 && 575 (class[1] == 0x40 || class[1] == 0x1f)) || 576 (class[0] == 0x10 && class[1] == 0x02 && class[2] == 0x40)) { 577 bacpy(&dst, &(info+i)->bdaddr); 578 ba2str(&dst, addr); 579 580 printf("\tConnecting to device %s\n", addr); 581 do_connect(ctl, &src, &dst, subclass, 1, bootonly, 0, timeout); 582 } 583 } 584 585 done: 586 bt_free(info); 587 588 if (!num_rsp) { 589 fprintf(stderr, "\tNo devices in range or visible\n"); 590 close(ctl); 591 exit(1); 592 } 593 } 594 595 static void do_kill(int ctl, bdaddr_t *bdaddr, uint32_t flags) 596 { 597 struct hidp_conndel_req req; 598 struct hidp_connlist_req cl; 599 struct hidp_conninfo ci[16]; 600 unsigned int i; 601 602 if (!bacmp(bdaddr, BDADDR_ALL)) { 603 cl.cnum = 16; 604 cl.ci = ci; 605 606 if (ioctl(ctl, HIDPGETCONNLIST, &cl) < 0) { 607 perror("Can't get connection list"); 608 close(ctl); 609 exit(1); 610 } 611 612 for (i = 0; i < cl.cnum; i++) { 613 bacpy(&req.bdaddr, &ci[i].bdaddr); 614 req.flags = flags; 615 616 if (ioctl(ctl, HIDPCONNDEL, &req) < 0) { 617 perror("Can't release connection"); 618 close(ctl); 619 exit(1); 620 } 621 } 622 623 } else { 624 bacpy(&req.bdaddr, bdaddr); 625 req.flags = flags; 626 627 if (ioctl(ctl, HIDPCONNDEL, &req) < 0) { 628 perror("Can't release connection"); 629 close(ctl); 630 exit(1); 631 } 632 } 633 } 634 635 static void usage(void) 636 { 637 printf("hidd - Bluetooth HID daemon version %s\n\n", VERSION); 638 639 printf("Usage:\n" 640 "\thidd [options] [commands]\n" 641 "\n"); 642 643 printf("Options:\n" 644 "\t-i <hciX|bdaddr> Local HCI device or BD Address\n" 645 "\t-t <timeout> Set idle timeout (in minutes)\n" 646 "\t-b <subclass> Overwrite the boot mode subclass\n" 647 "\t-n, --nodaemon Don't fork daemon to background\n" 648 "\t-h, --help Display help\n" 649 "\n"); 650 651 printf("Commands:\n" 652 "\t--server Start HID server\n" 653 "\t--search Search for HID devices\n" 654 "\t--connect <bdaddr> Connect remote HID device\n" 655 "\t--unplug <bdaddr> Unplug the HID connection\n" 656 "\t--kill <bdaddr> Terminate HID connection\n" 657 "\t--killall Terminate all connections\n" 658 "\t--show List current HID connections\n" 659 "\n"); 660 } 661 662 static struct option main_options[] = { 663 { "help", 0, 0, 'h' }, 664 { "nodaemon", 0, 0, 'n' }, 665 { "subclass", 1, 0, 'b' }, 666 { "timeout", 1, 0, 't' }, 667 { "device", 1, 0, 'i' }, 668 { "master", 0, 0, 'M' }, 669 { "encrypt", 0, 0, 'E' }, 670 { "nosdp", 0, 0, 'D' }, 671 { "nocheck", 0, 0, 'Z' }, 672 { "bootonly", 0, 0, 'B' }, 673 { "hidonly", 0, 0, 'H' }, 674 { "show", 0, 0, 'l' }, 675 { "list", 0, 0, 'l' }, 676 { "server", 0, 0, 'd' }, 677 { "listen", 0, 0, 'd' }, 678 { "search", 0, 0, 's' }, 679 { "create", 1, 0, 'c' }, 680 { "connect", 1, 0, 'c' }, 681 { "disconnect", 1, 0, 'k' }, 682 { "terminate", 1, 0, 'k' }, 683 { "release", 1, 0, 'k' }, 684 { "kill", 1, 0, 'k' }, 685 { "killall", 0, 0, 'K' }, 686 { "unplug", 1, 0, 'u' }, 687 { 0, 0, 0, 0 } 688 }; 689 690 int main(int argc, char *argv[]) 691 { 692 struct sigaction sa; 693 bdaddr_t bdaddr, dev; 694 uint32_t flags = 0; 695 uint8_t subclass = 0x00; 696 char addr[18]; 697 int log_option = LOG_NDELAY | LOG_PID; 698 int opt, ctl, csk, isk; 699 int mode = SHOW, detach = 1, nosdp = 0, nocheck = 0, bootonly = 0; 700 int fakehid = 1, encrypt = 0, timeout = 30, lm = 0; 701 702 bacpy(&bdaddr, BDADDR_ANY); 703 704 while ((opt = getopt_long(argc, argv, "+i:nt:b:MEDZBHldsc:k:Ku:h", main_options, NULL)) != -1) { 705 switch(opt) { 706 case 'i': 707 if (!strncasecmp(optarg, "hci", 3)) 708 hci_devba(atoi(optarg + 3), &bdaddr); 709 else 710 str2ba(optarg, &bdaddr); 711 break; 712 case 'n': 713 detach = 0; 714 break; 715 case 't': 716 timeout = atoi(optarg); 717 break; 718 case 'b': 719 if (!strncasecmp(optarg, "0x", 2)) 720 subclass = (uint8_t) strtol(optarg, NULL, 16); 721 else 722 subclass = atoi(optarg); 723 break; 724 case 'M': 725 lm |= L2CAP_LM_MASTER; 726 break; 727 case 'E': 728 encrypt = 1; 729 break; 730 case 'D': 731 nosdp = 1; 732 break; 733 case 'Z': 734 nocheck = 1; 735 break; 736 case 'B': 737 bootonly = 1; 738 break; 739 case 'H': 740 fakehid = 0; 741 break; 742 case 'l': 743 mode = SHOW; 744 break; 745 case 'd': 746 mode = SERVER; 747 break; 748 case 's': 749 mode = SEARCH; 750 break; 751 case 'c': 752 str2ba(optarg, &dev); 753 mode = CONNECT; 754 break; 755 case 'k': 756 str2ba(optarg, &dev); 757 mode = KILL; 758 break; 759 case 'K': 760 bacpy(&dev, BDADDR_ALL); 761 mode = KILL; 762 break; 763 case 'u': 764 str2ba(optarg, &dev); 765 flags = (1 << HIDP_VIRTUAL_CABLE_UNPLUG); 766 mode = KILL; 767 break; 768 case 'h': 769 usage(); 770 exit(0); 771 default: 772 exit(0); 773 } 774 } 775 776 ba2str(&bdaddr, addr); 777 778 ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HIDP); 779 if (ctl < 0) { 780 perror("Can't open HIDP control socket"); 781 exit(1); 782 } 783 784 switch (mode) { 785 case SERVER: 786 csk = l2cap_listen(&bdaddr, L2CAP_PSM_HIDP_CTRL, lm, 10); 787 if (csk < 0) { 788 perror("Can't listen on HID control channel"); 789 close(ctl); 790 exit(1); 791 } 792 793 isk = l2cap_listen(&bdaddr, L2CAP_PSM_HIDP_INTR, lm, 10); 794 if (isk < 0) { 795 perror("Can't listen on HID interrupt channel"); 796 close(ctl); 797 close(csk); 798 exit(1); 799 } 800 break; 801 802 case SEARCH: 803 do_search(ctl, &bdaddr, subclass, fakehid, bootonly, encrypt, timeout); 804 close(ctl); 805 exit(0); 806 807 case CONNECT: 808 do_connect(ctl, &bdaddr, &dev, subclass, fakehid, bootonly, encrypt, timeout); 809 close(ctl); 810 exit(0); 811 812 case KILL: 813 do_kill(ctl, &dev, flags); 814 close(ctl); 815 exit(0); 816 817 default: 818 do_show(ctl); 819 close(ctl); 820 exit(0); 821 } 822 823 if (detach) { 824 if (daemon(0, 0)) { 825 perror("Can't start daemon"); 826 exit(1); 827 } 828 } else 829 log_option |= LOG_PERROR; 830 831 openlog("hidd", log_option, LOG_DAEMON); 832 833 if (bacmp(&bdaddr, BDADDR_ANY)) 834 syslog(LOG_INFO, "Bluetooth HID daemon (%s)", addr); 835 else 836 syslog(LOG_INFO, "Bluetooth HID daemon"); 837 838 memset(&sa, 0, sizeof(sa)); 839 sa.sa_flags = SA_NOCLDSTOP; 840 841 sa.sa_handler = sig_term; 842 sigaction(SIGTERM, &sa, NULL); 843 sigaction(SIGINT, &sa, NULL); 844 sa.sa_handler = sig_hup; 845 sigaction(SIGHUP, &sa, NULL); 846 847 sa.sa_handler = SIG_IGN; 848 sigaction(SIGCHLD, &sa, NULL); 849 sigaction(SIGPIPE, &sa, NULL); 850 851 run_server(ctl, csk, isk, subclass, nosdp, nocheck, bootonly, encrypt, timeout); 852 853 syslog(LOG_INFO, "Exit"); 854 855 close(csk); 856 close(isk); 857 close(ctl); 858 859 return 0; 860 } 861
