compat/hidd.c

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