| /* |
| * |
| * BlueZ - Bluetooth protocol stack for Linux |
| * |
| * Copyright (C) 2006-2007 Nokia Corporation |
| * Copyright (C) 2004-2008 Marcel Holtmann <marcel@holtmann.org> |
| * |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <stdio.h> |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| #include <unistd.h> |
| #include <sys/time.h> |
| #include <sys/stat.h> |
| #include <sys/ioctl.h> |
| #include <sys/param.h> |
| #include <sys/socket.h> |
| |
| #include <bluetooth/bluetooth.h> |
| #include <bluetooth/hci.h> |
| #include <bluetooth/hci_lib.h> |
| #include <bluetooth/sdp.h> |
| #include <bluetooth/sdp_lib.h> |
| |
| #include <glib.h> |
| #include <dbus/dbus.h> |
| #include <gdbus.h> |
| |
| #include "hcid.h" |
| #include "sdpd.h" |
| |
| #include "logging.h" |
| #include "textfile.h" |
| #include "oui.h" |
| |
| #include "adapter.h" |
| #include "device.h" |
| #include "dbus-common.h" |
| #include "dbus-hci.h" |
| #include "dbus-service.h" |
| #include "error.h" |
| #include "glib-helper.h" |
| #include "agent.h" |
| #include "dbus-sdp.h" |
| #include "sdp-xml.h" |
| |
| #define MAX_DEVICES 16 |
| #define DISCONNECT_TIMER 2 |
| |
| #define DEVICE_INTERFACE "org.bluez.Device" |
| |
| struct browse_req { |
| DBusConnection *conn; |
| DBusMessage *msg; |
| struct device *device; |
| int search_uuid; |
| gboolean update; |
| gboolean browse; |
| }; |
| |
| struct hci_peer { |
| struct timeval lastseen; |
| struct timeval lastused; |
| |
| bdaddr_t bdaddr; |
| uint32_t class; |
| int8_t rssi; |
| uint8_t data[240]; |
| uint8_t name[248]; |
| |
| uint8_t pscan_rep_mode; |
| uint8_t pscan_period_mode; |
| uint8_t pscan_mode; |
| uint16_t clock_offset; |
| |
| struct hci_peer *next; |
| }; |
| |
| struct hci_conn { |
| bdaddr_t bdaddr; |
| uint16_t handle; |
| |
| struct hci_conn *next; |
| }; |
| |
| struct hci_dev { |
| int ignore; |
| |
| bdaddr_t bdaddr; |
| uint8_t features[8]; |
| uint8_t lmp_ver; |
| uint16_t lmp_subver; |
| uint16_t hci_rev; |
| uint16_t manufacturer; |
| |
| uint8_t ssp_mode; |
| uint8_t name[248]; |
| uint8_t class[3]; |
| |
| struct hci_peer *peers; |
| struct hci_conn *conns; |
| }; |
| |
| static struct hci_dev devices[MAX_DEVICES]; |
| |
| #define ASSERT_DEV_ID { if (dev_id >= MAX_DEVICES) return -ERANGE; } |
| |
| static GSList *drivers = NULL; |
| |
| static uint16_t uuid_list[] = { |
| PUBLIC_BROWSE_GROUP, |
| HID_SVCLASS_ID, |
| GENERIC_AUDIO_SVCLASS_ID, |
| ADVANCED_AUDIO_SVCLASS_ID, |
| AV_REMOTE_SVCLASS_ID, |
| 0 |
| }; |
| |
| void init_adapters(void) |
| { |
| int i; |
| |
| for (i = 0; i < MAX_DEVICES; i++) |
| memset(devices + i, 0, sizeof(struct hci_dev)); |
| } |
| |
| static int device_read_bdaddr(uint16_t dev_id, bdaddr_t *bdaddr) |
| { |
| int dd, err; |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| if (hci_read_bd_addr(dd, bdaddr, 2000) < 0) { |
| err = errno; |
| error("Can't read address for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| hci_close_dev(dd); |
| |
| return 0; |
| } |
| |
| int add_adapter(uint16_t dev_id) |
| { |
| struct hci_dev *dev; |
| struct hci_dev_info di; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| if (hci_devinfo(dev_id, &di) < 0) { |
| dev->ignore = 1; |
| return -errno; |
| } |
| |
| if (hci_test_bit(HCI_RAW, &di.flags)) { |
| info("Device hci%d is using raw mode", dev_id); |
| dev->ignore = 1; |
| } |
| |
| if (bacmp(&di.bdaddr, BDADDR_ANY)) |
| bacpy(&dev->bdaddr, &di.bdaddr); |
| else { |
| int err = device_read_bdaddr(dev_id, &dev->bdaddr); |
| if (err < 0) |
| return err; |
| } |
| memcpy(dev->features, di.features, 8); |
| |
| info("Device hci%d has been added", dev_id); |
| |
| return 0; |
| } |
| |
| int remove_adapter(uint16_t dev_id) |
| { |
| struct hci_dev *dev; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| memset(dev, 0, sizeof(struct hci_dev)); |
| |
| info("Device hci%d has been removed", dev_id); |
| |
| return 0; |
| } |
| |
| static inline uint8_t get_inquiry_mode(struct hci_dev *dev) |
| { |
| if (dev->features[6] & LMP_EXT_INQ) |
| return 2; |
| |
| if (dev->features[3] & LMP_RSSI_INQ) |
| return 1; |
| |
| if (dev->manufacturer == 11 && |
| dev->hci_rev == 0x00 && dev->lmp_subver == 0x0757) |
| return 1; |
| |
| if (dev->manufacturer == 15) { |
| if (dev->hci_rev == 0x03 && dev->lmp_subver == 0x6963) |
| return 1; |
| if (dev->hci_rev == 0x09 && dev->lmp_subver == 0x6963) |
| return 1; |
| if (dev->hci_rev == 0x00 && dev->lmp_subver == 0x6965) |
| return 1; |
| } |
| |
| if (dev->manufacturer == 31 && |
| dev->hci_rev == 0x2005 && dev->lmp_subver == 0x1805) |
| return 1; |
| |
| return 0; |
| } |
| |
| static void update_ext_inquiry_response(int dd, struct hci_dev *dev) |
| { |
| uint8_t fec = 0, data[240]; |
| |
| if (!(dev->features[6] & LMP_EXT_INQ)) |
| return; |
| |
| memset(data, 0, sizeof(data)); |
| |
| if (dev->ssp_mode > 0) |
| create_ext_inquiry_response((char *) dev->name, data); |
| |
| if (hci_write_ext_inquiry_response(dd, fec, data, 2000) < 0) |
| error("Can't write extended inquiry response: %s (%d)", |
| strerror(errno), errno); |
| } |
| |
| int start_adapter(uint16_t dev_id) |
| { |
| struct hci_dev *dev; |
| struct hci_version ver; |
| uint8_t features[8], inqmode; |
| uint8_t events[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00 }; |
| char name[249]; |
| int dd, err; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| if (dev->ignore) |
| return 0; |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| if (hci_read_local_version(dd, &ver, 1000) < 0) { |
| err = errno; |
| error("Can't read version info for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| dev->hci_rev = ver.hci_rev; |
| dev->lmp_ver = ver.lmp_ver; |
| dev->lmp_subver = ver.lmp_subver; |
| dev->manufacturer = ver.manufacturer; |
| |
| if (hci_read_local_features(dd, features, 1000) < 0) { |
| err = errno; |
| error("Can't read features for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| memcpy(dev->features, features, 8); |
| |
| if (hci_read_class_of_dev(dd, dev->class, 1000) < 0) { |
| err = errno; |
| error("Can't read class of device on hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| if (hci_read_local_name(dd, sizeof(name), name, 2000) < 0) { |
| err = errno; |
| error("Can't read local name on hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| memcpy(dev->name, name, 248); |
| |
| if (!(features[6] & LMP_SIMPLE_PAIR)) |
| goto setup; |
| |
| if (hcid_dbus_use_experimental()) { |
| if (ioctl(dd, HCIGETAUTHINFO, NULL) < 0 && errno != EINVAL) |
| hci_write_simple_pairing_mode(dd, 0x01, 2000); |
| } |
| |
| if (hci_read_simple_pairing_mode(dd, &dev->ssp_mode, 1000) < 0) { |
| err = errno; |
| error("Can't read simple pairing mode on hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| setup: |
| if (ver.hci_rev > 1) { |
| if (features[5] & LMP_SNIFF_SUBR) |
| events[5] |= 0x20; |
| |
| if (features[5] & LMP_PAUSE_ENC) |
| events[5] |= 0x80; |
| |
| if (features[6] & LMP_EXT_INQ) |
| events[5] |= 0x40; |
| |
| if (features[6] & LMP_NFLUSH_PKTS) |
| events[7] |= 0x01; |
| |
| if (features[7] & LMP_LSTO) |
| events[6] |= 0x80; |
| |
| if (features[6] & LMP_SIMPLE_PAIR) { |
| events[6] |= 0x01; /* IO Capability Request */ |
| events[6] |= 0x02; /* IO Capability Response */ |
| events[6] |= 0x04; /* User Confirmation Request */ |
| events[6] |= 0x08; /* User Passkey Request */ |
| events[6] |= 0x10; /* Remote OOB Data Request */ |
| events[6] |= 0x20; /* Simple Pairing Complete */ |
| events[7] |= 0x04; /* User Passkey Notification */ |
| events[7] |= 0x08; /* Keypress Notification */ |
| events[7] |= 0x10; /* Remote Host Supported Features Notification */ |
| } |
| |
| hci_send_cmd(dd, OGF_HOST_CTL, OCF_SET_EVENT_MASK, |
| sizeof(events), events); |
| } |
| |
| if (read_local_name(&dev->bdaddr, name) == 0) { |
| memcpy(dev->name, name, 248); |
| hci_write_local_name(dd, name, 5000); |
| } |
| |
| update_ext_inquiry_response(dd, dev); |
| |
| inqmode = get_inquiry_mode(dev); |
| if (inqmode < 1) |
| goto done; |
| |
| if (hci_write_inquiry_mode(dd, inqmode, 2000) < 0) { |
| err = errno; |
| error("Can't write inquiry mode for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| done: |
| hci_close_dev(dd); |
| |
| info("Device hci%d has been activated", dev_id); |
| |
| return 0; |
| } |
| |
| int stop_adapter(uint16_t dev_id) |
| { |
| ASSERT_DEV_ID; |
| |
| info("Device hci%d has been disabled", dev_id); |
| |
| return 0; |
| } |
| |
| int update_adapter(uint16_t dev_id) |
| { |
| struct hci_dev *dev; |
| int dd; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| if (dev->ignore) |
| return 0; |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| int err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| update_ext_inquiry_response(dd, dev); |
| |
| hci_close_dev(dd); |
| |
| return 0; |
| } |
| |
| int get_device_address(uint16_t dev_id, char *address, size_t size) |
| { |
| struct hci_dev *dev; |
| |
| ASSERT_DEV_ID; |
| |
| if (size < 18) |
| return -ENOBUFS; |
| |
| dev = &devices[dev_id]; |
| |
| return ba2str(&dev->bdaddr, address); |
| } |
| |
| int get_device_class(uint16_t dev_id, uint8_t *cls) |
| { |
| struct hci_dev *dev; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| memcpy(cls, dev->class, 3); |
| |
| return 0; |
| } |
| |
| int set_device_class(uint16_t dev_id, uint8_t *cls) |
| { |
| struct hci_dev *dev; |
| |
| ASSERT_DEV_ID; |
| dev = &devices[dev_id]; |
| memcpy(dev->class, cls, 3); |
| |
| return 0; |
| } |
| |
| int get_device_version(uint16_t dev_id, char *version, size_t size) |
| { |
| struct hci_dev *dev; |
| char edr[7], *tmp; |
| int err; |
| |
| ASSERT_DEV_ID; |
| |
| if (size < 14) |
| return -ENOBUFS; |
| |
| dev = &devices[dev_id]; |
| |
| if ((dev->lmp_ver == 0x03 || dev->lmp_ver == 0x04) && |
| (dev->features[3] & (LMP_EDR_ACL_2M | LMP_EDR_ACL_3M))) |
| sprintf(edr, " + EDR"); |
| else |
| edr[0] = '\0'; |
| |
| tmp = lmp_vertostr(dev->lmp_ver); |
| |
| if (strlen(tmp) == 0) |
| err = snprintf(version, size, "not assigned"); |
| else |
| err = snprintf(version, size, "Bluetooth %s%s", tmp, edr); |
| |
| bt_free(tmp); |
| |
| return err; |
| } |
| |
| static int digi_revision(uint16_t dev_id, char *revision, size_t size) |
| { |
| struct hci_request rq; |
| unsigned char req[] = { 0x07 }; |
| unsigned char buf[102]; |
| int dd, err; |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| memset(&rq, 0, sizeof(rq)); |
| rq.ogf = OGF_VENDOR_CMD; |
| rq.ocf = 0x000e; |
| rq.cparam = req; |
| rq.clen = sizeof(req); |
| rq.rparam = &buf; |
| rq.rlen = sizeof(buf); |
| |
| if (hci_send_req(dd, &rq, 2000) < 0) { |
| err = errno; |
| error("Can't read revision for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| hci_close_dev(dd); |
| |
| return snprintf(revision, size, "%s", buf + 1); |
| } |
| |
| int get_device_revision(uint16_t dev_id, char *revision, size_t size) |
| { |
| struct hci_dev *dev; |
| int err; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| switch (dev->manufacturer) { |
| case 10: |
| err = snprintf(revision, size, "Build %d", dev->lmp_subver); |
| break; |
| case 12: |
| err = digi_revision(dev_id, revision, size); |
| break; |
| case 15: |
| err = snprintf(revision, size, "%d.%d / %d", |
| dev->hci_rev & 0xff, |
| dev->lmp_subver >> 8, dev->lmp_subver & 0xff); |
| break; |
| default: |
| err = snprintf(revision, size, "0x%02x", dev->lmp_subver); |
| break; |
| } |
| |
| return err; |
| } |
| |
| int get_device_manufacturer(uint16_t dev_id, char *manufacturer, size_t size) |
| { |
| char *tmp; |
| |
| ASSERT_DEV_ID; |
| |
| tmp = bt_compidtostr(devices[dev_id].manufacturer); |
| |
| return snprintf(manufacturer, size, "%s", tmp); |
| } |
| |
| int get_device_company(uint16_t dev_id, char *company, size_t size) |
| { |
| char *tmp, oui[9]; |
| int err; |
| |
| ASSERT_DEV_ID; |
| |
| ba2oui(&devices[dev_id].bdaddr, oui); |
| tmp = ouitocomp(oui); |
| |
| err = snprintf(company, size, "%s", tmp); |
| |
| free(tmp); |
| |
| return err; |
| } |
| |
| int set_simple_pairing_mode(uint16_t dev_id, uint8_t mode) |
| { |
| struct hci_dev *dev; |
| int dd; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| dev->ssp_mode = mode; |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| int err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| update_ext_inquiry_response(dd, dev); |
| |
| hci_close_dev(dd); |
| |
| return 0; |
| } |
| |
| int get_device_name(uint16_t dev_id, char *name, size_t size) |
| { |
| char tmp[249]; |
| int dd, err; |
| |
| ASSERT_DEV_ID; |
| |
| memset(tmp, 0, sizeof(tmp)); |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| if (hci_read_local_name(dd, sizeof(tmp), tmp, 2000) < 0) { |
| err = errno; |
| error("Can't read name for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| hci_close_dev(dd); |
| |
| memcpy(devices[dev_id].name, tmp, 248); |
| |
| return snprintf(name, size, "%s", tmp); |
| } |
| |
| int set_device_name(uint16_t dev_id, const char *name) |
| { |
| struct hci_dev *dev; |
| int dd, err; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| dd = hci_open_dev(dev_id); |
| if (dd < 0) { |
| err = errno; |
| error("Can't open device hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| return -err; |
| } |
| |
| if (hci_write_local_name(dd, name, 5000) < 0) { |
| err = errno; |
| error("Can't write name for hci%d: %s (%d)", |
| dev_id, strerror(err), err); |
| hci_close_dev(dd); |
| return -err; |
| } |
| |
| strncpy((char *) dev->name, name, 248); |
| |
| update_ext_inquiry_response(dd, dev); |
| |
| hci_close_dev(dd); |
| |
| return 0; |
| } |
| |
| int get_device_alias(uint16_t dev_id, const bdaddr_t *bdaddr, char *alias, size_t size) |
| { |
| char filename[PATH_MAX + 1], addr[18], *tmp; |
| int err; |
| |
| ASSERT_DEV_ID; |
| |
| ba2str(&devices[dev_id].bdaddr, addr); |
| create_name(filename, PATH_MAX, STORAGEDIR, addr, "aliases"); |
| |
| ba2str(bdaddr, addr); |
| |
| tmp = textfile_get(filename, addr); |
| if (!tmp) |
| return -ENXIO; |
| |
| err = snprintf(alias, size, "%s", tmp); |
| |
| free(tmp); |
| |
| return err; |
| } |
| |
| int set_device_alias(uint16_t dev_id, const bdaddr_t *bdaddr, const char *alias) |
| { |
| char filename[PATH_MAX + 1], addr[18]; |
| |
| ASSERT_DEV_ID; |
| |
| ba2str(&devices[dev_id].bdaddr, addr); |
| create_name(filename, PATH_MAX, STORAGEDIR, addr, "aliases"); |
| |
| create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); |
| |
| ba2str(bdaddr, addr); |
| |
| return textfile_put(filename, addr, alias); |
| } |
| |
| int remove_device_alias(uint16_t dev_id, const bdaddr_t *bdaddr) |
| { |
| char filename[PATH_MAX + 1], addr[18]; |
| |
| ASSERT_DEV_ID; |
| |
| ba2str(&devices[dev_id].bdaddr, addr); |
| create_name(filename, PATH_MAX, STORAGEDIR, addr, "aliases"); |
| |
| create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); |
| |
| ba2str(bdaddr, addr); |
| |
| return textfile_del(filename, addr); |
| } |
| |
| int get_encryption_key_size(uint16_t dev_id, const bdaddr_t *baddr) |
| { |
| struct hci_dev *dev; |
| int size; |
| |
| ASSERT_DEV_ID; |
| |
| dev = &devices[dev_id]; |
| |
| switch (dev->manufacturer) { |
| default: |
| size = -ENOENT; |
| break; |
| } |
| |
| return size; |
| } |
| |
| static void device_free(gpointer user_data) |
| { |
| struct device *device = user_data; |
| |
| if (device->agent) |
| agent_destroy(device->agent, FALSE); |
| |
| g_slist_foreach(device->uuids, (GFunc) g_free, NULL); |
| g_slist_free(device->uuids); |
| |
| if (device->disconn_timer) |
| g_source_remove(device->disconn_timer); |
| |
| g_free(device->address); |
| g_free(device->path); |
| g_free(device); |
| } |
| |
| static gboolean device_is_paired(struct device *device) |
| { |
| struct adapter *adapter = device->adapter; |
| char filename[PATH_MAX + 1], *str; |
| gboolean ret; |
| |
| create_name(filename, PATH_MAX, STORAGEDIR, |
| adapter->address, "linkkeys"); |
| str = textfile_caseget(filename, device->address); |
| ret = str ? TRUE : FALSE; |
| g_free(str); |
| |
| return ret; |
| } |
| |
| static char *device_get_name(struct device *device) |
| { |
| struct adapter *adapter = device->adapter; |
| char filename[PATH_MAX + 1]; |
| |
| create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, "names"); |
| return textfile_caseget(filename, device->address); |
| } |
| |
| static DBusMessage *get_properties(DBusConnection *conn, |
| DBusMessage *msg, void *user_data) |
| { |
| struct device *device = user_data; |
| struct adapter *adapter = device->adapter; |
| DBusMessage *reply; |
| DBusMessageIter iter; |
| DBusMessageIter dict; |
| bdaddr_t src, dst; |
| char path[MAX_PATH_LENGTH]; |
| char buf[64]; |
| const char *ptr; |
| char *name, *ppath, **uuids; |
| dbus_bool_t boolean; |
| uint32_t class; |
| int i; |
| GSList *l; |
| |
| reply = dbus_message_new_method_return(msg); |
| if (!reply) |
| return NULL; |
| |
| dbus_message_iter_init_append(reply, &iter); |
| |
| dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, |
| DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING |
| DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING |
| DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); |
| |
| /* Address */ |
| dbus_message_iter_append_dict_entry(&dict, "Address", DBUS_TYPE_STRING, |
| &device->address); |
| |
| /* Name */ |
| name = device_get_name(device); |
| if (name) { |
| dbus_message_iter_append_dict_entry(&dict, "Name", |
| DBUS_TYPE_STRING, &name); |
| } |
| |
| str2ba(adapter->address, &src); |
| str2ba(device->address, &dst); |
| |
| /* Class */ |
| if (read_remote_class(&src, &dst, &class) == 0) { |
| dbus_message_iter_append_dict_entry(&dict, "Class", |
| DBUS_TYPE_UINT32, &class); |
| } |
| |
| /* Alias */ |
| if (get_device_alias(adapter->dev_id, &dst, buf, sizeof(buf)) > 0) { |
| ptr = buf; |
| dbus_message_iter_append_dict_entry(&dict, "Alias", |
| DBUS_TYPE_STRING, &ptr); |
| } else if (name) { |
| dbus_message_iter_append_dict_entry(&dict, "Alias", |
| DBUS_TYPE_STRING, &name); |
| free(name); |
| } |
| |
| /* Paired */ |
| boolean = device_is_paired(device); |
| dbus_message_iter_append_dict_entry(&dict, "Paired", |
| DBUS_TYPE_BOOLEAN, &boolean); |
| |
| /* Trusted */ |
| boolean = read_trust(&src, device->address, GLOBAL_TRUST); |
| dbus_message_iter_append_dict_entry(&dict, "Trusted", |
| DBUS_TYPE_BOOLEAN, &boolean); |
| |
| /* Connected */ |
| if (g_slist_find_custom(adapter->active_conn, &dst, |
| active_conn_find_by_bdaddr)) |
| boolean = TRUE; |
| else |
| boolean = FALSE; |
| |
| dbus_message_iter_append_dict_entry(&dict, "Connected", |
| DBUS_TYPE_BOOLEAN, &boolean); |
| |
| /* UUIDs */ |
| uuids = g_new0(char *, g_slist_length(device->uuids) + 1); |
| for (i = 0, l = device->uuids; l; l = l->next, i++) |
| uuids[i] = l->data; |
| dbus_message_iter_append_dict_entry(&dict, "UUIDs", |
| DBUS_TYPE_ARRAY, &uuids); |
| g_free(uuids); |
| |
| /* Adapter */ |
| snprintf(path, sizeof(path), "/hci%d", adapter->dev_id); |
| ppath = path; |
| dbus_message_iter_append_dict_entry(&dict, "Adapter", |
| DBUS_TYPE_OBJECT_PATH, &ppath); |
| |
| dbus_message_iter_close_container(&iter, &dict); |
| |
| return reply; |
| } |
| |
| static DBusMessage *set_alias(DBusConnection *conn, DBusMessage *msg, |
| const char *alias, void *data) |
| { |
| struct device *device = data; |
| struct adapter *adapter = device->adapter; |
| bdaddr_t bdaddr; |
| int ecode; |
| char *str, filename[PATH_MAX + 1], path[MAX_PATH_LENGTH]; |
| |
| str2ba(device->address, &bdaddr); |
| |
| /* Remove alias if empty string */ |
| if (g_str_equal(alias, "")) { |
| create_name(filename, PATH_MAX, STORAGEDIR, adapter->address, |
| "names"); |
| str = textfile_caseget(filename, device->address); |
| ecode = remove_device_alias(adapter->dev_id, &bdaddr); |
| } else { |
| str = g_strdup(alias); |
| ecode = set_device_alias(adapter->dev_id, &bdaddr, alias); |
| } |
| |
| if (ecode < 0) |
| return g_dbus_create_error(msg, |
| ERROR_INTERFACE ".Failed", |
| strerror(-ecode)); |
| |
| snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, adapter->dev_id); |
| |
| g_dbus_emit_signal(conn, path, |
| ADAPTER_INTERFACE, "RemoteAliasChanged", |
| DBUS_TYPE_STRING, &device->address, |
| DBUS_TYPE_STRING, &str, |
| DBUS_TYPE_INVALID); |
| |
| dbus_connection_emit_property_changed(conn, dbus_message_get_path(msg), |
| DEVICE_INTERFACE, "Alias", |
| DBUS_TYPE_STRING, &str); |
| |
| g_free(str); |
| |
| return dbus_message_new_method_return(msg); |
| } |
| |
| static DBusMessage *set_trust(DBusConnection *conn, DBusMessage *msg, |
| dbus_bool_t value, void *data) |
| { |
| struct device *device = data; |
| struct adapter *adapter = device->adapter; |
| bdaddr_t local; |
| char path[MAX_PATH_LENGTH]; |
| |
| str2ba(adapter->address, &local); |
| |
| write_trust(&local, device->address, GLOBAL_TRUST, value); |
| |
| snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, adapter->dev_id); |
| |
| g_dbus_emit_signal(conn, path, |
| ADAPTER_INTERFACE, |
| value ? "TrustAdded" : "TrustRemoved", |
| DBUS_TYPE_STRING, &device->address, |
| DBUS_TYPE_INVALID); |
| |
| dbus_connection_emit_property_changed(conn, dbus_message_get_path(msg), |
| DEVICE_INTERFACE, "Trusted", |
| DBUS_TYPE_BOOLEAN, &value); |
| |
| return dbus_message_new_method_return(msg); |
| } |
| |
| static inline DBusMessage *invalid_args(DBusMessage *msg) |
| { |
| return g_dbus_create_error(msg, |
| ERROR_INTERFACE ".InvalidArguments", |
| "Invalid arguments in method call"); |
| } |
| |
| static DBusMessage *set_property(DBusConnection *conn, |
| DBusMessage *msg, void *data) |
| { |
| DBusMessageIter iter; |
| DBusMessageIter sub; |
| const char *property; |
| |
| if (!dbus_message_iter_init(msg, &iter)) |
| return invalid_args(msg); |
| |
| if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) |
| return invalid_args(msg); |
| |
| dbus_message_iter_get_basic(&iter, &property); |
| dbus_message_iter_next(&iter); |
| |
| if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) |
| return invalid_args(msg); |
| dbus_message_iter_recurse(&iter, &sub); |
| |
| if (g_str_equal("Trusted", property)) { |
| dbus_bool_t value; |
| |
| if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN) |
| return invalid_args(msg); |
| dbus_message_iter_get_basic(&sub, &value); |
| |
| return set_trust(conn, msg, value, data); |
| } else if (g_str_equal("Alias", property)) { |
| char *alias; |
| |
| if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) |
| return invalid_args(msg); |
| dbus_message_iter_get_basic(&sub, &alias); |
| |
| return set_alias(conn, msg, alias, data); |
| } |
| |
| return invalid_args(msg); |
| } |
| |
| static void discover_services_req_exit(void *user_data) |
| { |
| struct device *device = user_data; |
| struct adapter *adapter = device->adapter; |
| bdaddr_t src, dst; |
| |
| debug("DiscoverDevices requestor exited"); |
| |
| str2ba(adapter->address, &src); |
| str2ba(device->address, &dst); |
| |
| bt_cancel_discovery(&src, &dst); |
| } |
| |
| static DBusMessage *discover_services(DBusConnection *conn, |
| DBusMessage *msg, void *user_data) |
| { |
| struct device *device = user_data; |
| const char *pattern; |
| uint16_t search; |
| int err; |
| |
| if (device->discov_active) |
| return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress", |
| "Discover in progress"); |
| |
| if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, |
| DBUS_TYPE_INVALID) == FALSE) |
| goto fail; |
| |
| if (strlen(pattern) == 0) { |
| err = device_browse(device, conn, msg, TRUE, 0); |
| if (err < 0) |
| goto fail; |
| } else { |
| |
| search = sdp_str2svclass(pattern); |
| if (!search) |
| return invalid_args(msg); |
| |
| err = device_browse(device, conn, msg, TRUE, search); |
| if (err < 0) |
| goto fail; |
| } |
| |
| return NULL; |
| |
| fail: |
| return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed", |
| "Discovery Failed"); |
| } |
| |
| static DBusMessage *cancel_discover(DBusConnection *conn, |
| DBusMessage *msg, void *user_data) |
| { |
| struct device *device = user_data; |
| struct adapter *adapter = device->adapter; |
| bdaddr_t src, dst; |
| |
| if (!device->discov_active) |
| return g_dbus_create_error(msg, |
| ERROR_INTERFACE ".Failed", |
| "No pending discovery"); |
| |
| /* only the discover requestor can cancel the inquiry process */ |
| if (!device->discov_requestor || |
| strcmp(device->discov_requestor, dbus_message_get_sender(msg))) |
| return g_dbus_create_error(msg, |
| ERROR_INTERFACE ".NotAuthorized", |
| "Not Authorized"); |
| |
| str2ba(adapter->address, &src); |
| str2ba(device->address, &dst); |
| |
| if (bt_cancel_discovery(&src, &dst) < 0) |
| return g_dbus_create_error(msg, |
| ERROR_INTERFACE ".Failed", |
| "No pending discover"); |
| |
| return dbus_message_new_method_return(msg); |
| } |
| |
| static gboolean disconnect_timeout(gpointer user_data) |
| { |
| struct device *device = user_data; |
| struct active_conn_info *ci; |
| GSList *l; |
| disconnect_cp cp; |
| bdaddr_t bda; |
| int dd; |
| |
| device->disconn_timer = 0; |
| |
| str2ba(device->address, &bda); |
| l = g_slist_find_custom(device->adapter->active_conn, |
| &bda, active_conn_find_by_bdaddr); |
| if (!l) |
| return FALSE; |
| |
| ci = l->data; |
| dd = hci_open_dev(device->adapter->dev_id); |
| if (dd < 0) |
| goto fail; |
| |
| memset(&cp, 0, sizeof(cp)); |
| cp.handle = htobs(ci->handle); |
| cp.reason = HCI_OE_USER_ENDED_CONNECTION; |
| |
| hci_send_cmd(dd, OGF_LINK_CTL, OCF_DISCONNECT, |
| DISCONNECT_CP_SIZE, &cp); |
| |
| close(dd); |
| |
| fail: |
| return FALSE; |
| } |
| |
| static DBusMessage *disconnect(DBusConnection *conn, |
| DBusMessage *msg, void *user_data) |
| { |
| struct device *device = user_data; |
| GSList *l; |
| bdaddr_t bda; |
| |
| str2ba(device->address, &bda); |
| l = g_slist_find_custom(device->adapter->active_conn, |
| &bda, active_conn_find_by_bdaddr); |
| if (!l) |
| return g_dbus_create_error(msg, |
| ERROR_INTERFACE ".NotConnected", |
| "Device is not connected"); |
| |
| g_dbus_emit_signal(conn, device->path, |
| DEVICE_INTERFACE, "DisconnectRequested", |
| DBUS_TYPE_INVALID); |
| |
| device->disconn_timer = g_timeout_add_seconds(DISCONNECT_TIMER, |
| disconnect_timeout, device); |
| |
| return dbus_message_new_method_return(msg); |
| } |
| |
| static GDBusMethodTable device_methods[] = { |
| { "GetProperties", "", "a{sv}", get_properties }, |
| { "SetProperty", "sv", "", set_property }, |
| { "DiscoverServices", "s", "a{us}", discover_services, |
| G_DBUS_METHOD_FLAG_ASYNC}, |
| { "CancelDiscovery", "", "", cancel_discover }, |
| { "Disconnect", "", "", disconnect }, |
| { } |
| }; |
| |
| static GDBusSignalTable device_signals[] = { |
| { "PropertyChanged", "sv" }, |
| { "DisconnectRequested", "" }, |
| { } |
| }; |
| |
| struct device *device_create(DBusConnection *conn, struct adapter *adapter, |
| const gchar *address, GSList *uuids) |
| { |
| gchar *address_up; |
| struct device *device; |
| |
| device = g_try_malloc0(sizeof(struct device)); |
| if (device == NULL) |
| return NULL; |
| |
| address_up = g_ascii_strup(address, -1); |
| device->path = g_strdup_printf("/hci%d/dev_%s", |
| adapter->dev_id, address_up); |
| g_strdelimit(device->path, ":", '_'); |
| g_free(address_up); |
| |
| debug("Creating device %s", device->path); |
| |
| if (g_dbus_register_interface(conn, device->path, DEVICE_INTERFACE, |
| device_methods, device_signals, NULL, |
| device, device_free) == FALSE) { |
| device_free(device); |
| return NULL; |
| } |
| |
| device->address = g_strdup(address); |
| device->adapter = adapter; |
| device->uuids = uuids; |
| |
| device->dev.path = device->path; |
| str2ba(device->address, &device->dev.dst); |
| str2ba(adapter->address, &device->dev.src); |
| |
| return device; |
| } |
| |
| void device_remove(DBusConnection *conn, struct device *device) |
| { |
| GSList *list; |
| struct btd_device_driver *driver; |
| gchar *path = g_strdup(device->path); |
| |
| debug("Removing device %s", path); |
| |
| for (list = device->drivers; list; list = list->next) { |
| driver = (struct btd_device_driver *) list->data; |
| |
| driver->remove(&device->dev); |
| } |
| |
| g_dbus_unregister_interface(conn, path, DEVICE_INTERFACE); |
| |
| g_free(path); |
| } |
| |
| gint device_address_cmp(struct device *device, const gchar *address) |
| { |
| return strcasecmp(device->address, address); |
| } |
| |
| static int cmp_by_name(const void *data, const void *user_data) |
| { |
| const struct btd_device_driver *dev_driver = data, *driver = user_data; |
| |
| return (strcmp(dev_driver->name, driver->name)); |
| } |
| |
| void device_probe_drivers(struct device *device) |
| { |
| GSList *list; |
| const char **uuid; |
| int err; |
| |
| debug("Probe drivers for %s", device->path); |
| |
| for (list = drivers; list; list = list->next) { |
| struct btd_device_driver *driver = list->data; |
| gboolean do_probe = FALSE; |
| |
| for (uuid = driver->uuids; *uuid; uuid++) { |
| GSList *match = g_slist_find_custom(device->uuids, |
| *uuid, (GCompareFunc) strcasecmp); |
| if (match) { |
| do_probe = TRUE; |
| break; |
| } |
| } |
| |
| if (do_probe == TRUE && !g_slist_find_custom(device->drivers, |
| driver, (GCompareFunc) cmp_by_name)) { |
| |
| err = driver->probe(&device->dev); |
| if (err < 0) { |
| error("probe failed for driver %s", |
| driver->name); |
| continue; |
| } |
| |
| device->drivers = g_slist_append(device->drivers, |
| driver); |
| } |
| } |
| } |
| |
| static void iter_append_record(DBusMessageIter *dict, uint32_t handle, |
| const char *record) |
| { |
| DBusMessageIter entry; |
| |
| dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, |
| NULL, &entry); |
| |
| dbus_message_iter_append_basic(&entry, DBUS_TYPE_UINT32, &handle); |
| |
| dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &record); |
| |
| dbus_message_iter_close_container(dict, &entry); |
| } |
| |
| static void browse_cb(sdp_list_t *recs, int err, gpointer user_data) |
| { |
| sdp_list_t *seq, *next, *svcclass; |
| struct browse_req *req = user_data; |
| struct device *device = req->device; |
| struct adapter *adapter = device->adapter; |
| bdaddr_t src, dst; |
| char **uuids; |
| int i; |
| GSList *l; |
| DBusMessage *reply; |
| uuid_t uuid; |
| |
| if (err < 0) |
| goto proceed; |
| |
| for (seq = recs; seq; seq = next) { |
| sdp_record_t *rec = (sdp_record_t *) seq->data; |
| |
| if (!rec) |
| break; |
| |
| svcclass = NULL; |
| if (sdp_get_service_classes(rec, &svcclass) == 0) { |
| /* Extract the first element and skip the remainning */ |
| gchar *uuid_str = bt_uuid2string(svcclass->data); |
| if (uuid_str) { |
| if (!g_slist_find_custom(device->uuids, uuid_str, |
| (GCompareFunc) strcmp)) |
| device->uuids = g_slist_insert_sorted(device->uuids, |
| uuid_str, (GCompareFunc) strcmp); |
| else |
| g_free(uuid_str); |
| } |
| sdp_list_free(svcclass, free); |
| } |
| |
| next = seq->next; |
| } |
| |
| str2ba(adapter->address, &src); |
| str2ba(device->address, &dst); |
| |
| /* Public browsing successful or Single record requested */ |
| if (req->browse == FALSE || (!req->search_uuid && recs)) |
| goto probe; |
| |
| if (uuid_list[++req->search_uuid]) { |
| sdp_uuid16_create(&uuid, uuid_list[req->search_uuid]); |
| bt_search_service(&src, &dst, &uuid, browse_cb, user_data, NULL); |
| return; |
| } |
| |
| probe: |
| /* Store the device's profiles in the filesystem */ |
| if (device->uuids) { |
| gchar *str = bt_list2string(device->uuids); |
| write_device_profiles(&src, &dst, str); |
| g_free(str); |
| |
| uuids = g_new0(char *, g_slist_length(device->uuids) + 1); |
| for (i = 0, l = device->uuids; l; l = l->next, i++) |
| uuids[i] = l->data; |
| |
| dbus_connection_emit_property_changed(req->conn, device->path, |
| DEVICE_INTERFACE, "UUIDs", |
| DBUS_TYPE_ARRAY, &uuids); |
| |
| g_free(uuids); |
| |
| } else |
| write_device_profiles(&src, &dst, ""); |
| |
| /* Probe matching drivers */ |
| device_probe_drivers(device); |
| |
| proceed: |
| if (req->update == TRUE) { |
| DBusMessageIter iter, dict; |
| |
| reply = dbus_message_new_method_return(req->msg); |
| if (!reply) |
| goto fail; |
| |
| dbus_message_iter_init_append(reply, &iter); |
| |
| dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, |
| DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING |
| DBUS_TYPE_UINT32_AS_STRING DBUS_TYPE_STRING_AS_STRING |
| DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); |
| |
| for (seq = recs; seq; seq = next) { |
| sdp_record_t *rec = (sdp_record_t *) seq->data; |
| sdp_buf_t result; |
| |
| if (!rec) |
| break; |
| |
| memset(&result, 0, sizeof(sdp_buf_t)); |
| |
| convert_sdp_record_to_xml(rec, &result, |
| append_and_grow_string); |
| |
| if (result.data) { |
| const char *val = (char *) result.data; |
| iter_append_record(&dict, rec->handle, val); |
| free(result.data); |
| } |
| |
| next = seq->next; |
| } |
| |
| dbus_message_iter_close_container(&iter, &dict); |
| |
| dbus_connection_send(req->conn, reply, NULL); |
| dbus_message_unref(reply); |
| goto fail; |
| } |
| |
| g_dbus_emit_signal(req->conn, dbus_message_get_path(req->msg), |
| ADAPTER_INTERFACE, "DeviceCreated", |
| DBUS_TYPE_OBJECT_PATH, &device->path, |
| DBUS_TYPE_INVALID); |
| |
| /* Reply create device request */ |
| reply = dbus_message_new_method_return(req->msg); |
| if (!reply) |
| goto fail; |
| |
| dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &device->path, |
| DBUS_TYPE_INVALID); |
| |
| dbus_connection_send(req->conn, reply, NULL); |
| dbus_message_unref(reply); |
| |
| fail: |
| device->discov_active = 0; |
| |
| if (device->discov_requestor) { |
| g_dbus_remove_watch(req->conn, device->discov_listener); |
| device->discov_listener = 0; |
| g_free(device->discov_requestor); |
| device->discov_requestor = NULL; |
| } |
| |
| if (recs != NULL) |
| sdp_list_free(recs, (sdp_free_func_t) sdp_record_free); |
| |
| dbus_message_unref(req->msg); |
| dbus_connection_unref(req->conn); |
| g_free(req); |
| } |
| |
| int device_browse(struct device *device, DBusConnection *conn, |
| DBusMessage *msg, gboolean update, uint16_t search) |
| { |
| struct adapter *adapter = device->adapter; |
| struct browse_req *req; |
| bdaddr_t src, dst; |
| uuid_t uuid; |
| |
| req = g_new0(struct browse_req, 1); |
| req->conn = dbus_connection_ref(conn); |
| req->msg = dbus_message_ref(msg); |
| req->device = device; |
| req->update = update; |
| |
| str2ba(adapter->address, &src); |
| str2ba(device->address, &dst); |
| |
| if (search) { |
| sdp_uuid16_create(&uuid, search); |
| req->browse = FALSE; |
| } else { |
| sdp_uuid16_create(&uuid, uuid_list[req->search_uuid]); |
| req->browse = TRUE; |
| } |
| |
| device->discov_active = 1; |
| device->discov_requestor = g_strdup(dbus_message_get_sender(msg)); |
| /* track the request owner to cancel it automatically if the owner |
| * exits */ |
| device->discov_listener = g_dbus_add_disconnect_watch(conn, |
| dbus_message_get_sender(msg), |
| discover_services_req_exit, |
| device, NULL); |
| |
| return bt_search_service(&src, &dst, &uuid, browse_cb, req, NULL); |
| } |
| |
| int btd_register_device_driver(struct btd_device_driver *driver) |
| { |
| const char **uuid; |
| |
| drivers = g_slist_append(drivers, driver); |
| |
| for (uuid = driver->uuids; *uuid; uuid++) { |
| debug("name %s uuid %s", driver->name, *uuid); |
| } |
| |
| register_service(driver->name, driver->uuids); |
| |
| return 0; |
| } |
| |
| void btd_unregister_device_driver(struct btd_device_driver *driver) |
| { |
| unregister_service(driver->name); |
| |
| drivers = g_slist_remove(drivers, driver); |
| } |