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
sig_hup(int sig)67 static void sig_hup(int sig)
68 {
69 }
70
sig_term(int sig)71 static void sig_term(int sig)
72 {
73 __io_canceled = 1;
74 }
75
l2cap_connect(bdaddr_t * src,bdaddr_t * dst,unsigned short psm)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
l2cap_listen(const bdaddr_t * bdaddr,unsigned short psm,int lm,int backlog)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
l2cap_accept(int sk,bdaddr_t * bdaddr)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
request_authentication(bdaddr_t * src,bdaddr_t * dst)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
request_encryption(bdaddr_t * src,bdaddr_t * dst)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
enable_sixaxis(int csk)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
create_device(int ctl,int csk,int isk,uint8_t subclass,int nosdp,int nocheck,int bootonly,int encrypt,int timeout)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
run_server(int ctl,int csk,int isk,uint8_t subclass,int nosdp,int nocheck,int bootonly,int encrypt,int timeout)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
hidp_flagstostr(uint32_t flags)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
do_show(int ctl)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
do_connect(int ctl,bdaddr_t * src,bdaddr_t * dst,uint8_t subclass,int fakehid,int bootonly,int encrypt,int timeout)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
do_search(int ctl,bdaddr_t * bdaddr,uint8_t subclass,int fakehid,int bootonly,int encrypt,int timeout)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
do_kill(int ctl,bdaddr_t * bdaddr,uint32_t flags)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
usage(void)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
main(int argc,char * argv[])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