summaryrefslogtreecommitdiffstats
path: root/hcid
diff options
context:
space:
mode:
Diffstat (limited to 'hcid')
-rw-r--r--hcid/Makefile.am3
-rw-r--r--hcid/dbus-adapter.c1342
-rw-r--r--hcid/dbus-device.c1313
3 files changed, 1344 insertions, 1314 deletions
diff --git a/hcid/Makefile.am b/hcid/Makefile.am
index 0f9b81df..8d35463f 100644
--- a/hcid/Makefile.am
+++ b/hcid/Makefile.am
@@ -18,7 +18,8 @@ sbin_PROGRAMS = hcid
noinst_SCRIPTS = dbus-test
if DBUS
-dbus_hcid_sources = dbus.h dbus.c dbus-error.c dbus-manager.c dbus-device.c
+dbus_hcid_sources = dbus.h dbus.c dbus-error.c \
+ dbus-manager.c dbus-adapter.c dbus-device.c
dbus_hcid_libs = @DBUS_LIBS@
dbus_hcid_cflags = -DENABLE_DBUS -DDBUS_API_SUBJECT_TO_CHANGE
else
diff --git a/hcid/dbus-adapter.c b/hcid/dbus-adapter.c
new file mode 100644
index 00000000..050aab69
--- /dev/null
+++ b/hcid/dbus-adapter.c
@@ -0,0 +1,1342 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2006 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 <unistd.h>
+#include <sys/socket.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+
+#include <dbus/dbus.h>
+
+#include "hcid.h"
+#include "dbus.h"
+
+#include "textfile.h"
+#include "oui.h"
+
+static const char *service_cls[] = {
+ "positioning",
+ "networking",
+ "rendering",
+ "capturing",
+ "object transfer",
+ "audio",
+ "telephony",
+ "information"
+};
+
+static const char *computer_minor_cls[] = {
+ "uncategorized",
+ "desktop",
+ "server",
+ "laptop",
+ "handheld",
+ "palm",
+ "wearable"
+};
+
+static char *get_peer_name(const bdaddr_t *local, const bdaddr_t *peer)
+{
+ char filename[PATH_MAX + 1], addr[18];
+
+ ba2str(local, addr);
+ snprintf(filename, PATH_MAX, "%s/%s/names", STORAGEDIR, addr);
+
+ ba2str(peer, addr);
+ return textfile_get(filename, addr);
+}
+
+static DBusMessage *handle_dev_get_address_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ char str[18], *str_ptr = str;
+ int err;
+
+ err = get_device_address(dbus_data->dev_id, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_version_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ char str[20], *str_ptr = str;
+ int err;
+
+ err = get_device_version(dbus_data->dev_id, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_revision_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ char str[64], *str_ptr = str;
+ int err;
+
+ err = get_device_revision(dbus_data->dev_id, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_manufacturer_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ char str[64], *str_ptr = str;
+ int err;
+
+ err = get_device_manufacturer(dbus_data->dev_id, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_company_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ char str[64], *str_ptr = str;
+ int err;
+
+ err = get_device_company(dbus_data->dev_id, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_features_req(DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusMessageIter array_iter;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &array_iter);
+
+ dbus_message_iter_close_container(&iter, &array_iter);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_mode_req(DBusMessage *msg, void *data)
+{
+ const struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply = NULL;
+ const uint8_t hci_mode = dbus_data->mode;
+ const char *scan_mode;
+
+ switch (hci_mode) {
+ case SCAN_DISABLED:
+ scan_mode = MODE_OFF;
+ break;
+ case SCAN_PAGE:
+ scan_mode = MODE_CONNECTABLE;
+ break;
+ case (SCAN_PAGE | SCAN_INQUIRY):
+ scan_mode = MODE_DISCOVERABLE;
+ break;
+ case SCAN_INQUIRY:
+ /* inquiry scan mode is not handled, return unknown */
+ default:
+ /* reserved */
+ scan_mode = MODE_UNKNOWN;
+ }
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &scan_mode,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
+{
+ const struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ const char* scan_mode;
+ uint8_t hci_mode;
+ const uint8_t current_mode = dbus_data->mode;
+ int dd;
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &scan_mode,
+ DBUS_TYPE_INVALID);
+
+ if (!scan_mode)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+
+ if (strcasecmp(MODE_OFF, scan_mode) == 0)
+ hci_mode = SCAN_DISABLED;
+ else if (strcasecmp(MODE_CONNECTABLE, scan_mode) == 0)
+ hci_mode = SCAN_PAGE;
+ else if (strcasecmp(MODE_DISCOVERABLE, scan_mode) == 0)
+ hci_mode = (SCAN_PAGE | SCAN_INQUIRY);
+ else
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0)
+ return error_no_such_device(msg);
+
+ /* Check if the new requested mode is different from the current */
+ if (current_mode != hci_mode) {
+ struct hci_request rq;
+ uint8_t status = 0;
+
+ memset(&rq, 0, sizeof(rq));
+ rq.ogf = OGF_HOST_CTL;
+ rq.ocf = OCF_WRITE_SCAN_ENABLE;
+ rq.cparam = &hci_mode;
+ rq.clen = sizeof(hci_mode);
+ rq.rparam = &status;
+ rq.rlen = sizeof(status);
+
+ if (hci_send_req(dd, &rq, 100) < 0) {
+ syslog(LOG_ERR, "Sending write scan enable command failed: %s (%d)",
+ strerror(errno), errno);
+ hci_close_dev(dd);
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+ }
+
+ if (status) {
+ syslog(LOG_ERR, "Setting scan enable failed with status 0x%02x", status);
+ hci_close_dev(dd);
+ return bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | status);
+ }
+ }
+
+ hci_close_dev(dd);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_discoverable_to_req(DBusMessage *msg, void *data)
+{
+ const struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_UINT32, &dbus_data->discoverable_timeout,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_set_discoverable_to_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ uint32_t timeout;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &timeout);
+
+ dbus_data->discoverable_timeout = timeout;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_is_connectable_req(DBusMessage *msg, void *data)
+{
+ const struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ const uint8_t hci_mode = dbus_data->mode;
+ dbus_bool_t connectable = FALSE;
+
+ if (hci_mode & SCAN_PAGE)
+ connectable = TRUE;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connectable,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_is_discoverable_req(DBusMessage *msg, void *data)
+{
+ const struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ const uint8_t hci_mode = dbus_data->mode;
+ dbus_bool_t discoverable = FALSE;
+
+ if (hci_mode & SCAN_INQUIRY)
+ discoverable = TRUE;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &discoverable,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_major_class_req(DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ const char *str_ptr = "computer";
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ /*FIXME: Check the real device major class */
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_minor_class_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ const char *str_ptr = "";
+ uint8_t cls[3];
+ uint8_t minor_class;
+ int dd;
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0)
+ return error_no_such_device(msg);
+
+ if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
+ syslog(LOG_ERR, "Can't read class of device on hci%d: %s(%d)",
+ dbus_data->dev_id, strerror(errno), errno);
+ hci_close_dev(dd);
+ return error_generic(msg, -errno);
+ }
+
+ hci_close_dev(dd);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ /* FIXME: Currently, only computer major class is supported */
+ if ((cls[1] & 0x1f) != 1)
+ goto failed;
+
+ minor_class = cls[0] >> 2;
+
+ /* Validate computer minor class */
+ if (minor_class > (sizeof(computer_minor_cls) / sizeof(*computer_minor_cls)))
+ goto failed;
+
+ str_ptr = computer_minor_cls[minor_class];
+
+failed:
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusConnection *connection = get_dbus_connection();
+ DBusMessageIter iter;
+ DBusMessage *reply, *signal;
+ bdaddr_t bdaddr;
+ const char *minor;
+ uint8_t cls[3];
+ uint32_t dev_class = 0xFFFFFFFF;
+ int i, dd;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &minor);
+
+ if (!minor)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+
+ /* FIXME: currently, only computer minor classes are allowed */
+ for (i = 0; i < sizeof(computer_minor_cls) / sizeof(*computer_minor_cls); i++)
+ if (!strcasecmp(minor, computer_minor_cls[i])) {
+ /* Remove the format type */
+ dev_class = i << 2;
+ break;
+ }
+
+ /* Check if it's a valid minor class */
+ if (dev_class == 0xFFFFFFFF)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0) {
+ syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+ }
+
+ if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
+ syslog(LOG_ERR, "Can't read class of device on hci%d: %s(%d)",
+ dbus_data->dev_id, strerror(errno), errno);
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+ goto failed;
+ }
+
+ dev_class |= (cls[2] << 16) | (cls[1] << 8);
+
+ cls[2] = 0x00; /* no service classes */
+ cls[1] = 0x01; /* major class computer */
+ cls[0] = (dev_class & 0xff);
+
+ hci_devba(dbus_data->dev_id, &bdaddr);
+
+ write_local_class(&bdaddr, cls);
+
+ if (hci_write_class_of_dev(dd, dev_class, 2000) < 0) {
+ syslog(LOG_ERR, "Can't write class of device on hci%d: %s(%d)",
+ dbus_data->dev_id, strerror(errno), errno);
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+ goto failed;
+ }
+
+ signal = dev_signal_factory(dbus_data->dev_id, DEV_SIG_MINOR_CLASS_CHANGED,
+ DBUS_TYPE_STRING, &minor,
+ DBUS_TYPE_INVALID);
+ if (signal) {
+ dbus_connection_send(connection, signal, NULL);
+ dbus_connection_flush(connection);
+ dbus_message_unref(signal);
+ }
+
+ reply = dbus_message_new_method_return(msg);
+
+failed:
+ hci_close_dev(dd);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_service_classes_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusMessageIter array_iter;
+ const char *str_ptr;
+ uint8_t cls[3];
+ int dd, i;
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0) {
+ syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+ }
+
+ if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
+ syslog(LOG_ERR, "Can't read class of device on hci%d: %s(%d)",
+ dbus_data->dev_id, strerror(errno), errno);
+ hci_close_dev(dd);
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+ }
+
+ reply = dbus_message_new_method_return(msg);
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &array_iter);
+
+ for (i = 0; i < (sizeof(service_cls) / sizeof(*service_cls)); i++) {
+ if (cls[2] & (1 << i)) {
+ str_ptr = service_cls[i];
+ dbus_message_iter_append_basic(&array_iter,
+ DBUS_TYPE_STRING, &str_ptr);
+ }
+ }
+
+ dbus_message_iter_close_container(&iter, &array_iter);
+
+ hci_close_dev(dd);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_name_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply;
+ char str[249], *str_ptr = str;
+ int err;
+
+ err = get_device_name(dbus_data->dev_id, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_set_name_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ bdaddr_t bdaddr;
+ char *str_ptr;
+ int err;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &str_ptr);
+
+ if (strlen(str_ptr) == 0) {
+ syslog(LOG_ERR, "Name change failed: Invalid parameter");
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+ }
+
+ hci_devba(dbus_data->dev_id, &bdaddr);
+
+ write_local_name(&bdaddr, str_ptr);
+
+ err = set_device_name(dbus_data->dev_id, str_ptr);
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_remote_version_req(DBusMessage *msg, void *data)
+{
+ /*FIXME: */
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage *handle_dev_get_remote_revision_req(DBusMessage *msg, void *data)
+{
+ /*FIXME: */
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage *handle_dev_get_remote_manufacturer_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ char filename[PATH_MAX + 1];
+ char addr[18], *addr_ptr, *str;
+ int compid;
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ snprintf(filename, PATH_MAX, "%s/%s/manufacturers", STORAGEDIR, addr);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str = textfile_get(filename, addr_ptr);
+ if (!str)
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
+
+ compid = atoi(str);
+
+ free(str);
+
+ str = bt_compidtostr(compid);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_remote_company_req(DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ bdaddr_t bdaddr;
+ char oui[9], *str_bdaddr, *tmp;
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
+ DBUS_TYPE_INVALID);
+
+
+ str2ba(str_bdaddr, &bdaddr);
+ ba2oui(&bdaddr, oui);
+
+ tmp = ouitocomp(oui);
+ if (!tmp)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply) {
+ reply = error_out_of_memory(msg);
+ goto done;
+ }
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &tmp,
+ DBUS_TYPE_INVALID);
+
+done:
+ free(tmp);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_remote_name_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessage *reply = NULL;
+ const char *str_bdaddr;
+ char *name;
+ bdaddr_t bdaddr;
+ struct hci_dev_info di;
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
+ DBUS_TYPE_INVALID);
+
+ str2ba(str_bdaddr, &bdaddr);
+
+ if (hci_devinfo(dbus_data->dev_id, &di) < 0) {
+ syslog(LOG_ERR, "Can't get device info");
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
+ }
+
+ name = get_peer_name(&di.bdaddr, &bdaddr);
+ if (!name)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply) {
+ reply = error_out_of_memory(msg);
+ goto done;
+ }
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+
+done:
+ free(name);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_get_remote_alias_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ char str[249], *str_ptr = str, *addr_ptr;
+ bdaddr_t bdaddr;
+ int err;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str2ba(addr_ptr, &bdaddr);
+
+ err = get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_set_remote_alias_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusConnection *connection = get_dbus_connection();
+ DBusMessageIter iter;
+ DBusMessage *reply, *signal;
+ char *str_ptr, *addr_ptr;
+ bdaddr_t bdaddr;
+ int err;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_get_basic(&iter, &str_ptr);
+
+ if (strlen(str_ptr) == 0) {
+ syslog(LOG_ERR, "Alias change failed: Invalid parameter");
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
+ }
+
+ str2ba(addr_ptr, &bdaddr);
+
+ err = set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
+ if (err < 0)
+ return error_generic(msg, -err);
+
+ signal = dev_signal_factory(dbus_data->dev_id, DEV_SIG_REMOTE_ALIAS_CHANGED,
+ DBUS_TYPE_STRING, &addr_ptr,
+ DBUS_TYPE_STRING, &str_ptr,
+ DBUS_TYPE_INVALID);
+ if (signal) {
+ dbus_connection_send(connection, signal, NULL);
+ dbus_connection_flush(connection);
+ dbus_message_unref(signal);
+ }
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return error_out_of_memory(msg);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_last_seen_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ char filename[PATH_MAX + 1];
+ char addr[18], *addr_ptr, *str;
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ snprintf(filename, PATH_MAX, "%s/%s/lastseen", STORAGEDIR, addr);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str = textfile_get(filename, addr_ptr);
+ if (!str)
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply) {
+ reply = error_out_of_memory(msg);
+ goto done;
+ }
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
+ DBUS_TYPE_INVALID);
+
+done:
+ free(str);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_last_used_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ char filename[PATH_MAX + 1];
+ char addr[18], *addr_ptr, *str;
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ snprintf(filename, PATH_MAX, "%s/%s/lastused", STORAGEDIR, addr);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str = textfile_get(filename, addr_ptr);
+ if (!str)
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply) {
+ reply = error_out_of_memory(msg);
+ goto done;
+ }
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
+ DBUS_TYPE_INVALID);
+
+done:
+ free(str);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_create_bonding_req(DBusMessage *msg, void *data)
+{
+ struct hci_request rq;
+ auth_requested_cp cp;
+ evt_cmd_status rp;
+ DBusMessage *reply;
+ char *str_bdaddr;
+ struct hci_dbus_data *dbus_data = data;
+ struct hci_conn_info_req *cr;
+ bdaddr_t bdaddr;
+ int dd, dev_id;
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
+ DBUS_TYPE_INVALID);
+
+ str2ba(str_bdaddr, &bdaddr);
+
+ dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
+
+ if (dev_id < 0)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
+
+ if (dbus_data->dev_id != dev_id)
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
+
+ dd = hci_open_dev(dev_id);
+ if (dd < 0)
+ return error_no_such_device(msg);
+
+ cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
+ if (!cr) {
+ reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
+ goto failed;
+ }
+
+ bacpy(&cr->bdaddr, &bdaddr);
+ cr->type = ACL_LINK;
+
+ if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+ goto done;
+ }
+
+ memset(&cp, 0, sizeof(cp));
+ cp.handle = cr->conn_info->handle;
+
+ memset(&rq, 0, sizeof(rq));
+ rq.ogf = OGF_LINK_CTL;
+ rq.ocf = OCF_AUTH_REQUESTED;
+ rq.cparam = &cp;
+ rq.clen = AUTH_REQUESTED_CP_SIZE;
+ rq.rparam = &rp;
+ rq.rlen = EVT_CMD_STATUS_SIZE;
+ rq.event = EVT_CMD_STATUS;
+
+ if (hci_send_req(dd, &rq, 100) < 0) {
+ syslog(LOG_ERR, "Unable to send authentication request: %s (%d)",
+ strerror(errno), errno);
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+ goto done;
+ }
+
+ reply = dbus_message_new_method_return(msg);
+
+done:
+ free(cr);
+
+failed:
+ close(dd);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusConnection *connection = get_dbus_connection();
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ DBusMessage *signal;
+ char filename[PATH_MAX + 1];
+ char addr[18], *addr_ptr;
+ struct hci_conn_info_req *cr;
+ bdaddr_t bdaddr;
+ int dd;
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0)
+ return error_no_such_device(msg);
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ /* Delete the link key from storage */
+ textfile_del(filename, addr_ptr);
+
+ str2ba(addr_ptr, &bdaddr);
+
+ /* Delete the link key from the Bluetooth chip */
+ hci_delete_stored_link_key(dd, &bdaddr, 0, 1000);
+
+ /* Close active connections for the remote device */
+ cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
+ if (!cr) {
+ syslog(LOG_ERR, "Can't allocate memory");
+ hci_close_dev(dd);
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
+ }
+
+ bacpy(&cr->bdaddr, &bdaddr);
+ cr->type = ACL_LINK;
+ if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
+ /* Ignore when there isn't active connections, return success */
+ reply = dbus_message_new_method_return(msg);
+ goto failed;
+ }
+
+ /* Send the HCI disconnect command */
+ if (hci_disconnect(dd, htobs(cr->conn_info->handle), HCI_OE_USER_ENDED_CONNECTION, 1000) < 0) {
+ syslog(LOG_ERR, "Disconnect failed");
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
+ goto failed;
+ }
+
+ /* FIXME: which condition must be verified before send the signal */
+ signal = dev_signal_factory(dbus_data->dev_id,
+ DEV_SIG_BONDING_REMOVED,
+ DBUS_TYPE_STRING, &addr_ptr,
+ DBUS_TYPE_INVALID);
+ if (signal) {
+ dbus_connection_send(connection, signal, NULL);
+ dbus_connection_flush(connection);
+ dbus_message_unref(signal);
+ }
+
+ reply = dbus_message_new_method_return(msg);
+
+failed:
+ free(cr);
+
+ close(dd);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_has_bonding_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ char filename[PATH_MAX + 1];
+ char addr[18], *addr_ptr, *str;
+ dbus_bool_t result;
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str = textfile_get(filename, addr_ptr);
+ if (str) {
+ result = TRUE;
+ free(str);
+ } else
+ result = FALSE;
+
+ reply = dbus_message_new_method_return(msg);
+
+ dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &result,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_list_bondings_req(DBusMessage *msg, void *data)
+{
+ void do_append(char *key, char *value, void *data)
+ {
+ DBusMessageIter *iter = data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+ }
+
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessageIter array_iter;
+ DBusMessage *reply;
+ char filename[PATH_MAX + 1];
+ char addr[18];
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
+
+ reply = dbus_message_new_method_return(msg);
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &array_iter);
+
+ textfile_foreach(filename, do_append, &array_iter);
+
+ dbus_message_iter_close_container(&iter, &array_iter);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_pin_code_length_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ bdaddr_t local, peer;
+ char addr[18], *addr_ptr;
+ uint8_t length;
+ int len;
+
+ get_device_address(dbus_data->dev_id, addr, sizeof(addr));
+
+ str2ba(addr, &local);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str2ba(addr_ptr, &peer);
+
+ len = read_pin_length(&local, &peer);
+ if (len < 0)
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | -len);
+
+ reply = dbus_message_new_method_return(msg);
+
+ length = len;
+
+ dbus_message_append_args(reply, DBUS_TYPE_BYTE, &length,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_encryption_key_size_req(DBusMessage *msg, void *data)
+{
+ struct hci_dbus_data *dbus_data = data;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ bdaddr_t bdaddr;
+ char *addr_ptr;
+ uint8_t size;
+ int val;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_get_basic(&iter, &addr_ptr);
+
+ str2ba(addr_ptr, &bdaddr);
+
+ val = get_encryption_key_size(dbus_data->dev_id, &bdaddr);
+ if (val < 0)
+ return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | -val);
+
+ reply = dbus_message_new_method_return(msg);
+
+ size = val;
+
+ dbus_message_append_args(reply, DBUS_TYPE_BYTE, &size,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_discover_req(DBusMessage *msg, void *data)
+{
+ DBusMessage *reply = NULL;
+ inquiry_cp cp;
+ evt_cmd_status rp;
+ struct hci_request rq;
+ struct hci_dbus_data *dbus_data = data;
+ uint8_t length = 8, num_rsp = 0;
+ uint32_t lap = 0x9e8b33;
+ int dd;
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0)
+ return error_no_such_device(msg);
+
+ memset(&cp, 0, sizeof(cp));
+ cp.lap[0] = lap & 0xff;
+ cp.lap[1] = (lap >> 8) & 0xff;
+ cp.lap[2] = (lap >> 16) & 0xff;
+ cp.length = length;
+ cp.num_rsp = num_rsp;
+
+ memset(&rq, 0, sizeof(rq));
+ rq.ogf = OGF_LINK_CTL;
+ rq.ocf = OCF_INQUIRY;
+ rq.cparam = &cp;
+ rq.clen = INQUIRY_CP_SIZE;
+ rq.rparam = &rp;
+ rq.rlen = EVT_CMD_STATUS_SIZE;
+ rq.event = EVT_CMD_STATUS;
+
+ if (hci_send_req(dd, &rq, 100) < 0) {
+ syslog(LOG_ERR, "Unable to start inquiry: %s (%d)",
+ strerror(errno), errno);
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+ goto failed;
+ }
+
+ reply = dbus_message_new_method_return(msg);
+
+failed:
+ hci_close_dev(dd);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_discover_cancel_req(DBusMessage *msg, void *data)
+{
+ DBusMessage *reply = NULL;
+ struct hci_request rq;
+ struct hci_dbus_data *dbus_data = data;
+ uint8_t status;
+ int dd;
+
+ dd = hci_open_dev(dbus_data->dev_id);
+ if (dd < 0)
+ return error_no_such_device(msg);
+
+ memset(&rq, 0, sizeof(rq));
+ rq.ogf = OGF_LINK_CTL;
+ rq.ocf = OCF_INQUIRY_CANCEL;
+ rq.rparam = &status;
+ rq.rlen = sizeof(status);
+
+ if (hci_send_req(dd, &rq, 100) < 0) {
+ syslog(LOG_ERR, "Sending cancel inquiry failed: %s (%d)",
+ strerror(errno), errno);
+ reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
+ goto failed;
+ }
+
+ if (status) {
+ syslog(LOG_ERR, "Cancel inquiry failed with status 0x%02x", status);
+ reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET + status);
+ goto failed;
+ }
+
+ reply = dbus_message_new_method_return(msg);
+
+failed:
+ hci_close_dev(dd);
+
+ return reply;
+}
+
+static DBusMessage *handle_dev_discover_cache_req(DBusMessage *msg, void *data)
+{
+ /*FIXME: */
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static DBusMessage *handle_dev_discover_service_req(DBusMessage *msg, void *data)
+{
+ /*FIXME: */
+ return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
+}
+
+static const struct service_data dev_services[] = {
+ { DEV_GET_ADDRESS, handle_dev_get_address_req, DEV_GET_ADDRESS_SIGNATURE },
+ { DEV_GET_VERSION, handle_dev_get_version_req, DEV_GET_VERSION_SIGNATURE },
+ { DEV_GET_REVISION, handle_dev_get_revision_req, DEV_GET_REVISION_SIGNATURE },
+ { DEV_GET_MANUFACTURER, handle_dev_get_manufacturer_req, DEV_GET_MANUFACTURER_SIGNATURE },
+ { DEV_GET_COMPANY, handle_dev_get_company_req, DEV_GET_COMPANY_SIGNATURE },
+ { DEV_GET_FEATURES, handle_dev_get_features_req, DEV_GET_FEATURES_SIGNATURE },
+ { DEV_GET_MODE, handle_dev_get_mode_req, DEV_GET_MODE_SIGNATURE },
+ { DEV_SET_MODE, handle_dev_set_mode_req, DEV_SET_MODE_SIGNATURE },
+ { DEV_GET_DISCOVERABLE_TO, handle_dev_get_discoverable_to_req, DEV_GET_DISCOVERABLE_TO_SIGNATURE },
+ { DEV_SET_DISCOVERABLE_TO, handle_dev_set_discoverable_to_req, DEV_SET_DISCOVERABLE_TO_SIGNATURE },
+ { DEV_IS_CONNECTABLE, handle_dev_is_connectable_req, DEV_IS_CONNECTABLE_SIGNATURE },
+ { DEV_IS_DISCOVERABLE, handle_dev_is_discoverable_req, DEV_IS_DISCOVERABLE_SIGNATURE },
+ { DEV_GET_MAJOR_CLASS, handle_dev_get_major_class_req, DEV_GET_MAJOR_CLASS_SIGNATURE },
+ { DEV_GET_MINOR_CLASS, handle_dev_get_minor_class_req, DEV_GET_MINOR_CLASS_SIGNATURE },
+ { DEV_SET_MINOR_CLASS, handle_dev_set_minor_class_req, DEV_SET_MINOR_CLASS_SIGNATURE },
+ { DEV_GET_SERVICE_CLASSES, handle_dev_get_service_classes_req, DEV_GET_SERVICE_CLASSES_SIGNATURE },
+ { DEV_GET_NAME, handle_dev_get_name_req, DEV_GET_NAME_SIGNATURE },
+ { DEV_SET_NAME, handle_dev_set_name_req, DEV_SET_NAME_SIGNATURE },
+
+ { DEV_GET_REMOTE_VERSION, handle_dev_get_remote_version_req, DEV_GET_REMOTE_VERSION_SIGNATURE },
+ { DEV_GET_REMOTE_REVISION, handle_dev_get_remote_revision_req, DEV_GET_REMOTE_REVISION_SIGNATURE },
+ { DEV_GET_REMOTE_MANUFACTURER, handle_dev_get_remote_manufacturer_req, DEV_GET_REMOTE_MANUFACTURER_SIGNATURE },
+ { DEV_GET_REMOTE_COMPANY, handle_dev_get_remote_company_req, DEV_GET_REMOTE_COMPANY_SIGNATURE },
+ { DEV_GET_REMOTE_NAME, handle_dev_get_remote_name_req, DEV_GET_REMOTE_NAME_SIGNATURE },
+ { DEV_GET_REMOTE_ALIAS, handle_dev_get_remote_alias_req, DEV_GET_REMOTE_ALIAS_SIGNATURE },
+ { DEV_SET_REMOTE_ALIAS, handle_dev_set_remote_alias_req, DEV_SET_REMOTE_ALIAS_SIGNATURE },
+
+ { DEV_LAST_SEEN, handle_dev_last_seen_req, DEV_LAST_SEEN_SIGNATURE },
+ { DEV_LAST_USED, handle_dev_last_used_req, DEV_LAST_USED_SIGNATURE },
+
+ { DEV_CREATE_BONDING, handle_dev_create_bonding_req, DEV_CREATE_BONDING_SIGNATURE },
+ { DEV_REMOVE_BONDING, handle_dev_remove_bonding_req, DEV_REMOVE_BONDING_SIGNATURE },
+ { DEV_HAS_BONDING_NAME, handle_dev_has_bonding_req, DEV_HAS_BONDING_SIGNATURE },
+ { DEV_LIST_BONDINGS, handle_dev_list_bondings_req, DEV_LIST_BONDINGS_SIGNATURE },
+ { DEV_PIN_CODE_LENGTH, handle_dev_pin_code_length_req, DEV_PIN_CODE_LENGTH_SIGNATURE },
+ { DEV_ENCRYPTION_KEY_SIZE, handle_dev_encryption_key_size_req, DEV_ENCRYPTION_KEY_SIZE_SIGNATURE },
+
+ { DEV_DISCOVER, handle_dev_discover_req, DEV_DISCOVER_SIGNATURE },
+ { DEV_DISCOVER_CANCEL, handle_dev_discover_cancel_req, DEV_DISCOVER_CANCEL_SIGNATURE },
+ { DEV_DISCOVER_CACHE, handle_dev_discover_cache_req, DEV_DISCOVER_CACHE_SIGNATURE },
+ { DEV_DISCOVER_SERVICE, handle_dev_discover_service_req, DEV_DISCOVER_SERVICE_SIGNATURE },
+
+ { NULL, NULL, NULL}
+};
+
+DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ const struct service_data *handlers = dev_services;
+ DBusMessage *reply = NULL;
+ struct hci_dbus_data *dbus_data = data;
+ const char *method;
+ const char *signature;
+ const char *iface;
+ uint32_t error = BLUEZ_EDBUS_UNKNOWN_METHOD;
+
+ method = dbus_message_get_member(msg);
+ signature = dbus_message_get_signature(msg);
+ iface = dbus_message_get_interface(msg);
+
+ syslog(LOG_INFO, "Adapter path:%s method:%s",
+ dbus_message_get_path(msg), method);
+
+ if (strcmp(ADAPTER_INTERFACE, iface))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (dbus_data->path_id == ADAPTER_ROOT_ID) {
+ /* Adapter is down(path unregistered) or the path is wrong */
+ error = BLUEZ_EDBUS_UNKNOWN_PATH;
+ goto failed;
+ }
+
+ /* It's a device path id */
+ for (; handlers->name != NULL; handlers++) {
+ if (strcmp(handlers->name, method))
+ continue;
+
+ if (!strcmp(handlers->signature, signature)) {
+ reply = handlers->handler_func(msg, data);
+ error = 0;
+ break;
+ } else {
+ /* Set the error, but continue looping incase there is
+ * another method with the same name but a different
+ * signature */
+ error = BLUEZ_EDBUS_WRONG_SIGNATURE;
+ continue;
+ }
+ }
+
+failed:
+ if (error)
+ reply = bluez_new_failure_msg(msg, error);
+
+ if (reply) {
+ if (!dbus_connection_send (conn, reply, NULL))
+ syslog(LOG_ERR, "Can't send reply message");
+
+ dbus_message_unref(reply);
+ }
+
+ return DBUS_HANDLER_RESULT_HANDLED;
+}
diff --git a/hcid/dbus-device.c b/hcid/dbus-device.c
index 050aab69..f3bf47c4 100644
--- a/hcid/dbus-device.c
+++ b/hcid/dbus-device.c
@@ -27,1316 +27,3 @@
#include <stdio.h>
#include <errno.h>
-#include <unistd.h>
-#include <sys/socket.h>
-
-#include <bluetooth/bluetooth.h>
-#include <bluetooth/hci.h>
-#include <bluetooth/hci_lib.h>
-
-#include <dbus/dbus.h>
-
-#include "hcid.h"
-#include "dbus.h"
-
-#include "textfile.h"
-#include "oui.h"
-
-static const char *service_cls[] = {
- "positioning",
- "networking",
- "rendering",
- "capturing",
- "object transfer",
- "audio",
- "telephony",
- "information"
-};
-
-static const char *computer_minor_cls[] = {
- "uncategorized",
- "desktop",
- "server",
- "laptop",
- "handheld",
- "palm",
- "wearable"
-};
-
-static char *get_peer_name(const bdaddr_t *local, const bdaddr_t *peer)
-{
- char filename[PATH_MAX + 1], addr[18];
-
- ba2str(local, addr);
- snprintf(filename, PATH_MAX, "%s/%s/names", STORAGEDIR, addr);
-
- ba2str(peer, addr);
- return textfile_get(filename, addr);
-}
-
-static DBusMessage *handle_dev_get_address_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- char str[18], *str_ptr = str;
- int err;
-
- err = get_device_address(dbus_data->dev_id, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_version_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- char str[20], *str_ptr = str;
- int err;
-
- err = get_device_version(dbus_data->dev_id, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_revision_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- char str[64], *str_ptr = str;
- int err;
-
- err = get_device_revision(dbus_data->dev_id, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_manufacturer_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- char str[64], *str_ptr = str;
- int err;
-
- err = get_device_manufacturer(dbus_data->dev_id, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_company_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- char str[64], *str_ptr = str;
- int err;
-
- err = get_device_company(dbus_data->dev_id, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_features_req(DBusMessage *msg, void *data)
-{
- DBusMessage *reply;
- DBusMessageIter iter;
- DBusMessageIter array_iter;
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_iter_init_append(reply, &iter);
-
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
- DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
- dbus_message_iter_close_container(&iter, &array_iter);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_mode_req(DBusMessage *msg, void *data)
-{
- const struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply = NULL;
- const uint8_t hci_mode = dbus_data->mode;
- const char *scan_mode;
-
- switch (hci_mode) {
- case SCAN_DISABLED:
- scan_mode = MODE_OFF;
- break;
- case SCAN_PAGE:
- scan_mode = MODE_CONNECTABLE;
- break;
- case (SCAN_PAGE | SCAN_INQUIRY):
- scan_mode = MODE_DISCOVERABLE;
- break;
- case SCAN_INQUIRY:
- /* inquiry scan mode is not handled, return unknown */
- default:
- /* reserved */
- scan_mode = MODE_UNKNOWN;
- }
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &scan_mode,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_set_mode_req(DBusMessage *msg, void *data)
-{
- const struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- const char* scan_mode;
- uint8_t hci_mode;
- const uint8_t current_mode = dbus_data->mode;
- int dd;
-
- dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &scan_mode,
- DBUS_TYPE_INVALID);
-
- if (!scan_mode)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-
- if (strcasecmp(MODE_OFF, scan_mode) == 0)
- hci_mode = SCAN_DISABLED;
- else if (strcasecmp(MODE_CONNECTABLE, scan_mode) == 0)
- hci_mode = SCAN_PAGE;
- else if (strcasecmp(MODE_DISCOVERABLE, scan_mode) == 0)
- hci_mode = (SCAN_PAGE | SCAN_INQUIRY);
- else
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0)
- return error_no_such_device(msg);
-
- /* Check if the new requested mode is different from the current */
- if (current_mode != hci_mode) {
- struct hci_request rq;
- uint8_t status = 0;
-
- memset(&rq, 0, sizeof(rq));
- rq.ogf = OGF_HOST_CTL;
- rq.ocf = OCF_WRITE_SCAN_ENABLE;
- rq.cparam = &hci_mode;
- rq.clen = sizeof(hci_mode);
- rq.rparam = &status;
- rq.rlen = sizeof(status);
-
- if (hci_send_req(dd, &rq, 100) < 0) {
- syslog(LOG_ERR, "Sending write scan enable command failed: %s (%d)",
- strerror(errno), errno);
- hci_close_dev(dd);
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
- }
-
- if (status) {
- syslog(LOG_ERR, "Setting scan enable failed with status 0x%02x", status);
- hci_close_dev(dd);
- return bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET | status);
- }
- }
-
- hci_close_dev(dd);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_discoverable_to_req(DBusMessage *msg, void *data)
-{
- const struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_UINT32, &dbus_data->discoverable_timeout,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_set_discoverable_to_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- DBusMessageIter iter;
- uint32_t timeout;
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &timeout);
-
- dbus_data->discoverable_timeout = timeout;
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_is_connectable_req(DBusMessage *msg, void *data)
-{
- const struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- const uint8_t hci_mode = dbus_data->mode;
- dbus_bool_t connectable = FALSE;
-
- if (hci_mode & SCAN_PAGE)
- connectable = TRUE;
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connectable,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_is_discoverable_req(DBusMessage *msg, void *data)
-{
- const struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- const uint8_t hci_mode = dbus_data->mode;
- dbus_bool_t discoverable = FALSE;
-
- if (hci_mode & SCAN_INQUIRY)
- discoverable = TRUE;
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &discoverable,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_major_class_req(DBusMessage *msg, void *data)
-{
- DBusMessage *reply;
- const char *str_ptr = "computer";
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- /*FIXME: Check the real device major class */
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_minor_class_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- const char *str_ptr = "";
- uint8_t cls[3];
- uint8_t minor_class;
- int dd;
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0)
- return error_no_such_device(msg);
-
- if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
- syslog(LOG_ERR, "Can't read class of device on hci%d: %s(%d)",
- dbus_data->dev_id, strerror(errno), errno);
- hci_close_dev(dd);
- return error_generic(msg, -errno);
- }
-
- hci_close_dev(dd);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- /* FIXME: Currently, only computer major class is supported */
- if ((cls[1] & 0x1f) != 1)
- goto failed;
-
- minor_class = cls[0] >> 2;
-
- /* Validate computer minor class */
- if (minor_class > (sizeof(computer_minor_cls) / sizeof(*computer_minor_cls)))
- goto failed;
-
- str_ptr = computer_minor_cls[minor_class];
-
-failed:
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_set_minor_class_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusConnection *connection = get_dbus_connection();
- DBusMessageIter iter;
- DBusMessage *reply, *signal;
- bdaddr_t bdaddr;
- const char *minor;
- uint8_t cls[3];
- uint32_t dev_class = 0xFFFFFFFF;
- int i, dd;
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &minor);
-
- if (!minor)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-
- /* FIXME: currently, only computer minor classes are allowed */
- for (i = 0; i < sizeof(computer_minor_cls) / sizeof(*computer_minor_cls); i++)
- if (!strcasecmp(minor, computer_minor_cls[i])) {
- /* Remove the format type */
- dev_class = i << 2;
- break;
- }
-
- /* Check if it's a valid minor class */
- if (dev_class == 0xFFFFFFFF)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0) {
- syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
- }
-
- if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
- syslog(LOG_ERR, "Can't read class of device on hci%d: %s(%d)",
- dbus_data->dev_id, strerror(errno), errno);
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
- goto failed;
- }
-
- dev_class |= (cls[2] << 16) | (cls[1] << 8);
-
- cls[2] = 0x00; /* no service classes */
- cls[1] = 0x01; /* major class computer */
- cls[0] = (dev_class & 0xff);
-
- hci_devba(dbus_data->dev_id, &bdaddr);
-
- write_local_class(&bdaddr, cls);
-
- if (hci_write_class_of_dev(dd, dev_class, 2000) < 0) {
- syslog(LOG_ERR, "Can't write class of device on hci%d: %s(%d)",
- dbus_data->dev_id, strerror(errno), errno);
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
- goto failed;
- }
-
- signal = dev_signal_factory(dbus_data->dev_id, DEV_SIG_MINOR_CLASS_CHANGED,
- DBUS_TYPE_STRING, &minor,
- DBUS_TYPE_INVALID);
- if (signal) {
- dbus_connection_send(connection, signal, NULL);
- dbus_connection_flush(connection);
- dbus_message_unref(signal);
- }
-
- reply = dbus_message_new_method_return(msg);
-
-failed:
- hci_close_dev(dd);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_service_classes_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- DBusMessageIter iter;
- DBusMessageIter array_iter;
- const char *str_ptr;
- uint8_t cls[3];
- int dd, i;
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0) {
- syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
- }
-
- if (hci_read_class_of_dev(dd, cls, 1000) < 0) {
- syslog(LOG_ERR, "Can't read class of device on hci%d: %s(%d)",
- dbus_data->dev_id, strerror(errno), errno);
- hci_close_dev(dd);
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
- }
-
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_iter_init_append(reply, &iter);
-
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
- DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
- for (i = 0; i < (sizeof(service_cls) / sizeof(*service_cls)); i++) {
- if (cls[2] & (1 << i)) {
- str_ptr = service_cls[i];
- dbus_message_iter_append_basic(&array_iter,
- DBUS_TYPE_STRING, &str_ptr);
- }
- }
-
- dbus_message_iter_close_container(&iter, &array_iter);
-
- hci_close_dev(dd);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_name_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply;
- char str[249], *str_ptr = str;
- int err;
-
- err = get_device_name(dbus_data->dev_id, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_set_name_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- bdaddr_t bdaddr;
- char *str_ptr;
- int err;
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &str_ptr);
-
- if (strlen(str_ptr) == 0) {
- syslog(LOG_ERR, "Name change failed: Invalid parameter");
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
- }
-
- hci_devba(dbus_data->dev_id, &bdaddr);
-
- write_local_name(&bdaddr, str_ptr);
-
- err = set_device_name(dbus_data->dev_id, str_ptr);
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_remote_version_req(DBusMessage *msg, void *data)
-{
- /*FIXME: */
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage *handle_dev_get_remote_revision_req(DBusMessage *msg, void *data)
-{
- /*FIXME: */
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage *handle_dev_get_remote_manufacturer_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- char filename[PATH_MAX + 1];
- char addr[18], *addr_ptr, *str;
- int compid;
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- snprintf(filename, PATH_MAX, "%s/%s/manufacturers", STORAGEDIR, addr);
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str = textfile_get(filename, addr_ptr);
- if (!str)
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
-
- compid = atoi(str);
-
- free(str);
-
- str = bt_compidtostr(compid);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_remote_company_req(DBusMessage *msg, void *data)
-{
- DBusMessage *reply;
- bdaddr_t bdaddr;
- char oui[9], *str_bdaddr, *tmp;
-
- dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
- DBUS_TYPE_INVALID);
-
-
- str2ba(str_bdaddr, &bdaddr);
- ba2oui(&bdaddr, oui);
-
- tmp = ouitocomp(oui);
- if (!tmp)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply) {
- reply = error_out_of_memory(msg);
- goto done;
- }
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &tmp,
- DBUS_TYPE_INVALID);
-
-done:
- free(tmp);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_remote_name_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessage *reply = NULL;
- const char *str_bdaddr;
- char *name;
- bdaddr_t bdaddr;
- struct hci_dev_info di;
-
- dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
- DBUS_TYPE_INVALID);
-
- str2ba(str_bdaddr, &bdaddr);
-
- if (hci_devinfo(dbus_data->dev_id, &di) < 0) {
- syslog(LOG_ERR, "Can't get device info");
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
- }
-
- name = get_peer_name(&di.bdaddr, &bdaddr);
- if (!name)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_RECORD_NOT_FOUND);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply) {
- reply = error_out_of_memory(msg);
- goto done;
- }
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID);
-
-done:
- free(name);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_get_remote_alias_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- char str[249], *str_ptr = str, *addr_ptr;
- bdaddr_t bdaddr;
- int err;
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str2ba(addr_ptr, &bdaddr);
-
- err = get_device_alias(dbus_data->dev_id, &bdaddr, str, sizeof(str));
- if (err < 0)
- return error_generic(msg, -err);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_set_remote_alias_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusConnection *connection = get_dbus_connection();
- DBusMessageIter iter;
- DBusMessage *reply, *signal;
- char *str_ptr, *addr_ptr;
- bdaddr_t bdaddr;
- int err;
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
- dbus_message_iter_next(&iter);
- dbus_message_iter_get_basic(&iter, &str_ptr);
-
- if (strlen(str_ptr) == 0) {
- syslog(LOG_ERR, "Alias change failed: Invalid parameter");
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
- }
-
- str2ba(addr_ptr, &bdaddr);
-
- err = set_device_alias(dbus_data->dev_id, &bdaddr, str_ptr);
- if (err < 0)
- return error_generic(msg, -err);
-
- signal = dev_signal_factory(dbus_data->dev_id, DEV_SIG_REMOTE_ALIAS_CHANGED,
- DBUS_TYPE_STRING, &addr_ptr,
- DBUS_TYPE_STRING, &str_ptr,
- DBUS_TYPE_INVALID);
- if (signal) {
- dbus_connection_send(connection, signal, NULL);
- dbus_connection_flush(connection);
- dbus_message_unref(signal);
- }
-
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return error_out_of_memory(msg);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_last_seen_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- char filename[PATH_MAX + 1];
- char addr[18], *addr_ptr, *str;
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- snprintf(filename, PATH_MAX, "%s/%s/lastseen", STORAGEDIR, addr);
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str = textfile_get(filename, addr_ptr);
- if (!str)
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply) {
- reply = error_out_of_memory(msg);
- goto done;
- }
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
- DBUS_TYPE_INVALID);
-
-done:
- free(str);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_last_used_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- char filename[PATH_MAX + 1];
- char addr[18], *addr_ptr, *str;
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- snprintf(filename, PATH_MAX, "%s/%s/lastused", STORAGEDIR, addr);
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str = textfile_get(filename, addr_ptr);
- if (!str)
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | ENXIO);
-
- reply = dbus_message_new_method_return(msg);
- if (!reply) {
- reply = error_out_of_memory(msg);
- goto done;
- }
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
- DBUS_TYPE_INVALID);
-
-done:
- free(str);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_create_bonding_req(DBusMessage *msg, void *data)
-{
- struct hci_request rq;
- auth_requested_cp cp;
- evt_cmd_status rp;
- DBusMessage *reply;
- char *str_bdaddr;
- struct hci_dbus_data *dbus_data = data;
- struct hci_conn_info_req *cr;
- bdaddr_t bdaddr;
- int dd, dev_id;
-
- dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str_bdaddr,
- DBUS_TYPE_INVALID);
-
- str2ba(str_bdaddr, &bdaddr);
-
- dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
-
- if (dev_id < 0)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
-
- if (dbus_data->dev_id != dev_id)
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_CONN_NOT_FOUND);
-
- dd = hci_open_dev(dev_id);
- if (dd < 0)
- return error_no_such_device(msg);
-
- cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
- if (!cr) {
- reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
- goto failed;
- }
-
- bacpy(&cr->bdaddr, &bdaddr);
- cr->type = ACL_LINK;
-
- if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
- goto done;
- }
-
- memset(&cp, 0, sizeof(cp));
- cp.handle = cr->conn_info->handle;
-
- memset(&rq, 0, sizeof(rq));
- rq.ogf = OGF_LINK_CTL;
- rq.ocf = OCF_AUTH_REQUESTED;
- rq.cparam = &cp;
- rq.clen = AUTH_REQUESTED_CP_SIZE;
- rq.rparam = &rp;
- rq.rlen = EVT_CMD_STATUS_SIZE;
- rq.event = EVT_CMD_STATUS;
-
- if (hci_send_req(dd, &rq, 100) < 0) {
- syslog(LOG_ERR, "Unable to send authentication request: %s (%d)",
- strerror(errno), errno);
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
- goto done;
- }
-
- reply = dbus_message_new_method_return(msg);
-
-done:
- free(cr);
-
-failed:
- close(dd);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_remove_bonding_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusConnection *connection = get_dbus_connection();
- DBusMessageIter iter;
- DBusMessage *reply;
- DBusMessage *signal;
- char filename[PATH_MAX + 1];
- char addr[18], *addr_ptr;
- struct hci_conn_info_req *cr;
- bdaddr_t bdaddr;
- int dd;
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0)
- return error_no_such_device(msg);
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- /* Delete the link key from storage */
- textfile_del(filename, addr_ptr);
-
- str2ba(addr_ptr, &bdaddr);
-
- /* Delete the link key from the Bluetooth chip */
- hci_delete_stored_link_key(dd, &bdaddr, 0, 1000);
-
- /* Close active connections for the remote device */
- cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
- if (!cr) {
- syslog(LOG_ERR, "Can't allocate memory");
- hci_close_dev(dd);
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
- }
-
- bacpy(&cr->bdaddr, &bdaddr);
- cr->type = ACL_LINK;
- if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
- /* Ignore when there isn't active connections, return success */
- reply = dbus_message_new_method_return(msg);
- goto failed;
- }
-
- /* Send the HCI disconnect command */
- if (hci_disconnect(dd, htobs(cr->conn_info->handle), HCI_OE_USER_ENDED_CONNECTION, 1000) < 0) {
- syslog(LOG_ERR, "Disconnect failed");
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | errno);
- goto failed;
- }
-
- /* FIXME: which condition must be verified before send the signal */
- signal = dev_signal_factory(dbus_data->dev_id,
- DEV_SIG_BONDING_REMOVED,
- DBUS_TYPE_STRING, &addr_ptr,
- DBUS_TYPE_INVALID);
- if (signal) {
- dbus_connection_send(connection, signal, NULL);
- dbus_connection_flush(connection);
- dbus_message_unref(signal);
- }
-
- reply = dbus_message_new_method_return(msg);
-
-failed:
- free(cr);
-
- close(dd);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_has_bonding_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- char filename[PATH_MAX + 1];
- char addr[18], *addr_ptr, *str;
- dbus_bool_t result;
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str = textfile_get(filename, addr_ptr);
- if (str) {
- result = TRUE;
- free(str);
- } else
- result = FALSE;
-
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &result,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_list_bondings_req(DBusMessage *msg, void *data)
-{
- void do_append(char *key, char *value, void *data)
- {
- DBusMessageIter *iter = data;
-
- dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
- }
-
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessageIter array_iter;
- DBusMessage *reply;
- char filename[PATH_MAX + 1];
- char addr[18];
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- snprintf(filename, PATH_MAX, "%s/%s/linkkeys", STORAGEDIR, addr);
-
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_iter_init_append(reply, &iter);
-
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
- DBUS_TYPE_STRING_AS_STRING, &array_iter);
-
- textfile_foreach(filename, do_append, &array_iter);
-
- dbus_message_iter_close_container(&iter, &array_iter);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_pin_code_length_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- bdaddr_t local, peer;
- char addr[18], *addr_ptr;
- uint8_t length;
- int len;
-
- get_device_address(dbus_data->dev_id, addr, sizeof(addr));
-
- str2ba(addr, &local);
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str2ba(addr_ptr, &peer);
-
- len = read_pin_length(&local, &peer);
- if (len < 0)
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | -len);
-
- reply = dbus_message_new_method_return(msg);
-
- length = len;
-
- dbus_message_append_args(reply, DBUS_TYPE_BYTE, &length,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_encryption_key_size_req(DBusMessage *msg, void *data)
-{
- struct hci_dbus_data *dbus_data = data;
- DBusMessageIter iter;
- DBusMessage *reply;
- bdaddr_t bdaddr;
- char *addr_ptr;
- uint8_t size;
- int val;
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &addr_ptr);
-
- str2ba(addr_ptr, &bdaddr);
-
- val = get_encryption_key_size(dbus_data->dev_id, &bdaddr);
- if (val < 0)
- return bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET | -val);
-
- reply = dbus_message_new_method_return(msg);
-
- size = val;
-
- dbus_message_append_args(reply, DBUS_TYPE_BYTE, &size,
- DBUS_TYPE_INVALID);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_discover_req(DBusMessage *msg, void *data)
-{
- DBusMessage *reply = NULL;
- inquiry_cp cp;
- evt_cmd_status rp;
- struct hci_request rq;
- struct hci_dbus_data *dbus_data = data;
- uint8_t length = 8, num_rsp = 0;
- uint32_t lap = 0x9e8b33;
- int dd;
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0)
- return error_no_such_device(msg);
-
- memset(&cp, 0, sizeof(cp));
- cp.lap[0] = lap & 0xff;
- cp.lap[1] = (lap >> 8) & 0xff;
- cp.lap[2] = (lap >> 16) & 0xff;
- cp.length = length;
- cp.num_rsp = num_rsp;
-
- memset(&rq, 0, sizeof(rq));
- rq.ogf = OGF_LINK_CTL;
- rq.ocf = OCF_INQUIRY;
- rq.cparam = &cp;
- rq.clen = INQUIRY_CP_SIZE;
- rq.rparam = &rp;
- rq.rlen = EVT_CMD_STATUS_SIZE;
- rq.event = EVT_CMD_STATUS;
-
- if (hci_send_req(dd, &rq, 100) < 0) {
- syslog(LOG_ERR, "Unable to start inquiry: %s (%d)",
- strerror(errno), errno);
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
- goto failed;
- }
-
- reply = dbus_message_new_method_return(msg);
-
-failed:
- hci_close_dev(dd);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_discover_cancel_req(DBusMessage *msg, void *data)
-{
- DBusMessage *reply = NULL;
- struct hci_request rq;
- struct hci_dbus_data *dbus_data = data;
- uint8_t status;
- int dd;
-
- dd = hci_open_dev(dbus_data->dev_id);
- if (dd < 0)
- return error_no_such_device(msg);
-
- memset(&rq, 0, sizeof(rq));
- rq.ogf = OGF_LINK_CTL;
- rq.ocf = OCF_INQUIRY_CANCEL;
- rq.rparam = &status;
- rq.rlen = sizeof(status);
-
- if (hci_send_req(dd, &rq, 100) < 0) {
- syslog(LOG_ERR, "Sending cancel inquiry failed: %s (%d)",
- strerror(errno), errno);
- reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
- goto failed;
- }
-
- if (status) {
- syslog(LOG_ERR, "Cancel inquiry failed with status 0x%02x", status);
- reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET + status);
- goto failed;
- }
-
- reply = dbus_message_new_method_return(msg);
-
-failed:
- hci_close_dev(dd);
-
- return reply;
-}
-
-static DBusMessage *handle_dev_discover_cache_req(DBusMessage *msg, void *data)
-{
- /*FIXME: */
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static DBusMessage *handle_dev_discover_service_req(DBusMessage *msg, void *data)
-{
- /*FIXME: */
- return bluez_new_failure_msg(msg, BLUEZ_EDBUS_NOT_IMPLEMENTED);
-}
-
-static const struct service_data dev_services[] = {
- { DEV_GET_ADDRESS, handle_dev_get_address_req, DEV_GET_ADDRESS_SIGNATURE },
- { DEV_GET_VERSION, handle_dev_get_version_req, DEV_GET_VERSION_SIGNATURE },
- { DEV_GET_REVISION, handle_dev_get_revision_req, DEV_GET_REVISION_SIGNATURE },
- { DEV_GET_MANUFACTURER, handle_dev_get_manufacturer_req, DEV_GET_MANUFACTURER_SIGNATURE },
- { DEV_GET_COMPANY, handle_dev_get_company_req, DEV_GET_COMPANY_SIGNATURE },
- { DEV_GET_FEATURES, handle_dev_get_features_req, DEV_GET_FEATURES_SIGNATURE },
- { DEV_GET_MODE, handle_dev_get_mode_req, DEV_GET_MODE_SIGNATURE },
- { DEV_SET_MODE, handle_dev_set_mode_req, DEV_SET_MODE_SIGNATURE },
- { DEV_GET_DISCOVERABLE_TO, handle_dev_get_discoverable_to_req, DEV_GET_DISCOVERABLE_TO_SIGNATURE },
- { DEV_SET_DISCOVERABLE_TO, handle_dev_set_discoverable_to_req, DEV_SET_DISCOVERABLE_TO_SIGNATURE },
- { DEV_IS_CONNECTABLE, handle_dev_is_connectable_req, DEV_IS_CONNECTABLE_SIGNATURE },
- { DEV_IS_DISCOVERABLE, handle_dev_is_discoverable_req, DEV_IS_DISCOVERABLE_SIGNATURE },
- { DEV_GET_MAJOR_CLASS, handle_dev_get_major_class_req, DEV_GET_MAJOR_CLASS_SIGNATURE },
- { DEV_GET_MINOR_CLASS, handle_dev_get_minor_class_req, DEV_GET_MINOR_CLASS_SIGNATURE },
- { DEV_SET_MINOR_CLASS, handle_dev_set_minor_class_req, DEV_SET_MINOR_CLASS_SIGNATURE },
- { DEV_GET_SERVICE_CLASSES, handle_dev_get_service_classes_req, DEV_GET_SERVICE_CLASSES_SIGNATURE },
- { DEV_GET_NAME, handle_dev_get_name_req, DEV_GET_NAME_SIGNATURE },
- { DEV_SET_NAME, handle_dev_set_name_req, DEV_SET_NAME_SIGNATURE },
-
- { DEV_GET_REMOTE_VERSION, handle_dev_get_remote_version_req, DEV_GET_REMOTE_VERSION_SIGNATURE },
- { DEV_GET_REMOTE_REVISION, handle_dev_get_remote_revision_req, DEV_GET_REMOTE_REVISION_SIGNATURE },
- { DEV_GET_REMOTE_MANUFACTURER, handle_dev_get_remote_manufacturer_req, DEV_GET_REMOTE_MANUFACTURER_SIGNATURE },
- { DEV_GET_REMOTE_COMPANY, handle_dev_get_remote_company_req, DEV_GET_REMOTE_COMPANY_SIGNATURE },
- { DEV_GET_REMOTE_NAME, handle_dev_get_remote_name_req, DEV_GET_REMOTE_NAME_SIGNATURE },
- { DEV_GET_REMOTE_ALIAS, handle_dev_get_remote_alias_req, DEV_GET_REMOTE_ALIAS_SIGNATURE },
- { DEV_SET_REMOTE_ALIAS, handle_dev_set_remote_alias_req, DEV_SET_REMOTE_ALIAS_SIGNATURE },
-
- { DEV_LAST_SEEN, handle_dev_last_seen_req, DEV_LAST_SEEN_SIGNATURE },
- { DEV_LAST_USED, handle_dev_last_used_req, DEV_LAST_USED_SIGNATURE },
-
- { DEV_CREATE_BONDING, handle_dev_create_bonding_req, DEV_CREATE_BONDING_SIGNATURE },
- { DEV_REMOVE_BONDING, handle_dev_remove_bonding_req, DEV_REMOVE_BONDING_SIGNATURE },
- { DEV_HAS_BONDING_NAME, handle_dev_has_bonding_req, DEV_HAS_BONDING_SIGNATURE },
- { DEV_LIST_BONDINGS, handle_dev_list_bondings_req, DEV_LIST_BONDINGS_SIGNATURE },
- { DEV_PIN_CODE_LENGTH, handle_dev_pin_code_length_req, DEV_PIN_CODE_LENGTH_SIGNATURE },
- { DEV_ENCRYPTION_KEY_SIZE, handle_dev_encryption_key_size_req, DEV_ENCRYPTION_KEY_SIZE_SIGNATURE },
-
- { DEV_DISCOVER, handle_dev_discover_req, DEV_DISCOVER_SIGNATURE },
- { DEV_DISCOVER_CANCEL, handle_dev_discover_cancel_req, DEV_DISCOVER_CANCEL_SIGNATURE },
- { DEV_DISCOVER_CACHE, handle_dev_discover_cache_req, DEV_DISCOVER_CACHE_SIGNATURE },
- { DEV_DISCOVER_SERVICE, handle_dev_discover_service_req, DEV_DISCOVER_SERVICE_SIGNATURE },
-
- { NULL, NULL, NULL}
-};
-
-DBusHandlerResult msg_func_device(DBusConnection *conn, DBusMessage *msg, void *data)
-{
- const struct service_data *handlers = dev_services;
- DBusMessage *reply = NULL;
- struct hci_dbus_data *dbus_data = data;
- const char *method;
- const char *signature;
- const char *iface;
- uint32_t error = BLUEZ_EDBUS_UNKNOWN_METHOD;
-
- method = dbus_message_get_member(msg);
- signature = dbus_message_get_signature(msg);
- iface = dbus_message_get_interface(msg);
-
- syslog(LOG_INFO, "Adapter path:%s method:%s",
- dbus_message_get_path(msg), method);
-
- if (strcmp(ADAPTER_INTERFACE, iface))
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
- if (dbus_data->path_id == ADAPTER_ROOT_ID) {
- /* Adapter is down(path unregistered) or the path is wrong */
- error = BLUEZ_EDBUS_UNKNOWN_PATH;
- goto failed;
- }
-
- /* It's a device path id */
- for (; handlers->name != NULL; handlers++) {
- if (strcmp(handlers->name, method))
- continue;
-
- if (!strcmp(handlers->signature, signature)) {
- reply = handlers->handler_func(msg, data);
- error = 0;
- break;
- } else {
- /* Set the error, but continue looping incase there is
- * another method with the same name but a different
- * signature */
- error = BLUEZ_EDBUS_WRONG_SIGNATURE;
- continue;
- }
- }
-
-failed:
- if (error)
- reply = bluez_new_failure_msg(msg, error);
-
- if (reply) {
- if (!dbus_connection_send (conn, reply, NULL))
- syslog(LOG_ERR, "Can't send reply message");
-
- dbus_message_unref(reply);
- }
-
- return DBUS_HANDLER_RESULT_HANDLED;
-}