hciops.c revision 90608519f3701763ca00b27d6ae133d6bbb07bad 
1/*
2 *
3 *  BlueZ - Bluetooth protocol stack for Linux
4 *
5 *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
6 *
7 *  This program is free software; you can redistribute it and/or modify
8 *  it under the terms of the GNU General Public License as published by
9 *  the Free Software Foundation; either version 2 of the License, or
10 *  (at your option) any later version.
11 *
12 *  This program is distributed in the hope that it will be useful,
13 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 *  GNU General Public License for more details.
16 *
17 *  You should have received a copy of the GNU General Public License
18 *  along with this program; if not, write to the Free Software
19 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 *
21 */
22
23#ifdef HAVE_CONFIG_H
24#include <config.h>
25#endif
26
27#include <stdio.h>
28#include <errno.h>
29#include <unistd.h>
30#include <stdlib.h>
31#include <sys/types.h>
32#include <sys/ioctl.h>
33#include <sys/wait.h>
34
35#include <bluetooth/bluetooth.h>
36#include <bluetooth/hci.h>
37#include <bluetooth/hci_lib.h>
38
39#include <glib.h>
40
41#include "hcid.h"
42#include "sdpd.h"
43#include "adapter.h"
44#include "plugin.h"
45#include "log.h"
46#include "manager.h"
47
48static int child_pipe[2] = { -1, -1 };
49
50static guint child_io_id = 0;
51static guint ctl_io_id = 0;
52
53static gboolean child_exit(GIOChannel *io, GIOCondition cond, void *user_data)
54{
55	int status, fd = g_io_channel_unix_get_fd(io);
56	pid_t child_pid;
57
58	if (read(fd, &child_pid, sizeof(child_pid)) != sizeof(child_pid)) {
59		error("child_exit: unable to read child pid from pipe");
60		return TRUE;
61	}
62
63	if (waitpid(child_pid, &status, 0) != child_pid)
64		error("waitpid(%d) failed", child_pid);
65	else
66		DBG("child %d exited", child_pid);
67
68	return TRUE;
69}
70
71static void at_child_exit(void)
72{
73	pid_t pid = getpid();
74
75	if (write(child_pipe[1], &pid, sizeof(pid)) != sizeof(pid))
76		error("unable to write to child pipe");
77}
78
79static void configure_device(int index)
80{
81	struct hci_dev_info di;
82	uint16_t policy;
83	int dd, err;
84
85	if (hci_devinfo(index, &di) < 0)
86		return;
87
88	if (hci_test_bit(HCI_RAW, &di.flags))
89		return;
90
91	dd = hci_open_dev(index);
92	if (dd < 0) {
93		err = errno;
94		error("Can't open device hci%d: %s (%d)",
95						index, strerror(err), err);
96		return;
97	}
98
99	/* Set page timeout */
100	if ((main_opts.flags & (1 << HCID_SET_PAGETO))) {
101		write_page_timeout_cp cp;
102
103		cp.timeout = htobs(main_opts.pageto);
104		hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_PAGE_TIMEOUT,
105					WRITE_PAGE_TIMEOUT_CP_SIZE, &cp);
106	}
107
108	/* Set default link policy */
109	policy = htobs(main_opts.link_policy);
110	hci_send_cmd(dd, OGF_LINK_POLICY,
111				OCF_WRITE_DEFAULT_LINK_POLICY, 2, &policy);
112
113	hci_close_dev(dd);
114}
115
116static void init_device(int index)
117{
118	struct hci_dev_req dr;
119	struct hci_dev_info di;
120	pid_t pid;
121	int dd, err;
122
123	/* Do initialization in the separate process */
124	pid = fork();
125	switch (pid) {
126		case 0:
127			atexit(at_child_exit);
128			break;
129		case -1:
130			err = errno;
131			error("Fork failed. Can't init device hci%d: %s (%d)",
132					index, strerror(err), err);
133		default:
134			DBG("child %d forked", pid);
135			return;
136	}
137
138	dd = hci_open_dev(index);
139	if (dd < 0) {
140		err = errno;
141		error("Can't open device hci%d: %s (%d)",
142					index, strerror(err), err);
143		exit(1);
144	}
145
146	memset(&dr, 0, sizeof(dr));
147	dr.dev_id = index;
148
149	/* Set link mode */
150	dr.dev_opt = main_opts.link_mode;
151	if (ioctl(dd, HCISETLINKMODE, (unsigned long) &dr) < 0) {
152		err = errno;
153		error("Can't set link mode on hci%d: %s (%d)",
154					index, strerror(err), err);
155	}
156
157	/* Set link policy */
158	dr.dev_opt = main_opts.link_policy;
159	if (ioctl(dd, HCISETLINKPOL, (unsigned long) &dr) < 0 &&
160							errno != ENETDOWN) {
161		error("Can't set link policy on hci%d: %s (%d)",
162					index, strerror(errno), errno);
163	}
164
165	/* Start HCI device */
166	if (ioctl(dd, HCIDEVUP, index) < 0 && errno != EALREADY) {
167		error("Can't init device hci%d: %s (%d)",
168					index, strerror(errno), errno);
169		goto fail;
170	}
171
172	if (hci_devinfo(index, &di) < 0)
173		goto fail;
174
175	if (hci_test_bit(HCI_RAW, &di.flags))
176		goto done;
177
178done:
179	hci_close_dev(dd);
180	exit(0);
181
182fail:
183	hci_close_dev(dd);
184	exit(1);
185}
186
187static void device_devreg_setup(int index)
188{
189	struct hci_dev_info di;
190	gboolean devup;
191
192	init_device(index);
193
194	memset(&di, 0, sizeof(di));
195
196	if (hci_devinfo(index, &di) < 0)
197		return;
198
199	devup = hci_test_bit(HCI_UP, &di.flags);
200
201	if (!hci_test_bit(HCI_RAW, &di.flags))
202		manager_register_adapter(index, devup);
203}
204
205static void device_devup_setup(int index)
206{
207	configure_device(index);
208
209	start_security_manager(index);
210
211	/* Return value 1 means ioctl(DEVDOWN) was performed */
212	if (manager_start_adapter(index) == 1)
213		stop_security_manager(index);
214}
215
216static void device_event(int event, int index)
217{
218	switch (event) {
219	case HCI_DEV_REG:
220		info("HCI dev %d registered", index);
221		device_devreg_setup(index);
222		break;
223
224	case HCI_DEV_UNREG:
225		info("HCI dev %d unregistered", index);
226		manager_unregister_adapter(index);
227		break;
228
229	case HCI_DEV_UP:
230		info("HCI dev %d up", index);
231		device_devup_setup(index);
232		break;
233
234	case HCI_DEV_DOWN:
235		info("HCI dev %d down", index);
236		manager_stop_adapter(index);
237		stop_security_manager(index);
238		break;
239	}
240}
241
242static int init_known_adapters(int ctl)
243{
244	struct hci_dev_list_req *dl;
245	struct hci_dev_req *dr;
246	int i, err;
247
248	dl = g_try_malloc0(HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t));
249	if (!dl) {
250		err = errno;
251		error("Can't allocate devlist buffer: %s (%d)",
252							strerror(err), err);
253		return -err;
254	}
255
256	dl->dev_num = HCI_MAX_DEV;
257	dr = dl->dev_req;
258
259	if (ioctl(ctl, HCIGETDEVLIST, (void *) dl) < 0) {
260		err = errno;
261		error("Can't get device list: %s (%d)",
262							strerror(err), err);
263		g_free(dl);
264		return -err;
265	}
266
267	for (i = 0; i < dl->dev_num; i++, dr++) {
268		device_event(HCI_DEV_REG, dr->dev_id);
269
270		if (hci_test_bit(HCI_UP, &dr->dev_opt))
271			device_event(HCI_DEV_UP, dr->dev_id);
272	}
273
274	g_free(dl);
275	return 0;
276}
277
278static gboolean io_stack_event(GIOChannel *chan, GIOCondition cond,
279								gpointer data)
280{
281	unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr;
282	evt_stack_internal *si;
283	evt_si_device *sd;
284	hci_event_hdr *eh;
285	int type;
286	size_t len;
287	GIOError err;
288
289	ptr = buf;
290
291	err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len);
292	if (err) {
293		if (err == G_IO_ERROR_AGAIN)
294			return TRUE;
295
296		error("Read from control socket failed: %s (%d)",
297							strerror(errno), errno);
298		return FALSE;
299	}
300
301	type = *ptr++;
302
303	if (type != HCI_EVENT_PKT)
304		return TRUE;
305
306	eh = (hci_event_hdr *) ptr;
307	if (eh->evt != EVT_STACK_INTERNAL)
308		return TRUE;
309
310	ptr += HCI_EVENT_HDR_SIZE;
311
312	si = (evt_stack_internal *) ptr;
313	switch (si->type) {
314	case EVT_SI_DEVICE:
315		sd = (void *) &si->data;
316		device_event(sd->event, sd->dev_id);
317		break;
318	}
319
320	return TRUE;
321}
322
323static int hciops_setup(void)
324{
325	struct sockaddr_hci addr;
326	struct hci_filter flt;
327	GIOChannel *ctl_io, *child_io;
328	int sock, err;
329
330	if (child_pipe[0] != -1)
331		return -EALREADY;
332
333	if (pipe(child_pipe) < 0) {
334		err = errno;
335		error("pipe(): %s (%d)", strerror(err), err);
336		return -err;
337	}
338
339	child_io = g_io_channel_unix_new(child_pipe[0]);
340	g_io_channel_set_close_on_unref(child_io, TRUE);
341	child_io_id = g_io_add_watch(child_io,
342				G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
343				child_exit, NULL);
344	g_io_channel_unref(child_io);
345
346	/* Create and bind HCI socket */
347	sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
348	if (sock < 0) {
349		err = errno;
350		error("Can't open HCI socket: %s (%d)", strerror(err),
351								err);
352		return -err;
353	}
354
355	/* Set filter */
356	hci_filter_clear(&flt);
357	hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
358	hci_filter_set_event(EVT_STACK_INTERNAL, &flt);
359	if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt,
360							sizeof(flt)) < 0) {
361		err = errno;
362		error("Can't set filter: %s (%d)", strerror(err), err);
363		return -err;
364	}
365
366	memset(&addr, 0, sizeof(addr));
367	addr.hci_family = AF_BLUETOOTH;
368	addr.hci_dev = HCI_DEV_NONE;
369	if (bind(sock, (struct sockaddr *) &addr,
370							sizeof(addr)) < 0) {
371		err = errno;
372		error("Can't bind HCI socket: %s (%d)",
373							strerror(err), err);
374		return -err;
375	}
376
377	ctl_io = g_io_channel_unix_new(sock);
378	g_io_channel_set_close_on_unref(ctl_io, TRUE);
379
380	ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL);
381
382	g_io_channel_unref(ctl_io);
383
384	/* Initialize already connected devices */
385	return init_known_adapters(sock);
386}
387
388static void hciops_cleanup(void)
389{
390	if (child_io_id) {
391		g_source_remove(child_io_id);
392		child_io_id = 0;
393	}
394
395	if (ctl_io_id) {
396		g_source_remove(ctl_io_id);
397		ctl_io_id = 0;
398	}
399
400	if (child_pipe[0] >= 0) {
401		close(child_pipe[0]);
402		child_pipe[0] = -1;
403	}
404
405	if (child_pipe[1] >= 0) {
406		close(child_pipe[1]);
407		child_pipe[1] = -1;
408	}
409}
410
411static int hciops_start(int index)
412{
413	int dd;
414	int err = 0;
415
416	dd = hci_open_dev(index);
417	if (dd < 0)
418		return -EIO;
419
420	if (ioctl(dd, HCIDEVUP, index) == 0)
421		goto done; /* on success */
422
423	if (errno != EALREADY) {
424		err = errno;
425		error("Can't init device hci%d: %s (%d)",
426				index, strerror(err), err);
427	}
428
429done:
430	hci_close_dev(dd);
431	return -err;
432}
433
434static int hciops_stop(int index)
435{
436	int dd;
437	int err = 0;
438
439	dd = hci_open_dev(index);
440	if (dd < 0)
441		return -EIO;
442
443	if (ioctl(dd, HCIDEVDOWN, index) == 0)
444		goto done; /* on success */
445
446	if (errno != EALREADY) {
447		err = errno;
448		error("Can't stop device hci%d: %s (%d)",
449				index, strerror(err), err);
450	}
451
452done:
453	hci_close_dev(dd);
454	return -err;
455}
456
457static int hciops_powered(int index, gboolean powered)
458{
459	int dd, err;
460	uint8_t mode = SCAN_DISABLED;
461
462	if (powered)
463		return hciops_start(index);
464
465	dd = hci_open_dev(index);
466	if (dd < 0)
467		return -EIO;
468
469	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE,
470					1, &mode);
471	if (err < 0) {
472		err = -errno;
473		hci_close_dev(dd);
474		return err;
475	}
476
477	hci_close_dev(dd);
478
479	return hciops_stop(index);
480}
481
482static int hciops_connectable(int index)
483{
484	int dd, err;
485	uint8_t mode = SCAN_PAGE;
486
487	dd = hci_open_dev(index);
488	if (dd < 0)
489		return -EIO;
490
491	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE,
492					1, &mode);
493	if (err < 0)
494		err = -errno;
495
496	hci_close_dev(dd);
497
498	return err;
499}
500
501static int hciops_discoverable(int index)
502{
503	int dd, err;
504	uint8_t mode = (SCAN_PAGE | SCAN_INQUIRY);
505
506	dd = hci_open_dev(index);
507	if (dd < 0)
508		return -EIO;
509
510	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE,
511					1, &mode);
512	if (err < 0)
513		err = -errno;
514
515	hci_close_dev(dd);
516
517	return err;
518}
519
520static int hciops_set_class(int index, uint32_t class)
521{
522	int dd, err;
523	write_class_of_dev_cp cp;
524
525	dd = hci_open_dev(index);
526	if (dd < 0)
527		return -EIO;
528
529	memcpy(cp.dev_class, &class, 3);
530
531	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV,
532					WRITE_CLASS_OF_DEV_CP_SIZE, &cp);
533
534	if (err < 0)
535		err = -errno;
536
537	hci_close_dev(dd);
538
539	return err;
540}
541
542static int hciops_set_limited_discoverable(int index, uint32_t class,
543							gboolean limited)
544{
545	int dd, err;
546	int num = (limited ? 2 : 1);
547	uint8_t lap[] = { 0x33, 0x8b, 0x9e, 0x00, 0x8b, 0x9e };
548	write_current_iac_lap_cp cp;
549
550	/*
551	 * 1: giac
552	 * 2: giac + liac
553	 */
554	dd = hci_open_dev(index);
555	if (dd < 0)
556		return -EIO;
557
558	memset(&cp, 0, sizeof(cp));
559	cp.num_current_iac = num;
560	memcpy(&cp.lap, lap, num * 3);
561
562	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_CURRENT_IAC_LAP,
563			(num * 3 + 1), &cp);
564	if (err < 0) {
565		err = -errno;
566		hci_close_dev(dd);
567		return err;
568	}
569
570	hci_close_dev(dd);
571
572	return hciops_set_class(index, class);
573}
574
575static int hciops_start_discovery(int index, gboolean periodic)
576{
577	uint8_t lap[3] = { 0x33, 0x8b, 0x9e };
578	int dd, err;
579
580	dd = hci_open_dev(index);
581	if (dd < 0)
582		return -EIO;
583
584	if (periodic) {
585		periodic_inquiry_cp cp;
586
587		memset(&cp, 0, sizeof(cp));
588		memcpy(&cp.lap, lap, 3);
589		cp.max_period = htobs(24);
590		cp.min_period = htobs(16);
591		cp.length  = 0x08;
592		cp.num_rsp = 0x00;
593
594		err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_PERIODIC_INQUIRY,
595					PERIODIC_INQUIRY_CP_SIZE, &cp);
596	} else {
597		inquiry_cp inq_cp;
598
599		memset(&inq_cp, 0, sizeof(inq_cp));
600		memcpy(&inq_cp.lap, lap, 3);
601		inq_cp.length = 0x08;
602		inq_cp.num_rsp = 0x00;
603
604		err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_INQUIRY,
605					INQUIRY_CP_SIZE, &inq_cp);
606	}
607
608	if (err < 0)
609		err = -errno;
610
611	hci_close_dev(dd);
612
613	return err;
614}
615
616static int hciops_stop_discovery(int index)
617{
618	struct hci_dev_info di;
619	int dd, err;
620
621	if (hci_devinfo(index, &di) < 0)
622		return -errno;
623
624	dd = hci_open_dev(index);
625	if (dd < 0)
626		return -EIO;
627
628	if (hci_test_bit(HCI_INQUIRY, &di.flags))
629		err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_INQUIRY_CANCEL,
630				0, 0);
631	else
632		err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY,
633				0, 0);
634	if (err < 0)
635		err = -errno;
636
637	hci_close_dev(dd);
638
639	return err;
640}
641
642static int hciops_resolve_name(int index, bdaddr_t *bdaddr)
643{
644	remote_name_req_cp cp;
645	int dd, err;
646
647	dd = hci_open_dev(index);
648	if (dd < 0)
649		return -EIO;
650
651	memset(&cp, 0, sizeof(cp));
652	bacpy(&cp.bdaddr, bdaddr);
653	cp.pscan_rep_mode = 0x02;
654
655	err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ,
656					REMOTE_NAME_REQ_CP_SIZE, &cp);
657	if (err < 0)
658		err = -errno;
659
660	hci_close_dev(dd);
661
662	return err;
663}
664
665static int hciops_set_name(int index, const char *name)
666{
667	change_local_name_cp cp;
668	int dd, err;
669
670	dd = hci_open_dev(index);
671	if (dd < 0)
672		return -EIO;
673
674	memset(&cp, 0, sizeof(cp));
675	strncpy((char *) cp.name, name, sizeof(cp.name));
676
677	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME,
678					CHANGE_LOCAL_NAME_CP_SIZE, &cp);
679	if (err < 0)
680		err = -errno;
681
682	hci_close_dev(dd);
683
684	return err;
685}
686
687static int hciops_read_name(int index)
688{
689	int dd, err;
690
691	dd = hci_open_dev(index);
692	if (dd < 0)
693		return -EIO;
694
695	err = hci_send_cmd(dd, OGF_HOST_CTL, OCF_READ_LOCAL_NAME, 0, 0);
696	if (err < 0)
697		err = -errno;
698
699	hci_close_dev(dd);
700
701	return err;
702}
703
704static int hciops_cancel_resolve_name(int index, bdaddr_t *bdaddr)
705{
706	remote_name_req_cancel_cp cp;
707	int dd, err;
708
709	dd = hci_open_dev(index);
710	if (dd < 0)
711		return -EIO;
712
713	memset(&cp, 0, sizeof(cp));
714	bacpy(&cp.bdaddr, bdaddr);
715
716	err = hci_send_cmd(dd, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL,
717					REMOTE_NAME_REQ_CANCEL_CP_SIZE, &cp);
718	if (err < 0)
719		err = -errno;
720
721	hci_close_dev(dd);
722
723	return err;
724}
725
726static struct btd_adapter_ops hci_ops = {
727	.setup = hciops_setup,
728	.cleanup = hciops_cleanup,
729	.start = hciops_start,
730	.stop = hciops_stop,
731	.set_powered = hciops_powered,
732	.set_connectable = hciops_connectable,
733	.set_discoverable = hciops_discoverable,
734	.set_limited_discoverable = hciops_set_limited_discoverable,
735	.start_discovery = hciops_start_discovery,
736	.stop_discovery = hciops_stop_discovery,
737	.resolve_name = hciops_resolve_name,
738	.cancel_resolve_name = hciops_cancel_resolve_name,
739	.set_name = hciops_set_name,
740	.read_name = hciops_read_name,
741	.set_class = hciops_set_class,
742};
743
744static int hciops_init(void)
745{
746	return btd_register_adapter_ops(&hci_ops);
747}
748static void hciops_exit(void)
749{
750	btd_adapter_cleanup_ops(&hci_ops);
751}
752
753BLUETOOTH_PLUGIN_DEFINE(hciops, VERSION,
754		BLUETOOTH_PLUGIN_PRIORITY_LOW, hciops_init, hciops_exit)
755