1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2006-2010 Nokia Corporation
6 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 #define _GNU_SOURCE
30 #include <stdio.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <sys/ioctl.h>
35
36 #include <bluetooth/bluetooth.h>
37 #include <bluetooth/hci.h>
38 #include <bluetooth/hci_lib.h>
39 #include <bluetooth/sdp.h>
40 #include <bluetooth/sdp_lib.h>
41
42 #include <glib.h>
43 #include <dbus/dbus.h>
44 #include <gdbus.h>
45
46 #include "log.h"
47 #include "textfile.h"
48
49 #include "hcid.h"
50 #include "sdpd.h"
51 #include "manager.h"
52 #include "adapter.h"
53 #include "device.h"
54 #include "dbus-common.h"
55 #include "dbus-hci.h"
56 #include "error.h"
57 #include "glib-helper.h"
58 #include "agent.h"
59 #include "storage.h"
60
61 #define IO_CAPABILITY_DISPLAYONLY 0x00
62 #define IO_CAPABILITY_DISPLAYYESNO 0x01
63 #define IO_CAPABILITY_KEYBOARDONLY 0x02
64 #define IO_CAPABILITY_NOINPUTNOOUTPUT 0x03
65 #define IO_CAPABILITY_INVALID 0xFF
66
67 /* Limited Discoverable bit mask in CoD */
68 #define LIMITED_BIT 0x002000
69
70 #define check_address(address) bachk(address)
71
72 static DBusConnection *connection = NULL;
73 static GSList *adapter_drivers = NULL;
74
75 const struct btd_adapter_ops *adapter_ops = NULL;
76
77 struct session_req {
78 struct btd_adapter *adapter;
79 DBusConnection *conn; /* Connection reference */
80 DBusMessage *msg; /* Unreplied message ref */
81 char *owner; /* Bus name of the owner */
82 guint id; /* Listener id */
83 uint8_t mode; /* Requested mode */
84 int refcount; /* Session refcount */
85 };
86
87 struct service_auth {
88 service_auth_cb cb;
89 void *user_data;
90 struct btd_device *device;
91 struct btd_adapter *adapter;
92 };
93
94 struct btd_adapter {
95 uint16_t dev_id;
96 int up;
97 char *path; /* adapter object path */
98 bdaddr_t bdaddr; /* adapter Bluetooth Address */
99 guint discov_timeout_id; /* discoverable timeout id */
100 uint32_t discov_timeout; /* discoverable time(sec) */
101 guint pairable_timeout_id; /* pairable timeout id */
102 uint32_t pairable_timeout; /* pairable time(sec) */
103 uint8_t scan_mode; /* scan mode: SCAN_DISABLED, SCAN_PAGE,
104 * SCAN_INQUIRY */
105 uint8_t mode; /* off, connectable, discoverable,
106 * limited */
107 uint8_t global_mode; /* last valid global mode */
108 struct session_req *pending_mode;
109 int state; /* standard inq, periodic inq, name
110 * resloving */
111 GSList *found_devices;
112 GSList *oor_devices; /* out of range device list */
113 struct agent *agent; /* For the new API */
114 guint auth_idle_id; /* Ongoing authorization */
115 GSList *connections; /* Connected devices */
116 GSList *devices; /* Devices structure pointers */
117 GSList *mode_sessions; /* Request Mode sessions */
118 GSList *disc_sessions; /* Discovery sessions */
119 guint scheduler_id; /* Scheduler handle */
120 sdp_list_t *services; /* Services associated to adapter */
121
122 struct hci_dev dev; /* hci info */
123 int8_t tx_power; /* inq response tx power level */
124 gboolean pairable; /* pairable state */
125
126 gboolean initialized;
127 gboolean already_up; /* adapter was already up on init */
128
129 gboolean off_requested; /* DEVDOWN ioctl was called */
130
131 uint32_t current_cod; /* Adapter's current class */
132 uint32_t pending_cod;
133 uint32_t wanted_cod; /* CoD cache */
134
135 gboolean cache_enable;
136
137 gint ref;
138 };
139
140 static void adapter_set_pairable_timeout(struct btd_adapter *adapter,
141 guint interval);
142
invalid_args(DBusMessage * msg)143 static inline DBusMessage *invalid_args(DBusMessage *msg)
144 {
145 return g_dbus_create_error(msg, ERROR_INTERFACE ".InvalidArguments",
146 "Invalid arguments in method call");
147 }
148
adapter_not_ready(DBusMessage * msg)149 static inline DBusMessage *adapter_not_ready(DBusMessage *msg)
150 {
151 return g_dbus_create_error(msg, ERROR_INTERFACE ".NotReady",
152 "Adapter is not ready");
153 }
154
failed_strerror(DBusMessage * msg,int err)155 static inline DBusMessage *failed_strerror(DBusMessage *msg, int err)
156 {
157 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
158 strerror(err));
159 }
160
not_in_progress(DBusMessage * msg,const char * str)161 static inline DBusMessage *not_in_progress(DBusMessage *msg, const char *str)
162 {
163 return g_dbus_create_error(msg, ERROR_INTERFACE ".NotInProgress", str);
164 }
165
not_authorized(DBusMessage * msg)166 static inline DBusMessage *not_authorized(DBusMessage *msg)
167 {
168 return g_dbus_create_error(msg, ERROR_INTERFACE ".NotAuthorized",
169 "Not authorized");
170 }
171
found_device_cmp(const struct remote_dev_info * d1,const struct remote_dev_info * d2)172 static int found_device_cmp(const struct remote_dev_info *d1,
173 const struct remote_dev_info *d2)
174 {
175 int ret;
176
177 if (bacmp(&d2->bdaddr, BDADDR_ANY)) {
178 ret = bacmp(&d1->bdaddr, &d2->bdaddr);
179 if (ret)
180 return ret;
181 }
182
183 if (d2->name_status != NAME_ANY) {
184 ret = (d1->name_status - d2->name_status);
185 if (ret)
186 return ret;
187 }
188
189 return 0;
190 }
191
dev_info_free(struct remote_dev_info * dev)192 static void dev_info_free(struct remote_dev_info *dev)
193 {
194 g_free(dev->name);
195 g_free(dev->alias);
196 g_free(dev);
197 }
198
clear_found_devices_list(struct btd_adapter * adapter)199 void clear_found_devices_list(struct btd_adapter *adapter)
200 {
201 if (!adapter->found_devices)
202 return;
203
204 g_slist_foreach(adapter->found_devices, (GFunc) dev_info_free, NULL);
205 g_slist_free(adapter->found_devices);
206 adapter->found_devices = NULL;
207 }
208
adapter_set_service_classes(struct btd_adapter * adapter,uint8_t value)209 static int adapter_set_service_classes(struct btd_adapter *adapter,
210 uint8_t value)
211 {
212 int err;
213
214 /* Update only the service class, keep the limited bit,
215 * major/minor class bits intact */
216 adapter->wanted_cod &= 0x00ffff;
217 adapter->wanted_cod |= (value << 16);
218
219 /* If we already have the CoD we want or the cache is enabled or an
220 * existing CoD write is in progress just bail out */
221 if (adapter->current_cod == adapter->wanted_cod ||
222 adapter->cache_enable || adapter->pending_cod)
223 return 0;
224
225 DBG("Changing service classes to 0x%06x", adapter->wanted_cod);
226
227 err = adapter_ops->set_class(adapter->dev_id, adapter->wanted_cod);
228 if (err < 0)
229 error("Adapter class update failed: %s(%d)",
230 strerror(err), err);
231 else
232 adapter->pending_cod = adapter->wanted_cod;
233
234 return err;
235 }
236
btd_adapter_set_class(struct btd_adapter * adapter,uint8_t major,uint8_t minor)237 int btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
238 uint8_t minor)
239 {
240 int err;
241
242 /* Update only the major and minor class bits keeping remaining bits
243 * intact*/
244 adapter->wanted_cod &= 0xffe000;
245 adapter->wanted_cod |= ((major & 0x1f) << 8) | minor;
246
247 if (adapter->wanted_cod == adapter->current_cod ||
248 adapter->cache_enable || adapter->pending_cod)
249 return 0;
250
251 DBG("Changing Major/Minor class to 0x%06x", adapter->wanted_cod);
252
253 err = adapter_ops->set_class(adapter->dev_id, adapter->wanted_cod);
254 if (err < 0)
255 error("Adapter class update failed: %s(%d)",
256 strerror(err), err);
257 else
258 adapter->pending_cod = adapter->wanted_cod;
259
260 return err;
261 }
262
pending_remote_name_cancel(struct btd_adapter * adapter)263 int pending_remote_name_cancel(struct btd_adapter *adapter)
264 {
265 struct remote_dev_info *dev, match;
266 int err = 0;
267
268 /* find the pending remote name request */
269 memset(&match, 0, sizeof(struct remote_dev_info));
270 bacpy(&match.bdaddr, BDADDR_ANY);
271 match.name_status = NAME_REQUESTED;
272
273 dev = adapter_search_found_devices(adapter, &match);
274 if (!dev) /* no pending request */
275 return -ENODATA;
276
277 err = adapter_ops->cancel_resolve_name(adapter->dev_id, &dev->bdaddr);
278 if (err < 0)
279 error("Remote name cancel failed: %s(%d)",
280 strerror(errno), errno);
281 return err;
282 }
283
adapter_resolve_names(struct btd_adapter * adapter)284 int adapter_resolve_names(struct btd_adapter *adapter)
285 {
286 struct remote_dev_info *dev, match;
287 int err;
288
289 memset(&match, 0, sizeof(struct remote_dev_info));
290 bacpy(&match.bdaddr, BDADDR_ANY);
291 match.name_status = NAME_REQUIRED;
292
293 dev = adapter_search_found_devices(adapter, &match);
294 if (!dev)
295 return -ENODATA;
296
297 /* send at least one request or return failed if the list is empty */
298 do {
299 /* flag to indicate the current remote name requested */
300 dev->name_status = NAME_REQUESTED;
301
302 err = adapter_ops->resolve_name(adapter->dev_id, &dev->bdaddr);
303
304 if (!err)
305 break;
306
307 error("Unable to send HCI remote name req: %s (%d)",
308 strerror(errno), errno);
309
310 /* if failed, request the next element */
311 /* remove the element from the list */
312 adapter_remove_found_device(adapter, &dev->bdaddr);
313
314 /* get the next element */
315 dev = adapter_search_found_devices(adapter, &match);
316 } while (dev);
317
318 return err;
319 }
320
mode2str(uint8_t mode)321 static const char *mode2str(uint8_t mode)
322 {
323 switch(mode) {
324 case MODE_OFF:
325 return "off";
326 case MODE_CONNECTABLE:
327 return "connectable";
328 case MODE_DISCOVERABLE:
329 case MODE_LIMITED:
330 return "discoverable";
331 default:
332 return "unknown";
333 }
334 }
335
get_mode(const bdaddr_t * bdaddr,const char * mode)336 static uint8_t get_mode(const bdaddr_t *bdaddr, const char *mode)
337 {
338 if (strcasecmp("off", mode) == 0)
339 return MODE_OFF;
340 else if (strcasecmp("connectable", mode) == 0)
341 return MODE_CONNECTABLE;
342 else if (strcasecmp("discoverable", mode) == 0)
343 return MODE_DISCOVERABLE;
344 else if (strcasecmp("limited", mode) == 0)
345 return MODE_LIMITED;
346 else if (strcasecmp("on", mode) == 0) {
347 char onmode[14], srcaddr[18];
348
349 ba2str(bdaddr, srcaddr);
350 if (read_on_mode(srcaddr, onmode, sizeof(onmode)) < 0)
351 return MODE_CONNECTABLE;
352
353 return get_mode(bdaddr, onmode);
354 } else
355 return MODE_UNKNOWN;
356 }
357
adapter_remove_discov_timeout(struct btd_adapter * adapter)358 static void adapter_remove_discov_timeout(struct btd_adapter *adapter)
359 {
360 if (!adapter)
361 return;
362
363 if(adapter->discov_timeout_id == 0)
364 return;
365
366 g_source_remove(adapter->discov_timeout_id);
367 adapter->discov_timeout_id = 0;
368 }
369
discov_timeout_handler(gpointer user_data)370 static gboolean discov_timeout_handler(gpointer user_data)
371 {
372 struct btd_adapter *adapter = user_data;
373
374 adapter->discov_timeout_id = 0;
375
376 adapter_ops->set_connectable(adapter->dev_id);
377
378 return FALSE;
379 }
380
adapter_set_discov_timeout(struct btd_adapter * adapter,guint interval)381 static void adapter_set_discov_timeout(struct btd_adapter *adapter,
382 guint interval)
383 {
384 if (adapter->discov_timeout_id) {
385 g_source_remove(adapter->discov_timeout_id);
386 adapter->discov_timeout_id = 0;
387 }
388
389 if (interval == 0)
390 return;
391
392 adapter->discov_timeout_id = g_timeout_add_seconds(interval,
393 discov_timeout_handler,
394 adapter);
395 }
396
adapter_set_limited_discoverable(struct btd_adapter * adapter,gboolean limited)397 static void adapter_set_limited_discoverable(struct btd_adapter *adapter,
398 gboolean limited)
399 {
400 /* Check if limited bit needs to be set/reset */
401 if (limited)
402 adapter->wanted_cod |= LIMITED_BIT;
403 else
404 adapter->wanted_cod &= ~LIMITED_BIT;
405
406 /* If we dont need the toggling, save an unnecessary CoD write */
407 if (adapter->pending_cod ||
408 adapter->wanted_cod == adapter->current_cod)
409 return;
410
411 if (adapter_ops->set_limited_discoverable(adapter->dev_id,
412 adapter->wanted_cod, limited) == 0)
413 adapter->pending_cod = adapter->wanted_cod;
414 }
415
session_ref(struct session_req * req)416 static struct session_req *session_ref(struct session_req *req)
417 {
418 req->refcount++;
419
420 DBG("%p: ref=%d", req, req->refcount);
421
422 return req;
423 }
424
create_session(struct btd_adapter * adapter,DBusConnection * conn,DBusMessage * msg,uint8_t mode,GDBusWatchFunction cb)425 static struct session_req *create_session(struct btd_adapter *adapter,
426 DBusConnection *conn, DBusMessage *msg,
427 uint8_t mode, GDBusWatchFunction cb)
428 {
429 const char *sender = dbus_message_get_sender(msg);
430 struct session_req *req;
431
432 req = g_new0(struct session_req, 1);
433 req->adapter = adapter;
434 req->conn = dbus_connection_ref(conn);
435 req->msg = dbus_message_ref(msg);
436 req->mode = mode;
437
438 if (cb == NULL)
439 return session_ref(req);
440
441 req->owner = g_strdup(sender);
442 req->id = g_dbus_add_disconnect_watch(conn, sender, cb, req, NULL);
443
444 info("%s session %p with %s activated",
445 req->mode ? "Mode" : "Discovery", req, sender);
446
447 return session_ref(req);
448 }
449
set_mode(struct btd_adapter * adapter,uint8_t new_mode,DBusMessage * msg)450 static int set_mode(struct btd_adapter *adapter, uint8_t new_mode,
451 DBusMessage *msg)
452 {
453 int err;
454
455 if (adapter->pending_mode != NULL)
456 return -EALREADY;
457
458 if (!adapter->up && new_mode != MODE_OFF) {
459 err = adapter_ops->set_powered(adapter->dev_id, TRUE);
460 if (err < 0)
461 return err;
462 }
463
464 if (adapter->up && new_mode == MODE_OFF) {
465 err = adapter_ops->set_powered(adapter->dev_id, FALSE);
466 if (err < 0)
467 return err;
468
469 adapter->off_requested = TRUE;
470
471 goto done;
472 }
473
474 if (new_mode == adapter->mode)
475 return 0;
476
477 if (new_mode == MODE_CONNECTABLE)
478 err = adapter_ops->set_connectable(adapter->dev_id);
479 else
480 err = adapter_ops->set_discoverable(adapter->dev_id);
481
482 if (err < 0)
483 return err;
484
485 if (new_mode > MODE_CONNECTABLE) {
486 adapter_remove_discov_timeout(adapter);
487
488 if (adapter->discov_timeout)
489 adapter_set_discov_timeout(adapter,
490 adapter->discov_timeout);
491
492 if (new_mode != MODE_LIMITED && adapter->mode == MODE_LIMITED)
493 adapter_set_limited_discoverable(adapter, FALSE);
494 }
495
496 done:
497 DBG("%s", mode2str(new_mode));
498
499 if (msg != NULL)
500 /* Wait for mode change to reply */
501 adapter->pending_mode = create_session(adapter, connection,
502 msg, new_mode, NULL);
503 else {
504 /* Nothing to reply just write the new mode */
505 const char *modestr = mode2str(new_mode);
506 adapter->mode = new_mode;
507 write_device_mode(&adapter->bdaddr, modestr);
508 }
509
510 return 0;
511 }
512
set_powered(DBusConnection * conn,DBusMessage * msg,gboolean powered,void * data)513 static DBusMessage *set_powered(DBusConnection *conn, DBusMessage *msg,
514 gboolean powered, void *data)
515 {
516 struct btd_adapter *adapter = data;
517 uint8_t mode;
518 int err;
519
520 mode = powered ? get_mode(&adapter->bdaddr, "on") : MODE_OFF;
521
522 if (mode == adapter->mode)
523 return dbus_message_new_method_return(msg);
524
525 err = set_mode(adapter, mode, NULL);
526 if (err < 0)
527 return failed_strerror(msg, -err);
528
529 return dbus_message_new_method_return(msg);
530 }
531
set_discoverable(DBusConnection * conn,DBusMessage * msg,gboolean discoverable,void * data)532 static DBusMessage *set_discoverable(DBusConnection *conn, DBusMessage *msg,
533 gboolean discoverable, void *data)
534 {
535 struct btd_adapter *adapter = data;
536 uint8_t mode;
537 int err;
538
539 mode = discoverable ? MODE_DISCOVERABLE : MODE_CONNECTABLE;
540
541 if (mode == MODE_DISCOVERABLE && adapter->pairable &&
542 adapter->discov_timeout > 0 &&
543 adapter->discov_timeout <= 60)
544 mode = MODE_LIMITED;
545
546 if (mode == adapter->mode)
547 return dbus_message_new_method_return(msg);
548
549 err = set_mode(adapter, mode, msg);
550 if (err < 0)
551 return failed_strerror(msg, -err);
552
553 return 0;
554 }
555
set_pairable(DBusConnection * conn,DBusMessage * msg,gboolean pairable,void * data)556 static DBusMessage *set_pairable(DBusConnection *conn, DBusMessage *msg,
557 gboolean pairable, void *data)
558 {
559 struct btd_adapter *adapter = data;
560 uint8_t mode;
561 int err;
562
563 if (adapter->scan_mode == SCAN_DISABLED)
564 return adapter_not_ready(msg);
565
566 if (pairable == adapter->pairable)
567 goto done;
568
569 if (!(adapter->scan_mode & SCAN_INQUIRY))
570 goto store;
571
572 mode = (pairable && adapter->discov_timeout > 0 &&
573 adapter->discov_timeout <= 60) ?
574 MODE_LIMITED : MODE_DISCOVERABLE;
575
576 err = set_mode(adapter, mode, NULL);
577 if (err < 0 && msg)
578 return failed_strerror(msg, -err);
579
580 store:
581
582 adapter->pairable = pairable;
583
584 write_device_pairable(&adapter->bdaddr, pairable);
585
586 emit_property_changed(connection, adapter->path,
587 ADAPTER_INTERFACE, "Pairable",
588 DBUS_TYPE_BOOLEAN, &pairable);
589
590 if (pairable && adapter->pairable_timeout)
591 adapter_set_pairable_timeout(adapter,
592 adapter->pairable_timeout);
593
594 done:
595 return msg ? dbus_message_new_method_return(msg) : NULL;
596 }
597
pairable_timeout_handler(void * data)598 static gboolean pairable_timeout_handler(void *data)
599 {
600 set_pairable(NULL, NULL, FALSE, data);
601
602 return FALSE;
603 }
604
adapter_set_pairable_timeout(struct btd_adapter * adapter,guint interval)605 static void adapter_set_pairable_timeout(struct btd_adapter *adapter,
606 guint interval)
607 {
608 if (adapter->pairable_timeout_id) {
609 g_source_remove(adapter->pairable_timeout_id);
610 adapter->pairable_timeout_id = 0;
611 }
612
613 if (interval == 0)
614 return;
615
616 adapter->pairable_timeout_id = g_timeout_add_seconds(interval,
617 pairable_timeout_handler,
618 adapter);
619 }
620
find_session(GSList * list,const char * sender)621 static struct session_req *find_session(GSList *list, const char *sender)
622 {
623 GSList *l;
624
625 for (l = list; l; l = l->next) {
626 struct session_req *req = l->data;
627
628 if (g_str_equal(req->owner, sender))
629 return req;
630 }
631
632 return NULL;
633 }
634
get_needed_mode(struct btd_adapter * adapter,uint8_t mode)635 static uint8_t get_needed_mode(struct btd_adapter *adapter, uint8_t mode)
636 {
637 GSList *l;
638
639 if (adapter->global_mode > mode)
640 mode = adapter->global_mode;
641
642 for (l = adapter->mode_sessions; l; l = l->next) {
643 struct session_req *req = l->data;
644
645 if (req->mode > mode)
646 mode = req->mode;
647 }
648
649 return mode;
650 }
651
session_remove(struct session_req * req)652 static void session_remove(struct session_req *req)
653 {
654 struct btd_adapter *adapter = req->adapter;
655
656 /* Ignore set_mode session */
657 if (req->owner == NULL)
658 return;
659
660 DBG("%s session %p with %s deactivated",
661 req->mode ? "Mode" : "Discovery", req, req->owner);
662
663 if (req->mode) {
664 uint8_t mode;
665
666 adapter->mode_sessions = g_slist_remove(adapter->mode_sessions,
667 req);
668
669 mode = get_needed_mode(adapter, adapter->global_mode);
670
671 if (mode == adapter->mode)
672 return;
673
674 DBG("Switching to '%s' mode", mode2str(mode));
675
676 set_mode(adapter, mode, NULL);
677 } else {
678 adapter->disc_sessions = g_slist_remove(adapter->disc_sessions,
679 req);
680
681 if (adapter->disc_sessions)
682 return;
683
684 DBG("Stopping discovery");
685
686 pending_remote_name_cancel(adapter);
687
688 clear_found_devices_list(adapter);
689
690 g_slist_free(adapter->oor_devices);
691 adapter->oor_devices = NULL;
692
693 if (adapter->scheduler_id) {
694 g_source_remove(adapter->scheduler_id);
695 adapter->scheduler_id = 0;
696 }
697
698 adapter_ops->stop_discovery(adapter->dev_id);
699 }
700 }
701
session_free(struct session_req * req)702 static void session_free(struct session_req *req)
703 {
704 if (req->id)
705 g_dbus_remove_watch(req->conn, req->id);
706
707 session_remove(req);
708
709 if (req->msg)
710 dbus_message_unref(req->msg);
711 if (req->conn)
712 dbus_connection_unref(req->conn);
713 g_free(req->owner);
714 g_free(req);
715 }
716
session_owner_exit(DBusConnection * conn,void * user_data)717 static void session_owner_exit(DBusConnection *conn, void *user_data)
718 {
719 struct session_req *req = user_data;
720
721 req->id = 0;
722
723 session_free(req);
724 }
725
session_unref(struct session_req * req)726 static void session_unref(struct session_req *req)
727 {
728 req->refcount--;
729
730 DBG("%p: ref=%d", req, req->refcount);
731
732 if (req->refcount)
733 return;
734
735 session_free(req);
736 }
737
confirm_mode_cb(struct agent * agent,DBusError * derr,void * data)738 static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
739 {
740 struct session_req *req = data;
741 int err;
742 DBusMessage *reply;
743
744 if (derr && dbus_error_is_set(derr)) {
745 reply = dbus_message_new_error(req->msg, derr->name,
746 derr->message);
747 g_dbus_send_message(req->conn, reply);
748 session_unref(req);
749 return;
750 }
751
752 err = set_mode(req->adapter, req->mode, NULL);
753 if (err < 0)
754 reply = failed_strerror(req->msg, -err);
755 else
756 reply = dbus_message_new_method_return(req->msg);
757
758 g_dbus_send_message(req->conn, reply);
759
760 dbus_message_unref(req->msg);
761 req->msg = NULL;
762
763 if (!find_session(req->adapter->mode_sessions, req->owner))
764 session_unref(req);
765 }
766
set_discoverable_timeout(DBusConnection * conn,DBusMessage * msg,uint32_t timeout,void * data)767 static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
768 DBusMessage *msg,
769 uint32_t timeout,
770 void *data)
771 {
772 struct btd_adapter *adapter = data;
773 const char *path;
774
775 if (adapter->discov_timeout == timeout && timeout == 0)
776 return dbus_message_new_method_return(msg);
777
778 if (adapter->scan_mode & SCAN_INQUIRY)
779 adapter_set_discov_timeout(adapter, timeout);
780
781 adapter->discov_timeout = timeout;
782
783 write_discoverable_timeout(&adapter->bdaddr, timeout);
784
785 path = dbus_message_get_path(msg);
786
787 emit_property_changed(conn, path,
788 ADAPTER_INTERFACE, "DiscoverableTimeout",
789 DBUS_TYPE_UINT32, &timeout);
790
791 return dbus_message_new_method_return(msg);
792 }
793
set_pairable_timeout(DBusConnection * conn,DBusMessage * msg,uint32_t timeout,void * data)794 static DBusMessage *set_pairable_timeout(DBusConnection *conn,
795 DBusMessage *msg,
796 uint32_t timeout,
797 void *data)
798 {
799 struct btd_adapter *adapter = data;
800 const char *path;
801
802 if (adapter->pairable_timeout == timeout && timeout == 0)
803 return dbus_message_new_method_return(msg);
804
805 if (adapter->pairable)
806 adapter_set_pairable_timeout(adapter, timeout);
807
808 adapter->pairable_timeout = timeout;
809
810 write_pairable_timeout(&adapter->bdaddr, timeout);
811
812 path = dbus_message_get_path(msg);
813
814 emit_property_changed(conn, path,
815 ADAPTER_INTERFACE, "PairableTimeout",
816 DBUS_TYPE_UINT32, &timeout);
817
818 return dbus_message_new_method_return(msg);
819 }
820
update_ext_inquiry_response(struct btd_adapter * adapter)821 static void update_ext_inquiry_response(struct btd_adapter *adapter)
822 {
823 uint8_t fec = 0, data[240];
824 struct hci_dev *dev = &adapter->dev;
825 int dd;
826
827 if (!(dev->features[6] & LMP_EXT_INQ))
828 return;
829
830 memset(data, 0, sizeof(data));
831
832 dd = hci_open_dev(adapter->dev_id);
833 if (dd < 0)
834 return;
835
836 if (dev->ssp_mode > 0)
837 create_ext_inquiry_response((char *) dev->name,
838 adapter->tx_power,
839 adapter->services, data);
840
841 if (hci_write_ext_inquiry_response(dd, fec, data,
842 HCI_REQ_TIMEOUT) < 0)
843 error("Can't write extended inquiry response: %s (%d)",
844 strerror(errno), errno);
845
846 hci_close_dev(dd);
847 }
848
adapter_set_class_complete(bdaddr_t * bdaddr,uint8_t status)849 void adapter_set_class_complete(bdaddr_t *bdaddr, uint8_t status)
850 {
851 uint8_t class[3];
852 struct btd_adapter *adapter;
853 int err;
854
855 if (status)
856 return;
857
858 adapter = manager_find_adapter(bdaddr);
859 if (!adapter) {
860 error("Unable to find matching adapter");
861 return;
862 }
863
864 if (adapter->pending_cod == 0)
865 return;
866
867 adapter->current_cod = adapter->pending_cod;
868 adapter->pending_cod = 0;
869
870 class[2] = (adapter->current_cod >> 16) & 0xff;
871 class[1] = (adapter->current_cod >> 8) & 0xff;
872 class[0] = adapter->current_cod & 0xff;
873
874 write_local_class(&adapter->bdaddr, class);
875
876 emit_property_changed(connection, adapter->path,
877 ADAPTER_INTERFACE, "Class",
878 DBUS_TYPE_UINT32, &adapter->current_cod);
879
880 update_ext_inquiry_response(adapter);
881
882 if (adapter->wanted_cod == adapter->current_cod)
883 return;
884
885 if (adapter->wanted_cod & LIMITED_BIT &&
886 !(adapter->current_cod & LIMITED_BIT))
887 err = adapter_ops->set_limited_discoverable(adapter->dev_id,
888 adapter->wanted_cod, TRUE);
889 else if (!(adapter->wanted_cod & LIMITED_BIT) &&
890 adapter->current_cod & LIMITED_BIT)
891 err = adapter_ops->set_limited_discoverable(adapter->dev_id,
892 adapter->wanted_cod, FALSE);
893 else
894 err = adapter_ops->set_class(adapter->dev_id,
895 adapter->wanted_cod);
896
897 if (err == 0)
898 adapter->pending_cod = adapter->wanted_cod;
899 }
900
adapter_update_tx_power(bdaddr_t * bdaddr,uint8_t status,void * ptr)901 void adapter_update_tx_power(bdaddr_t *bdaddr, uint8_t status, void *ptr)
902 {
903 struct btd_adapter *adapter;
904
905 if (status)
906 return;
907
908 adapter = manager_find_adapter(bdaddr);
909 if (!adapter) {
910 error("Unable to find matching adapter");
911 return;
912 }
913
914 adapter->tx_power = *((int8_t *) ptr);
915
916 DBG("inquiry respone tx power level is %d", adapter->tx_power);
917
918 update_ext_inquiry_response(adapter);
919 }
920
adapter_update_local_name(bdaddr_t * bdaddr,uint8_t status,void * ptr)921 void adapter_update_local_name(bdaddr_t *bdaddr, uint8_t status, void *ptr)
922 {
923 read_local_name_rp rp;
924 struct hci_dev *dev;
925 struct btd_adapter *adapter;
926 gchar *name;
927
928 if (status)
929 return;
930
931 adapter = manager_find_adapter(bdaddr);
932 if (!adapter) {
933 error("Unable to find matching adapter");
934 return;
935 }
936
937 dev = &adapter->dev;
938
939 memcpy(&rp, ptr, MAX_NAME_LENGTH);
940 if (strncmp((char *) rp.name, (char *) dev->name, MAX_NAME_LENGTH) == 0)
941 return;
942
943 strncpy((char *) dev->name, (char *) rp.name, MAX_NAME_LENGTH);
944
945 write_local_name(bdaddr, (char *) dev->name);
946
947 update_ext_inquiry_response(adapter);
948
949 name = g_strdup((char *) dev->name);
950
951 if (connection)
952 emit_property_changed(connection, adapter->path,
953 ADAPTER_INTERFACE, "Name",
954 DBUS_TYPE_STRING, &name);
955 g_free(name);
956 }
957
adapter_setname_complete(bdaddr_t * local,uint8_t status)958 void adapter_setname_complete(bdaddr_t *local, uint8_t status)
959 {
960 struct btd_adapter *adapter;
961 int err;
962
963 if (status)
964 return;
965
966 adapter = manager_find_adapter(local);
967 if (!adapter) {
968 error("No matching adapter found");
969 return;
970 }
971
972 err = adapter_ops->read_name(adapter->dev_id);
973 if (err < 0)
974 error("Sending getting name command failed: %s (%d)",
975 strerror(errno), errno);
976
977 }
978
set_name(DBusConnection * conn,DBusMessage * msg,const char * name,void * data)979 static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
980 const char *name, void *data)
981 {
982 struct btd_adapter *adapter = data;
983 struct hci_dev *dev = &adapter->dev;
984
985 if (!g_utf8_validate(name, -1, NULL)) {
986 error("Name change failed: supplied name isn't valid UTF-8");
987 return invalid_args(msg);
988 }
989
990 if (strncmp(name, (char *) dev->name, MAX_NAME_LENGTH) == 0)
991 goto done;
992
993 if (!adapter->up) {
994 strncpy((char *) adapter->dev.name, name, MAX_NAME_LENGTH);
995 write_local_name(&adapter->bdaddr, name);
996 } else {
997 int err = adapter_ops->set_name(adapter->dev_id, name);
998 if (err < 0)
999 return failed_strerror(msg, err);
1000 }
1001
1002 done:
1003 return dbus_message_new_method_return(msg);
1004 }
1005
adapter_find_device(struct btd_adapter * adapter,const char * dest)1006 struct btd_device *adapter_find_device(struct btd_adapter *adapter,
1007 const char *dest)
1008 {
1009 struct btd_device *device;
1010 GSList *l;
1011
1012 if (!adapter)
1013 return NULL;
1014
1015 l = g_slist_find_custom(adapter->devices, dest,
1016 (GCompareFunc) device_address_cmp);
1017 if (!l)
1018 return NULL;
1019
1020 device = l->data;
1021
1022 return device;
1023 }
1024
adapter_find_connection(struct btd_adapter * adapter,uint16_t handle)1025 struct btd_device *adapter_find_connection(struct btd_adapter *adapter,
1026 uint16_t handle)
1027 {
1028 GSList *l;
1029
1030 for (l = adapter->connections; l; l = l->next) {
1031 struct btd_device *device = l->data;
1032
1033 if (device_has_connection(device, handle))
1034 return device;
1035 }
1036
1037 return NULL;
1038 }
1039
adapter_update_devices(struct btd_adapter * adapter)1040 static void adapter_update_devices(struct btd_adapter *adapter)
1041 {
1042 char **devices;
1043 int i;
1044 GSList *l;
1045
1046 /* Devices */
1047 devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
1048 for (i = 0, l = adapter->devices; l; l = l->next, i++) {
1049 struct btd_device *dev = l->data;
1050 devices[i] = (char *) device_get_path(dev);
1051 }
1052
1053 emit_array_property_changed(connection, adapter->path,
1054 ADAPTER_INTERFACE, "Devices",
1055 DBUS_TYPE_OBJECT_PATH, &devices);
1056 g_free(devices);
1057 }
1058
adapter_emit_uuids_updated(struct btd_adapter * adapter)1059 static void adapter_emit_uuids_updated(struct btd_adapter *adapter)
1060 {
1061 char **uuids;
1062 int i;
1063 sdp_list_t *list;
1064
1065 uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
1066
1067 for (i = 0, list = adapter->services; list; list = list->next, i++) {
1068 sdp_record_t *rec = list->data;
1069 uuids[i] = bt_uuid2string(&rec->svclass);
1070 }
1071
1072 emit_array_property_changed(connection, adapter->path,
1073 ADAPTER_INTERFACE, "UUIDs", DBUS_TYPE_STRING, &uuids);
1074
1075 g_strfreev(uuids);
1076 }
1077
1078 /*
1079 * adapter_services_inc_rem - Insert or remove UUID from adapter
1080 */
adapter_service_ins_rem(const bdaddr_t * bdaddr,void * rec,gboolean insert)1081 static void adapter_service_ins_rem(const bdaddr_t *bdaddr, void *rec,
1082 gboolean insert)
1083 {
1084 struct btd_adapter *adapter;
1085 GSList *adapters;
1086
1087 adapters = NULL;
1088
1089 if (bacmp(bdaddr, BDADDR_ANY) != 0) {
1090 /* Only one adapter */
1091 adapter = manager_find_adapter(bdaddr);
1092 if (!adapter)
1093 return;
1094
1095 adapters = g_slist_append(adapters, adapter);
1096 } else
1097 /* Emit D-Bus msg to all adapters */
1098 adapters = manager_get_adapters();
1099
1100 for (; adapters; adapters = adapters->next) {
1101 adapter = adapters->data;
1102
1103 if (insert == TRUE)
1104 adapter->services = sdp_list_insert_sorted(
1105 adapter->services, rec,
1106 record_sort);
1107 else
1108 adapter->services = sdp_list_remove(adapter->services,
1109 rec);
1110
1111 adapter_emit_uuids_updated(adapter);
1112 }
1113 }
1114
adapter_service_insert(const bdaddr_t * bdaddr,void * rec)1115 void adapter_service_insert(const bdaddr_t *bdaddr, void *rec)
1116 {
1117 /* TRUE to include service*/
1118 adapter_service_ins_rem(bdaddr, rec, TRUE);
1119 }
1120
adapter_service_remove(const bdaddr_t * bdaddr,void * rec)1121 void adapter_service_remove(const bdaddr_t *bdaddr, void *rec)
1122 {
1123 /* FALSE to remove service*/
1124 adapter_service_ins_rem(bdaddr, rec, FALSE);
1125 }
1126
adapter_get_services(struct btd_adapter * adapter)1127 sdp_list_t *adapter_get_services(struct btd_adapter *adapter)
1128 {
1129 return adapter->services;
1130 }
1131
adapter_create_device(DBusConnection * conn,struct btd_adapter * adapter,const char * address)1132 struct btd_device *adapter_create_device(DBusConnection *conn,
1133 struct btd_adapter *adapter,
1134 const char *address)
1135 {
1136 struct btd_device *device;
1137 const char *path;
1138
1139 DBG("%s", address);
1140
1141 device = device_create(conn, adapter, address);
1142 if (!device)
1143 return NULL;
1144
1145 device_set_temporary(device, TRUE);
1146
1147 adapter->devices = g_slist_append(adapter->devices, device);
1148
1149 path = device_get_path(device);
1150 g_dbus_emit_signal(conn, adapter->path,
1151 ADAPTER_INTERFACE, "DeviceCreated",
1152 DBUS_TYPE_OBJECT_PATH, &path,
1153 DBUS_TYPE_INVALID);
1154
1155 adapter_update_devices(adapter);
1156
1157 return device;
1158 }
1159
adapter_remove_device(DBusConnection * conn,struct btd_adapter * adapter,struct btd_device * device,gboolean remove_storage)1160 void adapter_remove_device(DBusConnection *conn, struct btd_adapter *adapter,
1161 struct btd_device *device,
1162 gboolean remove_storage)
1163 {
1164 const gchar *dev_path = device_get_path(device);
1165 struct agent *agent;
1166
1167 adapter->devices = g_slist_remove(adapter->devices, device);
1168 adapter->connections = g_slist_remove(adapter->connections, device);
1169
1170 adapter_update_devices(adapter);
1171
1172 g_dbus_emit_signal(conn, adapter->path,
1173 ADAPTER_INTERFACE, "DeviceRemoved",
1174 DBUS_TYPE_OBJECT_PATH, &dev_path,
1175 DBUS_TYPE_INVALID);
1176
1177 agent = device_get_agent(device);
1178
1179 if (agent && device_is_authorizing(device))
1180 agent_cancel(agent);
1181
1182 device_remove(device, remove_storage);
1183 }
1184
adapter_get_device(DBusConnection * conn,struct btd_adapter * adapter,const gchar * address)1185 struct btd_device *adapter_get_device(DBusConnection *conn,
1186 struct btd_adapter *adapter,
1187 const gchar *address)
1188 {
1189 struct btd_device *device;
1190
1191 DBG("%s", address);
1192
1193 if (!adapter)
1194 return NULL;
1195
1196 device = adapter_find_device(adapter, address);
1197 if (device)
1198 return device;
1199
1200 return adapter_create_device(conn, adapter, address);
1201 }
1202
adapter_start_inquiry(struct btd_adapter * adapter)1203 static int adapter_start_inquiry(struct btd_adapter *adapter)
1204 {
1205 gboolean periodic = TRUE;
1206
1207 if (main_opts.discov_interval)
1208 periodic = FALSE;
1209
1210 pending_remote_name_cancel(adapter);
1211
1212 return adapter_ops->start_discovery(adapter->dev_id, periodic);
1213 }
1214
adapter_start_discovery(DBusConnection * conn,DBusMessage * msg,void * data)1215 static DBusMessage *adapter_start_discovery(DBusConnection *conn,
1216 DBusMessage *msg, void *data)
1217 {
1218 struct session_req *req;
1219 struct btd_adapter *adapter = data;
1220 const char *sender = dbus_message_get_sender(msg);
1221 int err;
1222
1223 if (!adapter->up)
1224 return adapter_not_ready(msg);
1225
1226 req = find_session(adapter->disc_sessions, sender);
1227 if (req) {
1228 session_ref(req);
1229 return dbus_message_new_method_return(msg);
1230 }
1231
1232 if (adapter->disc_sessions)
1233 goto done;
1234
1235 if (main_opts.name_resolv)
1236 adapter->state |= RESOLVE_NAME;
1237
1238 err = adapter_start_inquiry(adapter);
1239 if (err < 0)
1240 return failed_strerror(msg, -err);
1241
1242 done:
1243 req = create_session(adapter, conn, msg, 0,
1244 session_owner_exit);
1245
1246 adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
1247
1248 return dbus_message_new_method_return(msg);
1249 }
1250
adapter_stop_discovery(DBusConnection * conn,DBusMessage * msg,void * data)1251 static DBusMessage *adapter_stop_discovery(DBusConnection *conn,
1252 DBusMessage *msg, void *data)
1253 {
1254 struct btd_adapter *adapter = data;
1255 struct session_req *req;
1256 const char *sender = dbus_message_get_sender(msg);
1257
1258 if (!adapter->up)
1259 return adapter_not_ready(msg);
1260
1261 req = find_session(adapter->disc_sessions, sender);
1262 if (!req)
1263 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1264 "Invalid discovery session");
1265
1266 session_unref(req);
1267 info("Stopping discovery");
1268 return dbus_message_new_method_return(msg);
1269 }
1270
1271 struct remote_device_list_t {
1272 GSList *list;
1273 time_t time;
1274 };
1275
get_properties(DBusConnection * conn,DBusMessage * msg,void * data)1276 static DBusMessage *get_properties(DBusConnection *conn,
1277 DBusMessage *msg, void *data)
1278 {
1279 struct btd_adapter *adapter = data;
1280 const char *property;
1281 DBusMessage *reply;
1282 DBusMessageIter iter;
1283 DBusMessageIter dict;
1284 char str[MAX_NAME_LENGTH + 1], srcaddr[18];
1285 gboolean value;
1286 char **devices, **uuids;
1287 int i;
1288 GSList *l;
1289 sdp_list_t *list;
1290
1291 ba2str(&adapter->bdaddr, srcaddr);
1292
1293 if (check_address(srcaddr) < 0)
1294 return adapter_not_ready(msg);
1295
1296 reply = dbus_message_new_method_return(msg);
1297 if (!reply)
1298 return NULL;
1299
1300 dbus_message_iter_init_append(reply, &iter);
1301
1302 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1303 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1304 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1305 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1306
1307 /* Address */
1308 property = srcaddr;
1309 dict_append_entry(&dict, "Address", DBUS_TYPE_STRING, &property);
1310
1311 /* Name */
1312 memset(str, 0, sizeof(str));
1313 strncpy(str, (char *) adapter->dev.name, MAX_NAME_LENGTH);
1314 property = str;
1315
1316 dict_append_entry(&dict, "Name", DBUS_TYPE_STRING, &property);
1317
1318 /* Class */
1319 dict_append_entry(&dict, "Class",
1320 DBUS_TYPE_UINT32, &adapter->current_cod);
1321
1322 /* Powered */
1323 value = (adapter->up && !adapter->off_requested) ? TRUE : FALSE;
1324 dict_append_entry(&dict, "Powered", DBUS_TYPE_BOOLEAN, &value);
1325
1326 /* Discoverable */
1327 value = adapter->scan_mode & SCAN_INQUIRY ? TRUE : FALSE;
1328 dict_append_entry(&dict, "Discoverable", DBUS_TYPE_BOOLEAN, &value);
1329
1330 /* Pairable */
1331 dict_append_entry(&dict, "Pairable", DBUS_TYPE_BOOLEAN,
1332 &adapter->pairable);
1333
1334 /* DiscoverableTimeout */
1335 dict_append_entry(&dict, "DiscoverableTimeout",
1336 DBUS_TYPE_UINT32, &adapter->discov_timeout);
1337
1338 /* PairableTimeout */
1339 dict_append_entry(&dict, "PairableTimeout",
1340 DBUS_TYPE_UINT32, &adapter->pairable_timeout);
1341
1342
1343 if (adapter->state & PERIODIC_INQUIRY || adapter->state & STD_INQUIRY)
1344 value = TRUE;
1345 else
1346 value = FALSE;
1347
1348 /* Discovering */
1349 dict_append_entry(&dict, "Discovering", DBUS_TYPE_BOOLEAN, &value);
1350
1351 /* Devices */
1352 devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
1353 for (i = 0, l = adapter->devices; l; l = l->next, i++) {
1354 struct btd_device *dev = l->data;
1355 devices[i] = (char *) device_get_path(dev);
1356 }
1357 dict_append_array(&dict, "Devices", DBUS_TYPE_OBJECT_PATH,
1358 &devices, i);
1359 g_free(devices);
1360
1361 /* UUIDs */
1362 uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
1363
1364 for (i = 0, list = adapter->services; list; list = list->next, i++) {
1365 sdp_record_t *rec = list->data;
1366 uuids[i] = bt_uuid2string(&rec->svclass);
1367 }
1368
1369 dict_append_array(&dict, "UUIDs", DBUS_TYPE_STRING, &uuids, i);
1370
1371 g_strfreev(uuids);
1372
1373 dbus_message_iter_close_container(&iter, &dict);
1374
1375 return reply;
1376 }
1377
set_property(DBusConnection * conn,DBusMessage * msg,void * data)1378 static DBusMessage *set_property(DBusConnection *conn,
1379 DBusMessage *msg, void *data)
1380 {
1381 struct btd_adapter *adapter = data;
1382 DBusMessageIter iter;
1383 DBusMessageIter sub;
1384 const char *property;
1385 char srcaddr[18];
1386
1387 ba2str(&adapter->bdaddr, srcaddr);
1388
1389 if (!dbus_message_iter_init(msg, &iter))
1390 return invalid_args(msg);
1391
1392 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
1393 return invalid_args(msg);
1394
1395 dbus_message_iter_get_basic(&iter, &property);
1396 dbus_message_iter_next(&iter);
1397
1398 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1399 return invalid_args(msg);
1400 dbus_message_iter_recurse(&iter, &sub);
1401
1402 if (g_str_equal("Name", property)) {
1403 const char *name;
1404
1405 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
1406 return invalid_args(msg);
1407 dbus_message_iter_get_basic(&sub, &name);
1408
1409 return set_name(conn, msg, name, data);
1410 } else if (g_str_equal("Powered", property)) {
1411 gboolean powered;
1412
1413 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1414 return invalid_args(msg);
1415
1416 dbus_message_iter_get_basic(&sub, &powered);
1417
1418 return set_powered(conn, msg, powered, data);
1419 } else if (g_str_equal("Discoverable", property)) {
1420 gboolean discoverable;
1421
1422 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1423 return invalid_args(msg);
1424
1425 dbus_message_iter_get_basic(&sub, &discoverable);
1426
1427 return set_discoverable(conn, msg, discoverable, data);
1428 } else if (g_str_equal("DiscoverableTimeout", property)) {
1429 uint32_t timeout;
1430
1431 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1432 return invalid_args(msg);
1433
1434 dbus_message_iter_get_basic(&sub, &timeout);
1435
1436 return set_discoverable_timeout(conn, msg, timeout, data);
1437 } else if (g_str_equal("Pairable", property)) {
1438 gboolean pairable;
1439
1440 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1441 return invalid_args(msg);
1442
1443 dbus_message_iter_get_basic(&sub, &pairable);
1444
1445 return set_pairable(conn, msg, pairable, data);
1446 } else if (g_str_equal("PairableTimeout", property)) {
1447 uint32_t timeout;
1448
1449 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1450 return invalid_args(msg);
1451
1452 dbus_message_iter_get_basic(&sub, &timeout);
1453
1454 return set_pairable_timeout(conn, msg, timeout, data);
1455 }
1456
1457 return invalid_args(msg);
1458 }
1459
request_session(DBusConnection * conn,DBusMessage * msg,void * data)1460 static DBusMessage *request_session(DBusConnection *conn,
1461 DBusMessage *msg, void *data)
1462 {
1463 struct btd_adapter *adapter = data;
1464 struct session_req *req;
1465 const char *sender = dbus_message_get_sender(msg);
1466 uint8_t new_mode;
1467 int err;
1468
1469 if (!adapter->agent)
1470 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1471 "No agent registered");
1472
1473 if (!adapter->mode_sessions)
1474 adapter->global_mode = adapter->mode;
1475
1476 new_mode = get_mode(&adapter->bdaddr, "on");
1477
1478 req = find_session(adapter->mode_sessions, sender);
1479 if (req) {
1480 session_ref(req);
1481 return dbus_message_new_method_return(msg);
1482 } else {
1483 req = create_session(adapter, conn, msg, new_mode,
1484 session_owner_exit);
1485 adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
1486 req);
1487 }
1488
1489 /* No need to change mode */
1490 if (adapter->mode >= new_mode)
1491 return dbus_message_new_method_return(msg);
1492
1493 err = agent_confirm_mode_change(adapter->agent, mode2str(new_mode),
1494 confirm_mode_cb, req, NULL);
1495 if (err < 0) {
1496 session_unref(req);
1497 return failed_strerror(msg, -err);
1498 }
1499
1500 return NULL;
1501 }
1502
release_session(DBusConnection * conn,DBusMessage * msg,void * data)1503 static DBusMessage *release_session(DBusConnection *conn,
1504 DBusMessage *msg, void *data)
1505 {
1506 struct btd_adapter *adapter = data;
1507 struct session_req *req;
1508 const char *sender = dbus_message_get_sender(msg);
1509
1510 req = find_session(adapter->mode_sessions, sender);
1511 if (!req)
1512 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1513 "No Mode to release");
1514
1515 session_unref(req);
1516
1517 return dbus_message_new_method_return(msg);
1518 }
1519
list_devices(DBusConnection * conn,DBusMessage * msg,void * data)1520 static DBusMessage *list_devices(DBusConnection *conn,
1521 DBusMessage *msg, void *data)
1522 {
1523 struct btd_adapter *adapter = data;
1524 DBusMessage *reply;
1525 GSList *l;
1526 DBusMessageIter iter;
1527 DBusMessageIter array_iter;
1528 const gchar *dev_path;
1529
1530 if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
1531 return invalid_args(msg);
1532
1533 reply = dbus_message_new_method_return(msg);
1534 if (!reply)
1535 return NULL;
1536
1537 dbus_message_iter_init_append(reply, &iter);
1538 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1539 DBUS_TYPE_OBJECT_PATH_AS_STRING, &array_iter);
1540
1541 for (l = adapter->devices; l; l = l->next) {
1542 struct btd_device *device = l->data;
1543
1544 dev_path = device_get_path(device);
1545
1546 dbus_message_iter_append_basic(&array_iter,
1547 DBUS_TYPE_OBJECT_PATH, &dev_path);
1548 }
1549
1550 dbus_message_iter_close_container(&iter, &array_iter);
1551
1552 return reply;
1553 }
1554
cancel_device_creation(DBusConnection * conn,DBusMessage * msg,void * data)1555 static DBusMessage *cancel_device_creation(DBusConnection *conn,
1556 DBusMessage *msg, void *data)
1557 {
1558 struct btd_adapter *adapter = data;
1559 const gchar *address, *sender = dbus_message_get_sender(msg);
1560 struct btd_device *device;
1561
1562 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1563 DBUS_TYPE_INVALID) == FALSE)
1564 return invalid_args(msg);
1565
1566 if (check_address(address) < 0)
1567 return invalid_args(msg);
1568
1569 device = adapter_find_device(adapter, address);
1570 if (!device || !device_is_creating(device, NULL))
1571 return not_in_progress(msg, "Device creation not in progress");
1572
1573 if (!device_is_creating(device, sender))
1574 return not_authorized(msg);
1575
1576 device_set_temporary(device, TRUE);
1577
1578 if (device_is_connected(device)) {
1579 device_request_disconnect(device, msg);
1580 return NULL;
1581 }
1582
1583 adapter_remove_device(conn, adapter, device, TRUE);
1584
1585 return dbus_message_new_method_return(msg);
1586 }
1587
create_device(DBusConnection * conn,DBusMessage * msg,void * data)1588 static DBusMessage *create_device(DBusConnection *conn,
1589 DBusMessage *msg, void *data)
1590 {
1591 struct btd_adapter *adapter = data;
1592 struct btd_device *device;
1593 const gchar *address;
1594
1595 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1596 DBUS_TYPE_INVALID) == FALSE)
1597 return invalid_args(msg);
1598
1599 if (check_address(address) < 0)
1600 return invalid_args(msg);
1601
1602 if (adapter_find_device(adapter, address))
1603 return g_dbus_create_error(msg,
1604 ERROR_INTERFACE ".AlreadyExists",
1605 "Device already exists");
1606
1607 DBG("%s", address);
1608
1609 device = adapter_create_device(conn, adapter, address);
1610 if (!device)
1611 return NULL;
1612
1613 device_browse(device, conn, msg, NULL, FALSE);
1614
1615 return NULL;
1616 }
1617
parse_io_capability(const char * capability)1618 static uint8_t parse_io_capability(const char *capability)
1619 {
1620 if (g_str_equal(capability, ""))
1621 return IO_CAPABILITY_DISPLAYYESNO;
1622 if (g_str_equal(capability, "DisplayOnly"))
1623 return IO_CAPABILITY_DISPLAYONLY;
1624 if (g_str_equal(capability, "DisplayYesNo"))
1625 return IO_CAPABILITY_DISPLAYYESNO;
1626 if (g_str_equal(capability, "KeyboardOnly"))
1627 return IO_CAPABILITY_KEYBOARDONLY;
1628 if (g_str_equal(capability, "NoInputNoOutput"))
1629 return IO_CAPABILITY_NOINPUTNOOUTPUT;
1630 return IO_CAPABILITY_INVALID;
1631 }
1632
create_paired_device_generic(DBusConnection * conn,DBusMessage * msg,void * data,const gboolean oob)1633 static DBusMessage *create_paired_device_generic(DBusConnection *conn,
1634 DBusMessage *msg, void *data, const gboolean oob)
1635 {
1636 struct btd_adapter *adapter = data;
1637 struct btd_device *device;
1638 const gchar *address, *agent_path, *capability, *sender;
1639 uint8_t cap;
1640
1641 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1642 DBUS_TYPE_OBJECT_PATH, &agent_path,
1643 DBUS_TYPE_STRING, &capability,
1644 DBUS_TYPE_INVALID) == FALSE)
1645 return invalid_args(msg);
1646
1647 if (check_address(address) < 0)
1648 return invalid_args(msg);
1649
1650 sender = dbus_message_get_sender(msg);
1651 if (adapter->agent &&
1652 agent_matches(adapter->agent, sender, agent_path)) {
1653 error("Refusing adapter agent usage as device specific one");
1654 return invalid_args(msg);
1655 }
1656
1657 cap = parse_io_capability(capability);
1658 if (cap == IO_CAPABILITY_INVALID)
1659 return invalid_args(msg);
1660
1661 device = adapter_get_device(conn, adapter, address);
1662 if (!device)
1663 return g_dbus_create_error(msg,
1664 ERROR_INTERFACE ".Failed",
1665 "Unable to create a new device object");
1666
1667 return device_create_bonding(device, conn, msg, agent_path, cap, oob);
1668 }
1669
create_paired_device_oob(DBusConnection * conn,DBusMessage * msg,void * data)1670 static DBusMessage *create_paired_device_oob(DBusConnection *conn,
1671 DBusMessage *msg, void *data)
1672 {
1673 return create_paired_device_generic(conn, msg, data, TRUE);
1674 }
1675
create_paired_device(DBusConnection * conn,DBusMessage * msg,void * data)1676 static DBusMessage *create_paired_device(DBusConnection *conn,
1677 DBusMessage *msg, void *data)
1678 {
1679 return create_paired_device_generic(conn, msg, data, FALSE);
1680 }
1681
device_path_cmp(struct btd_device * device,const gchar * path)1682 static gint device_path_cmp(struct btd_device *device, const gchar *path)
1683 {
1684 const gchar *dev_path = device_get_path(device);
1685
1686 return strcasecmp(dev_path, path);
1687 }
1688
remove_device(DBusConnection * conn,DBusMessage * msg,void * data)1689 static DBusMessage *remove_device(DBusConnection *conn, DBusMessage *msg,
1690 void *data)
1691 {
1692 struct btd_adapter *adapter = data;
1693 struct btd_device *device;
1694 const char *path;
1695 GSList *l;
1696
1697 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1698 DBUS_TYPE_INVALID) == FALSE)
1699 return invalid_args(msg);
1700
1701 l = g_slist_find_custom(adapter->devices,
1702 path, (GCompareFunc) device_path_cmp);
1703 if (!l)
1704 return g_dbus_create_error(msg,
1705 ERROR_INTERFACE ".DoesNotExist",
1706 "Device does not exist");
1707 device = l->data;
1708
1709 if (device_is_temporary(device) || device_is_busy(device))
1710 return g_dbus_create_error(msg,
1711 ERROR_INTERFACE ".DoesNotExist",
1712 "Device creation in progress");
1713
1714 device_set_temporary(device, TRUE);
1715
1716 if (!device_is_connected(device)) {
1717 adapter_remove_device(conn, adapter, device, TRUE);
1718 return dbus_message_new_method_return(msg);
1719 }
1720
1721 device_request_disconnect(device, msg);
1722 return NULL;
1723 }
1724
find_device(DBusConnection * conn,DBusMessage * msg,void * data)1725 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
1726 void *data)
1727 {
1728 struct btd_adapter *adapter = data;
1729 struct btd_device *device;
1730 DBusMessage *reply;
1731 const gchar *address;
1732 GSList *l;
1733 const gchar *dev_path;
1734
1735 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1736 DBUS_TYPE_INVALID))
1737 return invalid_args(msg);
1738
1739 l = g_slist_find_custom(adapter->devices,
1740 address, (GCompareFunc) device_address_cmp);
1741 if (!l)
1742 return g_dbus_create_error(msg,
1743 ERROR_INTERFACE ".DoesNotExist",
1744 "Device does not exist");
1745
1746 device = l->data;
1747
1748 reply = dbus_message_new_method_return(msg);
1749 if (!reply)
1750 return NULL;
1751
1752 dev_path = device_get_path(device);
1753
1754 dbus_message_append_args(reply,
1755 DBUS_TYPE_OBJECT_PATH, &dev_path,
1756 DBUS_TYPE_INVALID);
1757
1758 return reply;
1759 }
1760
agent_removed(struct agent * agent,struct btd_adapter * adapter)1761 static void agent_removed(struct agent *agent, struct btd_adapter *adapter)
1762 {
1763 adapter->agent = NULL;
1764 }
1765
1766
register_agent_generic(DBusConnection * conn,DBusMessage * msg,void * data,const char * path,const char * capability,const gboolean oob)1767 static DBusMessage *register_agent_generic(DBusConnection *conn, DBusMessage *msg,
1768 void *data, const char *path, const char *capability,
1769 const gboolean oob)
1770 {
1771 const char *name;
1772 struct agent *agent;
1773 struct btd_adapter *adapter = data;
1774 uint8_t cap;
1775
1776 if (adapter->agent)
1777 return g_dbus_create_error(msg,
1778 ERROR_INTERFACE ".AlreadyExists",
1779 "Agent already exists");
1780
1781 cap = parse_io_capability(capability);
1782 if (cap == IO_CAPABILITY_INVALID)
1783 return invalid_args(msg);
1784
1785 name = dbus_message_get_sender(msg);
1786
1787 agent = agent_create(adapter, name, path, cap, oob,
1788 (agent_remove_cb) agent_removed, adapter);
1789 if (!agent)
1790 return g_dbus_create_error(msg,
1791 ERROR_INTERFACE ".Failed",
1792 "Failed to create a new agent");
1793
1794 adapter->agent = agent;
1795
1796 DBG("Agent registered for hci%d at %s:%s", adapter->dev_id, name,
1797 path);
1798
1799 return dbus_message_new_method_return(msg);
1800 }
1801
register_agent_oob(DBusConnection * conn,DBusMessage * msg,void * data)1802 static DBusMessage *register_agent_oob(DBusConnection *conn, DBusMessage *msg,
1803 void *data)
1804 {
1805 const char *path, *capability;
1806 gboolean oob;
1807
1808 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1809 DBUS_TYPE_STRING, &capability,
1810 DBUS_TYPE_BOOLEAN, &oob, DBUS_TYPE_INVALID))
1811 return NULL;
1812
1813 return register_agent_generic(conn, msg, data, path, capability, oob);
1814 }
1815
register_agent(DBusConnection * conn,DBusMessage * msg,void * data)1816 static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg,
1817 void *data)
1818 {
1819 const char *path, *capability;
1820
1821 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1822 DBUS_TYPE_STRING, &capability, DBUS_TYPE_INVALID))
1823 return NULL;
1824
1825 return register_agent_generic(conn, msg, data, path, capability, FALSE);
1826 }
1827
unregister_agent(DBusConnection * conn,DBusMessage * msg,void * data)1828 static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg,
1829 void *data)
1830 {
1831 const char *path, *name;
1832 struct btd_adapter *adapter = data;
1833
1834 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1835 DBUS_TYPE_INVALID))
1836 return NULL;
1837
1838 name = dbus_message_get_sender(msg);
1839
1840 if (!adapter->agent || !agent_matches(adapter->agent, name, path))
1841 return g_dbus_create_error(msg,
1842 ERROR_INTERFACE ".DoesNotExist",
1843 "No such agent");
1844
1845 agent_free(adapter->agent);
1846 adapter->agent = NULL;
1847
1848 return dbus_message_new_method_return(msg);
1849 }
1850
create_rfcomm_record(struct btd_adapter * adapter,const char * name,uuid_t uuid,uint8_t channel)1851 static sdp_record_t *create_rfcomm_record(struct btd_adapter *adapter,
1852 const char *name, uuid_t uuid, uint8_t channel)
1853 {
1854 uuid_t root_uuid, l2cap_uuid, rfcomm_uuid;
1855 sdp_list_t *svclass, *root, *proto;
1856 sdp_record_t *record;
1857
1858 record = sdp_record_alloc();
1859 if (!record)
1860 return NULL;
1861
1862 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
1863 root = sdp_list_append(NULL, &root_uuid);
1864 sdp_set_browse_groups(record, root);
1865
1866 sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
1867 proto = sdp_list_append(NULL, sdp_list_append(NULL, &l2cap_uuid));
1868
1869 sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
1870 proto = sdp_list_append(proto, sdp_list_append(
1871 sdp_list_append(NULL, &rfcomm_uuid),
1872 sdp_data_alloc(SDP_UINT8, &channel)));
1873
1874 sdp_set_access_protos(record, sdp_list_append(NULL, proto));
1875
1876 svclass = sdp_list_append(NULL, &uuid);
1877 sdp_set_service_classes(record, svclass);
1878
1879 sdp_set_info_attr(record, name, NULL, NULL);
1880
1881 return record;
1882 }
1883
add_rfcomm_service_record(DBusConnection * conn,DBusMessage * msg,void * data)1884 static DBusMessage *add_rfcomm_service_record(DBusConnection *conn,
1885 DBusMessage *msg, void *data)
1886 {
1887 uuid_t uuid;
1888 const char *name;
1889 uint8_t channel;
1890 uint32_t *uuid_p;
1891 uint32_t uuid_net[4]; // network order
1892 uint64_t uuid_host[2]; // host
1893 sdp_record_t *record;
1894 struct btd_adapter *adapter = data;
1895
1896 DBusMessage *reply;
1897
1898 if (!dbus_message_get_args(msg, NULL,
1899 DBUS_TYPE_STRING, &name,
1900 DBUS_TYPE_UINT64, &uuid_host[0],
1901 DBUS_TYPE_UINT64, &uuid_host[1],
1902 DBUS_TYPE_UINT16, &channel,
1903 DBUS_TYPE_INVALID))
1904 return invalid_args(msg);
1905
1906 uuid_p = (uint32_t *)uuid_host;
1907 uuid_net[1] = htonl(*uuid_p++);
1908 uuid_net[0] = htonl(*uuid_p++);
1909 uuid_net[3] = htonl(*uuid_p++);
1910 uuid_net[2] = htonl(*uuid_p++);
1911
1912 sdp_uuid128_create(&uuid, (void *)uuid_net);
1913
1914 record = create_rfcomm_record(adapter, name, uuid, channel);
1915
1916 if (!record)
1917 return g_dbus_create_error(msg,
1918 ERROR_INTERFACE ".Failed",
1919 "Failed to create sdp record");
1920
1921 if (add_record_to_server(&adapter->bdaddr, record))
1922 return g_dbus_create_error(msg,
1923 ERROR_INTERFACE ".Failed",
1924 "Failed to register sdp record");
1925
1926 reply = dbus_message_new_method_return(msg);
1927 dbus_message_append_args(reply,
1928 DBUS_TYPE_UINT32, &record->handle,
1929 DBUS_TYPE_INVALID);
1930
1931 return reply;
1932 }
1933
remove_service_record(DBusConnection * conn,DBusMessage * msg,void * data)1934 static DBusMessage *remove_service_record(DBusConnection *conn,
1935 DBusMessage *msg, void *data)
1936 {
1937 struct btd_adapter *adapter = data;
1938 dbus_uint32_t handle;
1939
1940 if (!dbus_message_get_args(msg, NULL,
1941 DBUS_TYPE_UINT32, &handle,
1942 DBUS_TYPE_INVALID))
1943 return invalid_args(msg);
1944
1945 if (remove_record_from_server(handle))
1946 return g_dbus_create_error(msg,
1947 ERROR_INTERFACE ".Failed",
1948 "Failed to remove sdp record");
1949
1950 return dbus_message_new_method_return(msg);
1951 }
1952
read_local_oob_data(DBusConnection * conn,DBusMessage * msg,void * data)1953 static DBusMessage *read_local_oob_data(DBusConnection *conn,
1954 DBusMessage *msg, void *data)
1955 {
1956 struct btd_adapter *adapter = data;
1957 DBusMessage *reply;
1958
1959 uint8_t hash[16], randomizer[16];
1960 uint8_t *hash_ptr = hash;
1961 uint8_t *r_ptr = randomizer;
1962 int dd, err;
1963
1964 dd = hci_open_dev(adapter->dev_id);
1965
1966 if (dd < 0) {
1967 err = -errno;
1968 goto fail;
1969 }
1970
1971 err = hci_read_local_oob_data(dd, hash, randomizer, HCI_REQ_TIMEOUT);
1972
1973 hci_close_dev(dd);
1974
1975 if (err < 0) {
1976 err = -errno;
1977 goto fail;
1978 }
1979
1980 reply = dbus_message_new_method_return(msg);
1981 dbus_message_append_args(reply,
1982 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &hash_ptr, 16,
1983 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &r_ptr, 16,
1984 DBUS_TYPE_INVALID);
1985
1986 return reply;
1987 fail:
1988 return failed_strerror(msg, errno);
1989 }
1990
set_link_timeout(DBusConnection * conn,DBusMessage * msg,void * data)1991 static DBusMessage *set_link_timeout(DBusConnection *conn,
1992 DBusMessage *msg, void *data)
1993 {
1994 struct btd_adapter *adapter = data;
1995 struct btd_device *device;
1996 const char *path;
1997 GSList *l;
1998 uint32_t num_slots;
1999 int dd, err;
2000
2001 if (!dbus_message_get_args(msg, NULL,
2002 DBUS_TYPE_OBJECT_PATH, &path,
2003 DBUS_TYPE_UINT32, &num_slots,
2004 DBUS_TYPE_INVALID))
2005 return invalid_args(msg);
2006
2007 l = g_slist_find_custom(adapter->devices,
2008 path, (GCompareFunc) device_path_cmp);
2009 if (!l)
2010 return g_dbus_create_error(msg,
2011 ERROR_INTERFACE ".DoesNotExist",
2012 "Device does not exist");
2013 device = l->data;
2014 dd = hci_open_dev(adapter->dev_id);
2015
2016 if (dd < 0) {
2017 err = -errno;
2018 goto fail;
2019 }
2020
2021 err = hci_write_link_supervision_timeout(dd,
2022 htobs(device_get_handle(device)), htobs(num_slots), 1000);
2023 hci_close_dev(dd);
2024
2025 if (err < 0) {
2026 err = -errno;
2027 goto fail;
2028 }
2029 return dbus_message_new_method_return(msg);
2030 fail:
2031 return failed_strerror(msg, errno);
2032 }
2033
2034 static GDBusMethodTable adapter_methods[] = {
2035 { "GetProperties", "", "a{sv}",get_properties },
2036 { "SetProperty", "sv", "", set_property,
2037 G_DBUS_METHOD_FLAG_ASYNC},
2038 { "RequestSession", "", "", request_session,
2039 G_DBUS_METHOD_FLAG_ASYNC},
2040 { "ReleaseSession", "", "", release_session },
2041 { "StartDiscovery", "", "", adapter_start_discovery },
2042 { "StopDiscovery", "", "", adapter_stop_discovery,
2043 G_DBUS_METHOD_FLAG_ASYNC},
2044 { "ListDevices", "", "ao", list_devices,
2045 G_DBUS_METHOD_FLAG_DEPRECATED},
2046 { "CreateDevice", "s", "o", create_device,
2047 G_DBUS_METHOD_FLAG_ASYNC},
2048 { "CreatePairedDevice", "sos", "o", create_paired_device,
2049 G_DBUS_METHOD_FLAG_ASYNC},
2050 { "CreatePairedDeviceOutOfBand", "sos", "o", create_paired_device_oob,
2051 G_DBUS_METHOD_FLAG_ASYNC},
2052 { "CancelDeviceCreation","s", "", cancel_device_creation,
2053 G_DBUS_METHOD_FLAG_ASYNC},
2054 { "RemoveDevice", "o", "", remove_device,
2055 G_DBUS_METHOD_FLAG_ASYNC},
2056 { "FindDevice", "s", "o", find_device },
2057 { "ReadLocalOutOfBandData", "", "ayay", read_local_oob_data},
2058 { "RegisterAgent", "os", "", register_agent },
2059 { "RegisterAgent", "osb", "", register_agent_oob },
2060 { "UnregisterAgent", "o", "", unregister_agent },
2061 { "AddRfcommServiceRecord", "sttq", "u", add_rfcomm_service_record },
2062 { "RemoveServiceRecord", "u", "", remove_service_record },
2063 { "SetLinkTimeout", "ou", "", set_link_timeout },
2064 { }
2065 };
2066
2067 static GDBusSignalTable adapter_signals[] = {
2068 { "PropertyChanged", "sv" },
2069 { "DeviceCreated", "o" },
2070 { "DeviceRemoved", "o" },
2071 { "DeviceFound", "sa{sv}" },
2072 { "DeviceDisappeared", "s" },
2073 { }
2074 };
2075
get_inquiry_mode(struct hci_dev * dev)2076 static inline uint8_t get_inquiry_mode(struct hci_dev *dev)
2077 {
2078 if (dev->features[6] & LMP_EXT_INQ)
2079 return 2;
2080
2081 if (dev->features[3] & LMP_RSSI_INQ)
2082 return 1;
2083
2084 if (dev->manufacturer == 11 &&
2085 dev->hci_rev == 0x00 && dev->lmp_subver == 0x0757)
2086 return 1;
2087
2088 if (dev->manufacturer == 15) {
2089 if (dev->hci_rev == 0x03 && dev->lmp_subver == 0x6963)
2090 return 1;
2091 if (dev->hci_rev == 0x09 && dev->lmp_subver == 0x6963)
2092 return 1;
2093 if (dev->hci_rev == 0x00 && dev->lmp_subver == 0x6965)
2094 return 1;
2095 }
2096
2097 if (dev->manufacturer == 31 &&
2098 dev->hci_rev == 0x2005 && dev->lmp_subver == 0x1805)
2099 return 1;
2100
2101 return 0;
2102 }
2103
adapter_read_bdaddr(uint16_t dev_id,bdaddr_t * bdaddr)2104 static int adapter_read_bdaddr(uint16_t dev_id, bdaddr_t *bdaddr)
2105 {
2106 int dd, err;
2107
2108 dd = hci_open_dev(dev_id);
2109 if (dd < 0) {
2110 err = -errno;
2111 error("Can't open device hci%d: %s (%d)",
2112 dev_id, strerror(errno), errno);
2113 return err;
2114 }
2115
2116 if (hci_read_bd_addr(dd, bdaddr, HCI_REQ_TIMEOUT) < 0) {
2117 err = -errno;
2118 error("Can't read address for hci%d: %s (%d)",
2119 dev_id, strerror(errno), errno);
2120 hci_close_dev(dd);
2121 return err;
2122 }
2123
2124 hci_close_dev(dd);
2125
2126 return 0;
2127 }
2128
adapter_setup(struct btd_adapter * adapter,const char * mode)2129 static int adapter_setup(struct btd_adapter *adapter, const char *mode)
2130 {
2131 struct hci_dev *dev = &adapter->dev;
2132 uint8_t events[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00 };
2133 uint8_t inqmode;
2134 int err , dd;
2135 char name[MAX_NAME_LENGTH + 1];
2136 uint8_t cls[3];
2137
2138 dd = hci_open_dev(adapter->dev_id);
2139 if (dd < 0) {
2140 err = -errno;
2141 error("Can't open device hci%d: %s (%d)", adapter->dev_id,
2142 strerror(errno), errno);
2143 return err;
2144 }
2145
2146 if (dev->lmp_ver > 1) {
2147 if (dev->features[5] & LMP_SNIFF_SUBR)
2148 events[5] |= 0x20;
2149
2150 if (dev->features[5] & LMP_PAUSE_ENC)
2151 events[5] |= 0x80;
2152
2153 if (dev->features[6] & LMP_EXT_INQ)
2154 events[5] |= 0x40;
2155
2156 if (dev->features[6] & LMP_NFLUSH_PKTS)
2157 events[7] |= 0x01;
2158
2159 if (dev->features[7] & LMP_LSTO)
2160 events[6] |= 0x80;
2161
2162 if (dev->features[6] & LMP_SIMPLE_PAIR) {
2163 events[6] |= 0x01; /* IO Capability Request */
2164 events[6] |= 0x02; /* IO Capability Response */
2165 events[6] |= 0x04; /* User Confirmation Request */
2166 events[6] |= 0x08; /* User Passkey Request */
2167 events[6] |= 0x10; /* Remote OOB Data Request */
2168 events[6] |= 0x20; /* Simple Pairing Complete */
2169 events[7] |= 0x04; /* User Passkey Notification */
2170 events[7] |= 0x08; /* Keypress Notification */
2171 events[7] |= 0x10; /* Remote Host Supported
2172 * Features Notification */
2173 }
2174
2175 hci_send_cmd(dd, OGF_HOST_CTL, OCF_SET_EVENT_MASK,
2176 sizeof(events), events);
2177 }
2178
2179 inqmode = get_inquiry_mode(dev);
2180 if (inqmode < 1)
2181 goto done;
2182
2183 if (hci_write_inquiry_mode(dd, inqmode, HCI_REQ_TIMEOUT) < 0) {
2184 err = -errno;
2185 error("Can't write inquiry mode for %s: %s (%d)",
2186 adapter->path, strerror(errno), errno);
2187 hci_close_dev(dd);
2188 return err;
2189 }
2190
2191 if (dev->features[7] & LMP_INQ_TX_PWR)
2192 hci_send_cmd(dd, OGF_HOST_CTL,
2193 OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL, 0, NULL);
2194
2195 if (read_local_name(&adapter->bdaddr, name) < 0)
2196 expand_name(name, MAX_NAME_LENGTH, main_opts.name,
2197 adapter->dev_id);
2198
2199 adapter_ops->set_name(adapter->dev_id, name);
2200 if (g_str_equal(mode, "off"))
2201 strncpy((char *) adapter->dev.name, name, MAX_NAME_LENGTH);
2202
2203 /* Set device class */
2204 if (adapter->initialized && adapter->wanted_cod) {
2205 cls[1] = (adapter->wanted_cod >> 8) & 0xff;
2206 cls[0] = adapter->wanted_cod & 0xff;
2207 } else if (read_local_class(&adapter->bdaddr, cls) < 0) {
2208 uint32_t class = htobl(main_opts.class);
2209 if (class)
2210 memcpy(cls, &class, 3);
2211 else
2212 goto done;
2213 }
2214
2215 btd_adapter_set_class(adapter, cls[1], cls[0]);
2216 done:
2217 hci_close_dev(dd);
2218 return 0;
2219 }
2220
create_stored_device_from_profiles(char * key,char * value,void * user_data)2221 static void create_stored_device_from_profiles(char *key, char *value,
2222 void *user_data)
2223 {
2224 struct btd_adapter *adapter = user_data;
2225 GSList *uuids = bt_string2list(value);
2226 struct btd_device *device;
2227
2228 if (g_slist_find_custom(adapter->devices,
2229 key, (GCompareFunc) device_address_cmp))
2230 return;
2231
2232 device = device_create(connection, adapter, key);
2233 if (!device)
2234 return;
2235
2236 device_set_temporary(device, FALSE);
2237 adapter->devices = g_slist_append(adapter->devices, device);
2238
2239 device_probe_drivers(device, uuids);
2240
2241 g_slist_foreach(uuids, (GFunc) g_free, NULL);
2242 g_slist_free(uuids);
2243 }
2244
create_stored_device_from_linkkeys(char * key,char * value,void * user_data)2245 static void create_stored_device_from_linkkeys(char *key, char *value,
2246 void *user_data)
2247 {
2248 struct btd_adapter *adapter = user_data;
2249 struct btd_device *device;
2250
2251 if (g_slist_find_custom(adapter->devices, key,
2252 (GCompareFunc) device_address_cmp))
2253 return;
2254
2255 device = device_create(connection, adapter, key);
2256 if (device) {
2257 device_set_temporary(device, FALSE);
2258 adapter->devices = g_slist_append(adapter->devices, device);
2259 }
2260 }
2261
create_stored_device_from_blocked(char * key,char * value,void * user_data)2262 static void create_stored_device_from_blocked(char *key, char *value,
2263 void *user_data)
2264 {
2265 struct btd_adapter *adapter = user_data;
2266 struct btd_device *device;
2267
2268 if (g_slist_find_custom(adapter->devices,
2269 key, (GCompareFunc) device_address_cmp))
2270 return;
2271
2272 device = device_create(connection, adapter, key);
2273 if (device) {
2274 device_set_temporary(device, FALSE);
2275 adapter->devices = g_slist_append(adapter->devices, device);
2276 }
2277 }
2278
load_devices(struct btd_adapter * adapter)2279 static void load_devices(struct btd_adapter *adapter)
2280 {
2281 char filename[PATH_MAX + 1];
2282 char srcaddr[18];
2283
2284 ba2str(&adapter->bdaddr, srcaddr);
2285
2286 create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "profiles");
2287 textfile_foreach(filename, create_stored_device_from_profiles,
2288 adapter);
2289
2290 create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "linkkeys");
2291 textfile_foreach(filename, create_stored_device_from_linkkeys,
2292 adapter);
2293
2294 create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "blocked");
2295 textfile_foreach(filename, create_stored_device_from_blocked, adapter);
2296 }
2297
clear_blocked(struct btd_adapter * adapter)2298 static void clear_blocked(struct btd_adapter *adapter)
2299 {
2300 int dd;
2301
2302 dd = hci_open_dev(adapter->dev_id);
2303 if (dd < 0) {
2304 error("hci_open_dev(hci%d): %s (%d)", adapter->dev_id,
2305 strerror(errno), errno);
2306 return;
2307 }
2308
2309 if (ioctl(dd, HCIUNBLOCKADDR, BDADDR_ANY) < 0)
2310 error("ioctl(HCIUNBLOCKADDR): %s (%d)", strerror(errno), errno);
2311
2312 hci_close_dev(dd);
2313 }
2314
probe_driver(gpointer data,gpointer user_data)2315 static void probe_driver(gpointer data, gpointer user_data)
2316 {
2317 struct btd_adapter *adapter = data;
2318 struct btd_adapter_driver *driver = user_data;
2319 int err;
2320
2321 if (!adapter->up)
2322 return;
2323
2324 err = driver->probe(adapter);
2325 if (err < 0)
2326 error("%s: %s (%d)", driver->name, strerror(-err), -err);
2327 }
2328
load_drivers(struct btd_adapter * adapter)2329 static void load_drivers(struct btd_adapter *adapter)
2330 {
2331 GSList *l;
2332
2333 for (l = adapter_drivers; l; l = l->next) {
2334 struct btd_adapter_driver *driver = l->data;
2335
2336 if (driver->probe == NULL)
2337 continue;
2338
2339 probe_driver(adapter, driver);
2340 }
2341 }
2342
load_connections(struct btd_adapter * adapter)2343 static void load_connections(struct btd_adapter *adapter)
2344 {
2345 struct hci_conn_list_req *cl = NULL;
2346 struct hci_conn_info *ci;
2347 int i, dd;
2348
2349 dd = hci_open_dev(adapter->dev_id);
2350 if (dd < 0)
2351 return;
2352
2353 cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl));
2354
2355 cl->dev_id = adapter->dev_id;
2356 cl->conn_num = 10;
2357 ci = cl->conn_info;
2358
2359 if (ioctl(dd, HCIGETCONNLIST, cl) != 0) {
2360 g_free(cl);
2361 hci_close_dev(dd);
2362 return;
2363 }
2364
2365 for (i = 0; i < cl->conn_num; i++, ci++) {
2366 struct btd_device *device;
2367 char address[18];
2368
2369 ba2str(&ci->bdaddr, address);
2370 device = adapter_get_device(connection, adapter, address);
2371 if (device)
2372 adapter_add_connection(adapter, device, ci->handle);
2373 }
2374
2375 g_free(cl);
2376 hci_close_dev(dd);
2377 }
2378
get_discoverable_timeout(const char * src)2379 static int get_discoverable_timeout(const char *src)
2380 {
2381 int timeout;
2382
2383 if (read_discoverable_timeout(src, &timeout) == 0)
2384 return timeout;
2385
2386 return main_opts.discovto;
2387 }
2388
get_pairable_timeout(const char * src)2389 static int get_pairable_timeout(const char *src)
2390 {
2391 int timeout;
2392
2393 if (read_pairable_timeout(src, &timeout) == 0)
2394 return timeout;
2395
2396 return main_opts.pairto;
2397 }
2398
adapter_disable_cod_cache(struct btd_adapter * adapter)2399 static void adapter_disable_cod_cache(struct btd_adapter *adapter)
2400 {
2401 int err;
2402
2403 if (!adapter)
2404 return;
2405
2406 if (!adapter->cache_enable)
2407 return;
2408
2409 /* Disable and flush svc cache. All successive service class updates
2410 will be written to the device */
2411 adapter->cache_enable = FALSE;
2412
2413 if (adapter->current_cod == adapter->wanted_cod)
2414 return;
2415
2416 err = adapter_ops->set_class(adapter->dev_id, adapter->wanted_cod);
2417 if (err < 0)
2418 error("Adapter class update failed: %s(%d)",
2419 strerror(err), err);
2420 else
2421 adapter->pending_cod = adapter->wanted_cod;
2422 }
2423
adapter_up(struct btd_adapter * adapter,const char * mode)2424 static int adapter_up(struct btd_adapter *adapter, const char *mode)
2425 {
2426 char srcaddr[18];
2427 uint8_t scan_mode;
2428 gboolean powered, dev_down = FALSE;
2429 int err;
2430
2431 ba2str(&adapter->bdaddr, srcaddr);
2432
2433 adapter->off_requested = FALSE;
2434 adapter->up = 1;
2435 adapter->discov_timeout = get_discoverable_timeout(srcaddr);
2436 adapter->pairable_timeout = get_pairable_timeout(srcaddr);
2437 adapter->state = DISCOVER_TYPE_NONE;
2438 adapter->mode = MODE_CONNECTABLE;
2439 adapter->cache_enable = TRUE;
2440 scan_mode = SCAN_PAGE;
2441 powered = TRUE;
2442
2443 /* Set pairable mode */
2444 if (read_device_pairable(&adapter->bdaddr, &adapter->pairable) < 0)
2445 adapter->pairable = TRUE;
2446
2447 if (g_str_equal(mode, "off")) {
2448 char onmode[14];
2449
2450 powered = FALSE;
2451
2452 if (!adapter->initialized) {
2453 dev_down = TRUE;
2454 goto proceed;
2455 }
2456
2457 if (read_on_mode(srcaddr, onmode, sizeof(onmode)) < 0 ||
2458 g_str_equal(onmode, "off"))
2459 strcpy(onmode, "connectable");
2460
2461 write_device_mode(&adapter->bdaddr, onmode);
2462
2463 return adapter_up(adapter, onmode);
2464 } else if (!g_str_equal(mode, "connectable") &&
2465 adapter->discov_timeout == 0) {
2466 /* Set discoverable only if timeout is 0 */
2467 adapter->mode = MODE_DISCOVERABLE;
2468 scan_mode = SCAN_PAGE | SCAN_INQUIRY;
2469 }
2470
2471 proceed:
2472 if (scan_mode == SCAN_PAGE)
2473 err = adapter_ops->set_connectable(adapter->dev_id);
2474 else
2475 err = adapter_ops->set_discoverable(adapter->dev_id);
2476
2477 if (err < 0)
2478 return err;
2479
2480 if (adapter->initialized == FALSE) {
2481 load_drivers(adapter);
2482 clear_blocked(adapter);
2483 load_devices(adapter);
2484
2485 /* retrieve the active connections: address the scenario where
2486 * the are active connections before the daemon've started */
2487 load_connections(adapter);
2488
2489 adapter->initialized = TRUE;
2490
2491 manager_add_adapter(adapter->path);
2492
2493 }
2494
2495 if (dev_down) {
2496 adapter_ops->stop(adapter->dev_id);
2497 adapter->off_requested = TRUE;
2498 return 1;
2499 } else
2500 emit_property_changed(connection, adapter->path,
2501 ADAPTER_INTERFACE, "Powered",
2502 DBUS_TYPE_BOOLEAN, &powered);
2503
2504 adapter_disable_cod_cache(adapter);
2505
2506 return 0;
2507 }
2508
adapter_start(struct btd_adapter * adapter)2509 int adapter_start(struct btd_adapter *adapter)
2510 {
2511 struct hci_dev *dev = &adapter->dev;
2512 struct hci_dev_info di;
2513 struct hci_version ver;
2514 uint8_t features[8];
2515 int dd, err;
2516 char mode[14], address[18];
2517
2518 if (hci_devinfo(adapter->dev_id, &di) < 0)
2519 return -errno;
2520
2521 if (hci_test_bit(HCI_RAW, &di.flags)) {
2522 dev->ignore = 1;
2523 return -1;
2524 }
2525
2526 if (!bacmp(&di.bdaddr, BDADDR_ANY)) {
2527 int err;
2528
2529 DBG("Adapter %s without an address", adapter->path);
2530
2531 err = adapter_read_bdaddr(adapter->dev_id, &di.bdaddr);
2532 if (err < 0)
2533 return err;
2534 }
2535
2536 bacpy(&adapter->bdaddr, &di.bdaddr);
2537 memcpy(dev->features, di.features, 8);
2538 ba2str(&adapter->bdaddr, address);
2539
2540 err = read_device_mode(address, mode, sizeof(mode));
2541
2542 if ((!adapter->initialized && !main_opts.remember_powered) || err < 0) {
2543 if (!adapter->initialized && main_opts.mode == MODE_OFF)
2544 strcpy(mode, "off");
2545 else
2546 strcpy(mode, "connectable");
2547 }
2548
2549 dd = hci_open_dev(adapter->dev_id);
2550 if (dd < 0) {
2551 err = -errno;
2552 error("Can't open adapter %s: %s (%d)",
2553 adapter->path, strerror(errno), errno);
2554 return err;
2555 }
2556
2557 if (hci_read_local_version(dd, &ver, HCI_REQ_TIMEOUT) < 0) {
2558 err = -errno;
2559 error("Can't read version info for %s: %s (%d)",
2560 adapter->path, strerror(errno), errno);
2561 hci_close_dev(dd);
2562 return err;
2563 }
2564
2565 dev->hci_rev = ver.hci_rev;
2566 dev->lmp_ver = ver.lmp_ver;
2567 dev->lmp_subver = ver.lmp_subver;
2568 dev->manufacturer = ver.manufacturer;
2569
2570 if (hci_read_local_features(dd, features, HCI_REQ_TIMEOUT) < 0) {
2571 err = -errno;
2572 error("Can't read features for %s: %s (%d)",
2573 adapter->path, strerror(errno), errno);
2574 hci_close_dev(dd);
2575 return err;
2576 }
2577
2578 memcpy(dev->features, features, 8);
2579
2580 adapter_ops->read_name(adapter->dev_id);
2581
2582 if (!(features[6] & LMP_SIMPLE_PAIR))
2583 goto setup;
2584
2585 if (ioctl(dd, HCIGETAUTHINFO, NULL) < 0 && errno != EINVAL)
2586 hci_write_simple_pairing_mode(dd, 0x01, HCI_REQ_TIMEOUT);
2587
2588 if (hci_read_simple_pairing_mode(dd, &dev->ssp_mode,
2589 HCI_REQ_TIMEOUT) < 0) {
2590 err = -errno;
2591 error("Can't read simple pairing mode on %s: %s (%d)",
2592 adapter->path, strerror(errno), errno);
2593 /* Fall through since some chips have broken
2594 * read_simple_pairing_mode behavior */
2595 }
2596
2597 setup:
2598 hci_send_cmd(dd, OGF_LINK_POLICY, OCF_READ_DEFAULT_LINK_POLICY,
2599 0, NULL);
2600 hci_close_dev(dd);
2601
2602 adapter->current_cod = 0;
2603
2604 adapter_setup(adapter, mode);
2605
2606 if (!adapter->initialized && adapter->already_up) {
2607 DBG("Stopping Inquiry at adapter startup");
2608 adapter_ops->stop_discovery(adapter->dev_id);
2609 }
2610
2611 err = adapter_up(adapter, mode);
2612
2613 info("Adapter %s has been enabled", adapter->path);
2614
2615 return err;
2616 }
2617
reply_pending_requests(struct btd_adapter * adapter)2618 static void reply_pending_requests(struct btd_adapter *adapter)
2619 {
2620 GSList *l;
2621
2622 if (!adapter)
2623 return;
2624
2625 /* pending bonding */
2626 for (l = adapter->devices; l; l = l->next) {
2627 struct btd_device *device = l->data;
2628
2629 if (device_is_bonding(device, NULL))
2630 device_cancel_bonding(device,
2631 HCI_OE_USER_ENDED_CONNECTION);
2632 }
2633
2634 if (adapter->state & STD_INQUIRY || adapter->state & PERIODIC_INQUIRY) {
2635 /* Cancel inquiry initiated by D-Bus client */
2636 if (adapter->disc_sessions)
2637 adapter_ops->stop_discovery(adapter->dev_id);
2638 }
2639 }
2640
unload_drivers(struct btd_adapter * adapter)2641 static void unload_drivers(struct btd_adapter *adapter)
2642 {
2643 GSList *l;
2644
2645 for (l = adapter_drivers; l; l = l->next) {
2646 struct btd_adapter_driver *driver = l->data;
2647
2648 if (driver->remove)
2649 driver->remove(adapter);
2650 }
2651 }
2652
adapter_stop(struct btd_adapter * adapter)2653 int adapter_stop(struct btd_adapter *adapter)
2654 {
2655 gboolean powered, discoverable, pairable;
2656
2657 /* cancel pending timeout */
2658 if (adapter->discov_timeout_id) {
2659 g_source_remove(adapter->discov_timeout_id);
2660 adapter->discov_timeout_id = 0;
2661 }
2662
2663 /* check pending requests */
2664 reply_pending_requests(adapter);
2665
2666 if (adapter->disc_sessions) {
2667 g_slist_foreach(adapter->disc_sessions, (GFunc) session_free,
2668 NULL);
2669 g_slist_free(adapter->disc_sessions);
2670 adapter->disc_sessions = NULL;
2671 }
2672
2673 clear_found_devices_list(adapter);
2674
2675 if (adapter->oor_devices) {
2676 g_slist_free(adapter->oor_devices);
2677 adapter->oor_devices = NULL;
2678 }
2679
2680 while (adapter->connections) {
2681 struct btd_device *device = adapter->connections->data;
2682 adapter_remove_connection(adapter, device, 0);
2683 }
2684
2685 if (adapter->scan_mode == (SCAN_PAGE | SCAN_INQUIRY)) {
2686 discoverable = FALSE;
2687 emit_property_changed(connection, adapter->path,
2688 ADAPTER_INTERFACE, "Discoverable",
2689 DBUS_TYPE_BOOLEAN, &discoverable);
2690 }
2691
2692 if ((adapter->scan_mode & SCAN_PAGE) && adapter->pairable == TRUE) {
2693 pairable = FALSE;
2694 emit_property_changed(connection, adapter->path,
2695 ADAPTER_INTERFACE, "Pairable",
2696 DBUS_TYPE_BOOLEAN, &pairable);
2697 }
2698
2699 powered = FALSE;
2700 emit_property_changed(connection, adapter->path, ADAPTER_INTERFACE,
2701 "Powered", DBUS_TYPE_BOOLEAN, &powered);
2702
2703 adapter->up = 0;
2704 adapter->scan_mode = SCAN_DISABLED;
2705 adapter->mode = MODE_OFF;
2706 adapter->state = DISCOVER_TYPE_NONE;
2707 adapter->cache_enable = TRUE;
2708 adapter->pending_cod = 0;
2709
2710 info("Adapter %s has been disabled", adapter->path);
2711
2712 return 0;
2713 }
2714
adapter_update(struct btd_adapter * adapter,uint8_t new_svc)2715 int adapter_update(struct btd_adapter *adapter, uint8_t new_svc)
2716 {
2717 struct hci_dev *dev = &adapter->dev;
2718
2719 if (dev->ignore)
2720 return 0;
2721
2722 adapter_set_service_classes(adapter, new_svc);
2723
2724 return 0;
2725 }
2726
adapter_update_ssp_mode(struct btd_adapter * adapter,uint8_t mode)2727 int adapter_update_ssp_mode(struct btd_adapter *adapter, uint8_t mode)
2728 {
2729 struct hci_dev *dev = &adapter->dev;
2730
2731 dev->ssp_mode = mode;
2732
2733 update_ext_inquiry_response(adapter);
2734
2735 return 0;
2736 }
2737
adapter_free(gpointer user_data)2738 static void adapter_free(gpointer user_data)
2739 {
2740 struct btd_adapter *adapter = user_data;
2741
2742 agent_free(adapter->agent);
2743 adapter->agent = NULL;
2744
2745 DBG("%p", adapter);
2746
2747 if (adapter->auth_idle_id)
2748 g_source_remove(adapter->auth_idle_id);
2749
2750 g_free(adapter->path);
2751 g_free(adapter);
2752 }
2753
btd_adapter_ref(struct btd_adapter * adapter)2754 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
2755 {
2756 adapter->ref++;
2757
2758 DBG("%p: ref=%d", adapter, adapter->ref);
2759
2760 return adapter;
2761 }
2762
btd_adapter_unref(struct btd_adapter * adapter)2763 void btd_adapter_unref(struct btd_adapter *adapter)
2764 {
2765 gchar *path;
2766
2767 adapter->ref--;
2768
2769 DBG("%p: ref=%d", adapter, adapter->ref);
2770
2771 if (adapter->ref > 0)
2772 return;
2773
2774 path = g_strdup(adapter->path);
2775
2776 g_dbus_unregister_interface(connection, path, ADAPTER_INTERFACE);
2777
2778 g_free(path);
2779 }
2780
adapter_create(DBusConnection * conn,int id,gboolean devup)2781 struct btd_adapter *adapter_create(DBusConnection *conn, int id,
2782 gboolean devup)
2783 {
2784 char path[MAX_PATH_LENGTH];
2785 struct btd_adapter *adapter;
2786 const char *base_path = manager_get_base_path();
2787
2788 if (!connection)
2789 connection = conn;
2790
2791 snprintf(path, sizeof(path), "%s/hci%d", base_path, id);
2792
2793 adapter = g_try_new0(struct btd_adapter, 1);
2794 if (!adapter) {
2795 error("adapter_create: failed to alloc memory for %s", path);
2796 return NULL;
2797 }
2798
2799 adapter->dev_id = id;
2800 if (main_opts.name_resolv)
2801 adapter->state |= RESOLVE_NAME;
2802 adapter->path = g_strdup(path);
2803 adapter->already_up = devup;
2804
2805 adapter->tx_power = 0;
2806
2807 if (!g_dbus_register_interface(conn, path, ADAPTER_INTERFACE,
2808 adapter_methods, adapter_signals, NULL,
2809 adapter, adapter_free)) {
2810 error("Adapter interface init failed on path %s", path);
2811 adapter_free(adapter);
2812 return NULL;
2813 }
2814
2815 return btd_adapter_ref(adapter);
2816 }
2817
adapter_remove(struct btd_adapter * adapter)2818 void adapter_remove(struct btd_adapter *adapter)
2819 {
2820 GSList *l;
2821
2822 DBG("Removing adapter %s", adapter->path);
2823
2824 for (l = adapter->devices; l; l = l->next)
2825 device_remove(l->data, FALSE);
2826 g_slist_free(adapter->devices);
2827
2828 if (adapter->initialized)
2829 unload_drivers(adapter);
2830
2831 /* Return adapter to down state if it was not up on init */
2832 if (adapter->up && !adapter->already_up)
2833 adapter_ops->stop(adapter->dev_id);
2834
2835 btd_adapter_unref(adapter);
2836 }
2837
adapter_get_dev_id(struct btd_adapter * adapter)2838 uint16_t adapter_get_dev_id(struct btd_adapter *adapter)
2839 {
2840 return adapter->dev_id;
2841 }
2842
adapter_get_path(struct btd_adapter * adapter)2843 const gchar *adapter_get_path(struct btd_adapter *adapter)
2844 {
2845 if (!adapter)
2846 return NULL;
2847
2848 return adapter->path;
2849 }
2850
adapter_get_address(struct btd_adapter * adapter,bdaddr_t * bdaddr)2851 void adapter_get_address(struct btd_adapter *adapter, bdaddr_t *bdaddr)
2852 {
2853 bacpy(bdaddr, &adapter->bdaddr);
2854 }
2855
adapter_set_state(struct btd_adapter * adapter,int state)2856 void adapter_set_state(struct btd_adapter *adapter, int state)
2857 {
2858 gboolean discov_active = FALSE;
2859 const char *path = adapter->path;
2860
2861 if (adapter->state == state)
2862 return;
2863
2864 if (state & PERIODIC_INQUIRY || state & STD_INQUIRY)
2865 discov_active = TRUE;
2866 else if (adapter->disc_sessions && main_opts.discov_interval)
2867 adapter->scheduler_id = g_timeout_add_seconds(
2868 main_opts.discov_interval,
2869 (GSourceFunc) adapter_start_inquiry,
2870 adapter);
2871
2872 /* Send out of range */
2873 if (!discov_active)
2874 adapter_update_oor_devices(adapter);
2875
2876 emit_property_changed(connection, path,
2877 ADAPTER_INTERFACE, "Discovering",
2878 DBUS_TYPE_BOOLEAN, &discov_active);
2879
2880 adapter->state = state;
2881 }
2882
adapter_get_state(struct btd_adapter * adapter)2883 int adapter_get_state(struct btd_adapter *adapter)
2884 {
2885 return adapter->state;
2886 }
2887
adapter_is_ready(struct btd_adapter * adapter)2888 gboolean adapter_is_ready(struct btd_adapter *adapter)
2889 {
2890 return adapter->initialized;
2891 }
2892
adapter_search_found_devices(struct btd_adapter * adapter,struct remote_dev_info * match)2893 struct remote_dev_info *adapter_search_found_devices(struct btd_adapter *adapter,
2894 struct remote_dev_info *match)
2895 {
2896 GSList *l;
2897
2898 l = g_slist_find_custom(adapter->found_devices, match,
2899 (GCompareFunc) found_device_cmp);
2900 if (l)
2901 return l->data;
2902
2903 return NULL;
2904 }
2905
dev_rssi_cmp(struct remote_dev_info * d1,struct remote_dev_info * d2)2906 static int dev_rssi_cmp(struct remote_dev_info *d1, struct remote_dev_info *d2)
2907 {
2908 int rssi1, rssi2;
2909
2910 rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi;
2911 rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi;
2912
2913 return rssi1 - rssi2;
2914 }
2915
append_dict_valist(DBusMessageIter * iter,const char * first_key,va_list var_args)2916 static void append_dict_valist(DBusMessageIter *iter,
2917 const char *first_key,
2918 va_list var_args)
2919 {
2920 DBusMessageIter dict;
2921 const char *key;
2922 int type;
2923 void *val;
2924
2925 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
2926 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2927 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
2928 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
2929
2930 key = first_key;
2931 while (key) {
2932 type = va_arg(var_args, int);
2933 val = va_arg(var_args, void *);
2934 dict_append_entry(&dict, key, type, val);
2935 key = va_arg(var_args, char *);
2936 }
2937
2938 dbus_message_iter_close_container(iter, &dict);
2939 }
2940
emit_device_found(const char * path,const char * address,const char * first_key,...)2941 static void emit_device_found(const char *path, const char *address,
2942 const char *first_key, ...)
2943 {
2944 DBusMessage *signal;
2945 DBusMessageIter iter;
2946 va_list var_args;
2947
2948 signal = dbus_message_new_signal(path, ADAPTER_INTERFACE,
2949 "DeviceFound");
2950 if (!signal) {
2951 error("Unable to allocate new %s.DeviceFound signal",
2952 ADAPTER_INTERFACE);
2953 return;
2954 }
2955 dbus_message_iter_init_append(signal, &iter);
2956 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &address);
2957
2958 va_start(var_args, first_key);
2959 append_dict_valist(&iter, first_key, var_args);
2960 va_end(var_args);
2961
2962 g_dbus_send_message(connection, signal);
2963 }
2964
adapter_emit_device_found(struct btd_adapter * adapter,struct remote_dev_info * dev)2965 void adapter_emit_device_found(struct btd_adapter *adapter,
2966 struct remote_dev_info *dev)
2967 {
2968 struct btd_device *device;
2969 char peer_addr[18], local_addr[18];
2970 const char *icon, *paddr = peer_addr;
2971 dbus_bool_t paired = FALSE;
2972 dbus_int16_t rssi = dev->rssi;
2973 char *alias;
2974
2975 ba2str(&dev->bdaddr, peer_addr);
2976 ba2str(&adapter->bdaddr, local_addr);
2977
2978 device = adapter_find_device(adapter, paddr);
2979 if (device)
2980 paired = device_is_paired(device);
2981
2982 icon = class_to_icon(dev->class);
2983
2984 if (!dev->alias) {
2985 if (!dev->name) {
2986 alias = g_strdup(peer_addr);
2987 g_strdelimit(alias, ":", '-');
2988 } else
2989 alias = g_strdup(dev->name);
2990 } else
2991 alias = g_strdup(dev->alias);
2992
2993 emit_device_found(adapter->path, paddr,
2994 "Address", DBUS_TYPE_STRING, &paddr,
2995 "Class", DBUS_TYPE_UINT32, &dev->class,
2996 "Icon", DBUS_TYPE_STRING, &icon,
2997 "RSSI", DBUS_TYPE_INT16, &rssi,
2998 "Name", DBUS_TYPE_STRING, &dev->name,
2999 "Alias", DBUS_TYPE_STRING, &alias,
3000 "LegacyPairing", DBUS_TYPE_BOOLEAN, &dev->legacy,
3001 "Paired", DBUS_TYPE_BOOLEAN, &paired,
3002 NULL);
3003
3004 g_free(alias);
3005 }
3006
adapter_update_found_devices(struct btd_adapter * adapter,bdaddr_t * bdaddr,int8_t rssi,uint32_t class,const char * name,const char * alias,gboolean legacy,name_status_t name_status)3007 void adapter_update_found_devices(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3008 int8_t rssi, uint32_t class, const char *name,
3009 const char *alias, gboolean legacy,
3010 name_status_t name_status)
3011 {
3012 struct remote_dev_info *dev, match;
3013
3014 memset(&match, 0, sizeof(struct remote_dev_info));
3015 bacpy(&match.bdaddr, bdaddr);
3016 match.name_status = NAME_ANY;
3017
3018 dev = adapter_search_found_devices(adapter, &match);
3019 if (dev) {
3020 /* Out of range list update */
3021 adapter->oor_devices = g_slist_remove(adapter->oor_devices,
3022 dev);
3023
3024 if (rssi == dev->rssi)
3025 return;
3026
3027 goto done;
3028 }
3029
3030 dev = g_new0(struct remote_dev_info, 1);
3031
3032 bacpy(&dev->bdaddr, bdaddr);
3033 dev->class = class;
3034 if (name)
3035 dev->name = g_strdup(name);
3036 if (alias)
3037 dev->alias = g_strdup(alias);
3038 dev->legacy = legacy;
3039 dev->name_status = name_status;
3040
3041 adapter->found_devices = g_slist_prepend(adapter->found_devices, dev);
3042
3043 done:
3044 dev->rssi = rssi;
3045
3046 adapter->found_devices = g_slist_sort(adapter->found_devices,
3047 (GCompareFunc) dev_rssi_cmp);
3048
3049 adapter_emit_device_found(adapter, dev);
3050 }
3051
adapter_remove_found_device(struct btd_adapter * adapter,bdaddr_t * bdaddr)3052 int adapter_remove_found_device(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3053 {
3054 struct remote_dev_info *dev, match;
3055
3056 memset(&match, 0, sizeof(struct remote_dev_info));
3057 bacpy(&match.bdaddr, bdaddr);
3058
3059 dev = adapter_search_found_devices(adapter, &match);
3060 if (!dev)
3061 return -1;
3062
3063 dev->name_status = NAME_NOT_REQUIRED;
3064
3065 return 0;
3066 }
3067
adapter_update_oor_devices(struct btd_adapter * adapter)3068 void adapter_update_oor_devices(struct btd_adapter *adapter)
3069 {
3070 GSList *l;
3071
3072 for (l = adapter->oor_devices; l; l = l->next) {
3073 char address[18];
3074 const char *paddr = address;
3075 struct remote_dev_info *dev = l->data;
3076
3077 ba2str(&dev->bdaddr, address);
3078
3079 g_dbus_emit_signal(connection, adapter->path,
3080 ADAPTER_INTERFACE, "DeviceDisappeared",
3081 DBUS_TYPE_STRING, &paddr,
3082 DBUS_TYPE_INVALID);
3083
3084 adapter->found_devices = g_slist_remove(adapter->found_devices,
3085 dev);
3086 dev_info_free(dev);
3087 }
3088
3089 g_slist_free(adapter->oor_devices);
3090 adapter->oor_devices = NULL;
3091
3092 adapter->oor_devices = g_slist_copy(adapter->found_devices);
3093 }
3094
set_mode_complete(struct btd_adapter * adapter)3095 static void set_mode_complete(struct btd_adapter *adapter)
3096 {
3097 struct session_req *pending;
3098 const char *modestr;
3099 int err;
3100
3101 if (adapter->pending_mode == NULL)
3102 return;
3103
3104 pending = adapter->pending_mode;
3105 adapter->pending_mode = NULL;
3106
3107 err = (pending->mode != adapter->mode) ? -EINVAL : 0;
3108
3109 if (pending->msg != NULL) {
3110 DBusMessage *msg = pending->msg;
3111 DBusMessage *reply;
3112
3113 if (err < 0)
3114 reply = failed_strerror(msg, -err);
3115 else
3116 reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3117
3118 g_dbus_send_message(connection, reply);
3119 }
3120
3121 modestr = mode2str(adapter->mode);
3122
3123 DBG("%s", modestr);
3124
3125 /* Only store if the mode matches the pending */
3126 if (err == 0)
3127 write_device_mode(&adapter->bdaddr, modestr);
3128 else
3129 error("unable to set mode: %s", mode2str(pending->mode));
3130
3131 session_unref(pending);
3132 }
3133
adapter_mode_changed(struct btd_adapter * adapter,uint8_t scan_mode)3134 void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
3135 {
3136 const gchar *path = adapter_get_path(adapter);
3137 gboolean discoverable, pairable;
3138
3139 if (adapter->scan_mode == scan_mode)
3140 return;
3141
3142 adapter_remove_discov_timeout(adapter);
3143
3144 switch (scan_mode) {
3145 case SCAN_DISABLED:
3146 adapter->mode = MODE_OFF;
3147 discoverable = FALSE;
3148 pairable = FALSE;
3149 break;
3150 case SCAN_PAGE:
3151 adapter->mode = MODE_CONNECTABLE;
3152 discoverable = FALSE;
3153 pairable = adapter->pairable;
3154 break;
3155 case (SCAN_PAGE | SCAN_INQUIRY):
3156 adapter->mode = MODE_DISCOVERABLE;
3157 discoverable = TRUE;
3158 pairable = adapter->pairable;
3159 if (adapter->discov_timeout != 0)
3160 adapter_set_discov_timeout(adapter,
3161 adapter->discov_timeout);
3162 break;
3163 case SCAN_INQUIRY:
3164 /* Address the scenario where a low-level application like
3165 * hciconfig changed the scan mode */
3166 if (adapter->discov_timeout != 0)
3167 adapter_set_discov_timeout(adapter,
3168 adapter->discov_timeout);
3169
3170 /* ignore, this event should not be sent */
3171 default:
3172 /* ignore, reserved */
3173 return;
3174 }
3175
3176 /* If page scanning gets toggled emit the Pairable property */
3177 if ((adapter->scan_mode & SCAN_PAGE) != (scan_mode & SCAN_PAGE))
3178 emit_property_changed(connection, adapter->path,
3179 ADAPTER_INTERFACE, "Pairable",
3180 DBUS_TYPE_BOOLEAN, &pairable);
3181
3182 if (discoverable && adapter->pairable && adapter->discov_timeout > 0 &&
3183 adapter->discov_timeout <= 60)
3184 adapter_set_limited_discoverable(adapter, TRUE);
3185 else if (!discoverable)
3186 adapter_set_limited_discoverable(adapter, FALSE);
3187
3188 emit_property_changed(connection, path,
3189 ADAPTER_INTERFACE, "Discoverable",
3190 DBUS_TYPE_BOOLEAN, &discoverable);
3191
3192 adapter->scan_mode = scan_mode;
3193
3194 set_mode_complete(adapter);
3195 }
3196
adapter_get_agent(struct btd_adapter * adapter)3197 struct agent *adapter_get_agent(struct btd_adapter *adapter)
3198 {
3199 if (!adapter || !adapter->agent)
3200 return NULL;
3201
3202 return adapter->agent;
3203 }
3204
adapter_add_connection(struct btd_adapter * adapter,struct btd_device * device,uint16_t handle)3205 void adapter_add_connection(struct btd_adapter *adapter,
3206 struct btd_device *device, uint16_t handle)
3207 {
3208 if (g_slist_find(adapter->connections, device)) {
3209 error("Unable to add connection %d", handle);
3210 return;
3211 }
3212
3213 device_add_connection(device, connection, handle);
3214
3215 adapter->connections = g_slist_append(adapter->connections, device);
3216 }
3217
adapter_remove_connection(struct btd_adapter * adapter,struct btd_device * device,uint16_t handle)3218 void adapter_remove_connection(struct btd_adapter *adapter,
3219 struct btd_device *device, uint16_t handle)
3220 {
3221 bdaddr_t bdaddr;
3222
3223 if (!g_slist_find(adapter->connections, device)) {
3224 error("No matching connection for handle %u", handle);
3225 return;
3226 }
3227
3228 device_remove_connection(device, connection, handle);
3229
3230 adapter->connections = g_slist_remove(adapter->connections, device);
3231
3232 /* clean pending HCI cmds */
3233 device_get_address(device, &bdaddr);
3234 hci_req_queue_remove(adapter->dev_id, &bdaddr);
3235
3236 if (device_is_authenticating(device))
3237 device_cancel_authentication(device, TRUE);
3238
3239 if (device_is_temporary(device)) {
3240 const char *path = device_get_path(device);
3241
3242 DBG("Removing temporary device %s", path);
3243 adapter_remove_device(connection, adapter, device, TRUE);
3244 }
3245 }
3246
adapter_has_discov_sessions(struct btd_adapter * adapter)3247 gboolean adapter_has_discov_sessions(struct btd_adapter *adapter)
3248 {
3249 if (!adapter || !adapter->disc_sessions)
3250 return FALSE;
3251
3252 return TRUE;
3253 }
3254
btd_register_adapter_driver(struct btd_adapter_driver * driver)3255 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
3256 {
3257 GSList *adapters;
3258
3259 adapter_drivers = g_slist_append(adapter_drivers, driver);
3260
3261 if (driver->probe == NULL)
3262 return 0;
3263
3264 adapters = manager_get_adapters();
3265 g_slist_foreach(adapters, probe_driver, driver);
3266
3267 return 0;
3268 }
3269
btd_unregister_adapter_driver(struct btd_adapter_driver * driver)3270 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
3271 {
3272 adapter_drivers = g_slist_remove(adapter_drivers, driver);
3273 }
3274
agent_auth_cb(struct agent * agent,DBusError * derr,void * user_data)3275 static void agent_auth_cb(struct agent *agent, DBusError *derr,
3276 void *user_data)
3277 {
3278 struct service_auth *auth = user_data;
3279
3280 device_set_authorizing(auth->device, FALSE);
3281
3282 auth->cb(derr, auth->user_data);
3283 }
3284
auth_idle_cb(gpointer user_data)3285 static gboolean auth_idle_cb(gpointer user_data)
3286 {
3287 struct service_auth *auth = user_data;
3288 struct btd_adapter *adapter = auth->adapter;
3289
3290 adapter->auth_idle_id = 0;
3291
3292 auth->cb(NULL, auth->user_data);
3293
3294 return FALSE;
3295 }
3296
btd_adapter_authorize(struct btd_adapter * adapter,const bdaddr_t * dst,const char * uuid,service_auth_cb cb,void * user_data)3297 static int btd_adapter_authorize(struct btd_adapter *adapter,
3298 const bdaddr_t *dst,
3299 const char *uuid,
3300 service_auth_cb cb, void *user_data)
3301 {
3302 struct service_auth *auth;
3303 struct btd_device *device;
3304 struct agent *agent;
3305 char address[18];
3306 const gchar *dev_path;
3307 int err;
3308
3309 ba2str(dst, address);
3310 device = adapter_find_device(adapter, address);
3311 if (!device)
3312 return -EPERM;
3313
3314 /* Device connected? */
3315 if (!g_slist_find(adapter->connections, device))
3316 return -ENOTCONN;
3317
3318 if (adapter->auth_idle_id)
3319 return -EBUSY;
3320
3321 auth = g_try_new0(struct service_auth, 1);
3322 if (!auth)
3323 return -ENOMEM;
3324
3325 auth->cb = cb;
3326 auth->user_data = user_data;
3327 auth->device = device;
3328 auth->adapter = adapter;
3329
3330 if (device_is_trusted(device) == TRUE) {
3331 adapter->auth_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
3332 auth_idle_cb, auth,
3333 g_free);
3334 return 0;
3335 }
3336
3337 agent = device_get_agent(device);
3338 if (!agent) {
3339 g_free(auth);
3340 return -EPERM;
3341 }
3342
3343 dev_path = device_get_path(device);
3344
3345 err = agent_authorize(agent, dev_path, uuid, agent_auth_cb, auth, g_free);
3346 if (err < 0)
3347 g_free(auth);
3348 else
3349 device_set_authorizing(device, TRUE);
3350
3351 return err;
3352 }
3353
btd_request_authorization(const bdaddr_t * src,const bdaddr_t * dst,const char * uuid,service_auth_cb cb,void * user_data)3354 int btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
3355 const char *uuid, service_auth_cb cb, void *user_data)
3356 {
3357 struct btd_adapter *adapter;
3358 GSList *adapters;
3359
3360 if (src == NULL || dst == NULL)
3361 return -EINVAL;
3362
3363 if (bacmp(src, BDADDR_ANY) != 0)
3364 goto proceed;
3365
3366 /* Handle request authorization for ANY adapter */
3367 adapters = manager_get_adapters();
3368
3369 for (; adapters; adapters = adapters->next) {
3370 int err;
3371 adapter = adapters->data;
3372
3373 err = btd_adapter_authorize(adapter, dst, uuid, cb, user_data);
3374 if (err == 0)
3375 return 0;
3376 }
3377
3378 return -EPERM;
3379
3380 proceed:
3381 adapter = manager_find_adapter(src);
3382 if (!adapter)
3383 return -EPERM;
3384
3385 return btd_adapter_authorize(adapter, dst, uuid, cb, user_data);
3386 }
3387
btd_cancel_authorization(const bdaddr_t * src,const bdaddr_t * dst)3388 int btd_cancel_authorization(const bdaddr_t *src, const bdaddr_t *dst)
3389 {
3390 struct btd_adapter *adapter = manager_find_adapter(src);
3391 struct btd_device *device;
3392 struct agent *agent;
3393 char address[18];
3394 int err;
3395
3396 if (!adapter)
3397 return -EPERM;
3398
3399 ba2str(dst, address);
3400 device = adapter_find_device(adapter, address);
3401 if (!device)
3402 return -EPERM;
3403
3404 if (adapter->auth_idle_id) {
3405 g_source_remove(adapter->auth_idle_id);
3406 adapter->auth_idle_id = 0;
3407 return 0;
3408 }
3409
3410 /*
3411 * FIXME: Cancel fails if authorization is requested to adapter's
3412 * agent and in the meanwhile CreatePairedDevice is called.
3413 */
3414
3415 agent = device_get_agent(device);
3416 if (!agent)
3417 return -EPERM;
3418
3419 err = agent_cancel(agent);
3420
3421 if (err == 0)
3422 device_set_authorizing(device, FALSE);
3423
3424 return err;
3425 }
3426
3427 static gchar *adapter_any_path = NULL;
3428 static int adapter_any_refcount = 0;
3429
adapter_any_get_path(void)3430 const char *adapter_any_get_path(void)
3431 {
3432 return adapter_any_path;
3433 }
3434
btd_adapter_any_request_path(void)3435 const char *btd_adapter_any_request_path(void)
3436 {
3437 if (adapter_any_refcount > 0)
3438 return adapter_any_path;
3439
3440 adapter_any_path = g_strdup_printf("%s/any", manager_get_base_path());
3441 adapter_any_refcount++;
3442
3443 return adapter_any_path;
3444 }
3445
btd_adapter_any_release_path(void)3446 void btd_adapter_any_release_path(void)
3447 {
3448 adapter_any_refcount--;
3449
3450 if (adapter_any_refcount > 0)
3451 return;
3452
3453 g_free(adapter_any_path);
3454 adapter_any_path = NULL;
3455 }
3456
adapter_is_pairable(struct btd_adapter * adapter)3457 gboolean adapter_is_pairable(struct btd_adapter *adapter)
3458 {
3459 return adapter->pairable;
3460 }
3461
adapter_powering_down(struct btd_adapter * adapter)3462 gboolean adapter_powering_down(struct btd_adapter *adapter)
3463 {
3464 return adapter->off_requested;
3465 }
3466
btd_adapter_restore_powered(struct btd_adapter * adapter)3467 int btd_adapter_restore_powered(struct btd_adapter *adapter)
3468 {
3469 char mode[14], address[18];
3470
3471 if (!adapter_ops)
3472 return -EINVAL;
3473
3474 if (!main_opts.remember_powered)
3475 return -EINVAL;
3476
3477 if (adapter->up)
3478 return 0;
3479
3480 ba2str(&adapter->bdaddr, address);
3481 if (read_device_mode(address, mode, sizeof(mode)) == 0 &&
3482 g_str_equal(mode, "off"))
3483 return 0;
3484
3485 return adapter_ops->set_powered(adapter->dev_id, TRUE);
3486 }
3487
btd_adapter_switch_online(struct btd_adapter * adapter)3488 int btd_adapter_switch_online(struct btd_adapter *adapter)
3489 {
3490 if (!adapter_ops)
3491 return -EINVAL;
3492
3493 if (adapter->up)
3494 return 0;
3495
3496 return adapter_ops->set_powered(adapter->dev_id, TRUE);
3497 }
3498
btd_adapter_switch_offline(struct btd_adapter * adapter)3499 int btd_adapter_switch_offline(struct btd_adapter *adapter)
3500 {
3501 if (!adapter_ops)
3502 return -EINVAL;
3503
3504 if (!adapter->up)
3505 return 0;
3506
3507 return adapter_ops->set_powered(adapter->dev_id, FALSE);
3508 }
3509
btd_register_adapter_ops(struct btd_adapter_ops * btd_adapter_ops)3510 int btd_register_adapter_ops(struct btd_adapter_ops *btd_adapter_ops)
3511 {
3512 /* Already registered */
3513 if (adapter_ops)
3514 return -EALREADY;
3515
3516 if (btd_adapter_ops->setup == NULL)
3517 return -EINVAL;
3518
3519 adapter_ops = btd_adapter_ops;
3520
3521 return 0;
3522 }
3523
btd_adapter_cleanup_ops(struct btd_adapter_ops * btd_adapter_ops)3524 void btd_adapter_cleanup_ops(struct btd_adapter_ops *btd_adapter_ops)
3525 {
3526 adapter_ops->cleanup();
3527 }
3528
adapter_ops_setup(void)3529 int adapter_ops_setup(void)
3530 {
3531 if (!adapter_ops)
3532 return -EINVAL;
3533
3534 return adapter_ops->setup();
3535 }
3536