diff --git a/Makefile.am b/Makefile.am
index 8afb2cc..009762d 100644
--- a/Makefile.am
+++ b/Makefile.am
profiles/deviceinfo/deviceinfo.c
endif
-
-builtin_modules += mgmtops
-builtin_sources += plugins/mgmtops.c
-
if HAL
builtin_modules += hal
builtin_sources += plugins/hal.c
src/device.h src/device.c src/attio.h \
src/dbus-common.c src/dbus-common.h \
src/event.h src/event.c \
- src/oob.h src/oob.c src/eir.h src/eir.c
+ src/oob.h src/oob.c src/eir.h src/eir.c \
+ src/mgmt.c src/mgmt.h
src_bluetoothd_LDADD = lib/libbluetooth-private.la @GLIB_LIBS@ @DBUS_LIBS@ \
-ldl -lrt
src_bluetoothd_LDFLAGS = $(AM_LDFLAGS) -Wl,--export-dynamic \
diff --git a/src/adapter.c b/src/adapter.c
index 505797f..8820e27 100644
--- a/src/adapter.c
+++ b/src/adapter.c
#include "gatt.h"
#include "attrib-server.h"
#include "eir.h"
+#include "mgmt.h"
/* Flags Descriptions */
#define EIR_LIM_DISC 0x01 /* LE Limited Discoverable Mode */
static DBusConnection *connection = NULL;
static GSList *adapter_drivers = NULL;
-static GSList *ops_candidates = NULL;
-
-const struct btd_adapter_ops *adapter_ops = NULL;
-
struct session_req {
struct btd_adapter *adapter;
DBusConnection *conn; /* Connection reference */
int btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
uint8_t minor)
{
- return adapter_ops->set_dev_class(adapter->dev_id, major, minor);
+ return mgmt_set_dev_class(adapter->dev_id, major, minor);
}
static const char *mode2str(uint8_t mode)
int err;
if (mode == MODE_CONNECTABLE)
- err = adapter_ops->set_discoverable(adapter->dev_id, FALSE, 0);
+ err = mgmt_set_discoverable(adapter->dev_id, FALSE, 0);
else
- err = adapter_ops->set_discoverable(adapter->dev_id, TRUE,
+ err = mgmt_set_discoverable(adapter->dev_id, TRUE,
adapter->discov_timeout);
return err;
return -EALREADY;
if (!adapter->up && new_mode != MODE_OFF) {
- err = adapter_ops->set_powered(adapter->dev_id, TRUE);
+ err = mgmt_set_powered(adapter->dev_id, TRUE);
if (err < 0)
return err;
}
if (adapter->up && new_mode == MODE_OFF) {
- err = adapter_ops->set_powered(adapter->dev_id, FALSE);
+ err = mgmt_set_powered(adapter->dev_id, FALSE);
if (err < 0)
return err;
return btd_error_failed(msg, strerror(-err));
store:
- adapter_ops->set_pairable(adapter->dev_id, pairable);
+ mgmt_set_pairable(adapter->dev_id, pairable);
done:
return msg ? dbus_message_new_method_return(msg) : NULL;
}
if (adapter->up)
- adapter_ops->stop_discovery(adapter->dev_id);
+ mgmt_stop_discovery(adapter->dev_id);
}
static void session_remove(struct session_req *req)
return dbus_message_new_method_return(msg);
if (adapter->scan_mode & SCAN_INQUIRY)
- adapter_ops->set_discoverable(adapter->dev_id, TRUE, timeout);
+ mgmt_set_discoverable(adapter->dev_id, TRUE, timeout);
adapter->discov_timeout = timeout;
}
if (adapter->up) {
- int err = adapter_ops->set_name(adapter->dev_id, maxname);
+ int err = mgmt_set_name(adapter->dev_id, maxname);
if (err < 0)
return err;
} else {
if (new_uuid) {
uint8_t svc_hint = get_uuid_mask(&rec->svclass);
- adapter_ops->add_uuid(adapter->dev_id, &rec->svclass, svc_hint);
+ mgmt_add_uuid(adapter->dev_id, &rec->svclass, svc_hint);
}
adapter_emit_uuids_updated(adapter);
adapter->services = sdp_list_remove(adapter->services, rec);
if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
- adapter_ops->remove_uuid(adapter->dev_id, &rec->svclass);
+ mgmt_remove_uuid(adapter->dev_id, &rec->svclass);
adapter_emit_uuids_updated(adapter);
}
adapter->discov_id = 0;
- err = adapter_ops->start_discovery(adapter->dev_id);
+ err = mgmt_start_discovery(adapter->dev_id);
if (err < 0)
error("start_discovery: %s (%d)", strerror(-err), -err);
if (adapter->discov_suspended)
goto done;
- err = adapter_ops->start_discovery(adapter->dev_id);
+ err = mgmt_start_discovery(adapter->dev_id);
if (err < 0)
return btd_error_failed(msg, strerror(-err));
static void agent_removed(struct agent *agent, struct btd_adapter *adapter)
{
- adapter_ops->set_io_capability(adapter->dev_id,
- IO_CAPABILITY_NOINPUTNOOUTPUT);
+ mgmt_set_io_capability(adapter->dev_id, IO_CAPABILITY_NOINPUTNOOUTPUT);
adapter->agent = NULL;
}
DBG("Agent registered for hci%d at %s:%s", adapter->dev_id, name,
path);
- adapter_ops->set_io_capability(adapter->dev_id, cap);
+ mgmt_set_io_capability(adapter->dev_id, cap);
return dbus_message_new_method_return(msg);
}
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "linkkeys");
textfile_foreach(filename, create_stored_device_from_linkkeys, &keys);
- err = adapter_ops->load_keys(adapter->dev_id, keys.keys,
+ err = mgmt_load_link_keys(adapter->dev_id, keys.keys,
main_opts.debug_keys);
if (err < 0)
- error("Unable to load keys to adapter_ops: %s (%d)",
+ error("Unable to load link keys: %s (%d)",
strerror(-err), -err);
g_slist_free_full(keys.keys, g_free);
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "longtermkeys");
textfile_foreach(filename, create_stored_device_from_ltks, &keys);
- err = adapter_ops->load_ltks(adapter->dev_id, keys.keys);
+ err = mgmt_load_ltks(adapter->dev_id, keys.keys);
if (err < 0)
- error("Unable to load keys to adapter_ops: %s (%d)",
- strerror(-err), -err);
+ error("Unable to load ltks: %s (%d)", strerror(-err), -err);
+
g_slist_free_full(keys.keys, smp_key_free);
keys.keys = NULL;
int btd_adapter_block_address(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint8_t bdaddr_type)
{
- return adapter_ops->block_device(adapter->dev_id, bdaddr, bdaddr_type);
+ return mgmt_block_device(adapter->dev_id, bdaddr, bdaddr_type);
}
int btd_adapter_unblock_address(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint8_t bdaddr_type)
{
- return adapter_ops->unblock_device(adapter->dev_id, bdaddr,
+ return mgmt_unblock_device(adapter->dev_id, bdaddr,
bdaddr_type);
}
{
int err;
- err = adapter_ops->unblock_device(adapter->dev_id, BDADDR_ANY, 0);
+ err = mgmt_unblock_device(adapter->dev_id, BDADDR_ANY, 0);
if (err < 0)
error("Clearing blocked list failed: %s (%d)",
strerror(-err), -err);
GSList *l, *conns;
int err;
- err = adapter_ops->get_conn_list(adapter->dev_id, &conns);
+ err = mgmt_get_conn_list(adapter->dev_id, &conns);
if (err < 0) {
error("Unable to fetch existing connections: %s (%d)",
strerror(-err), -err);
adapter->allow_name_changes = TRUE;
- adapter_ops->read_bdaddr(adapter->dev_id, &adapter->bdaddr);
+ mgmt_read_bdaddr(adapter->dev_id, &adapter->bdaddr);
if (bacmp(&adapter->bdaddr, BDADDR_ANY) == 0) {
error("No address available for hci%d", adapter->dev_id);
/* Return adapter to down state if it was not up on init */
if (!adapter->already_up && adapter->up)
- adapter_ops->set_powered(adapter->dev_id, FALSE);
+ mgmt_set_powered(adapter->dev_id, FALSE);
}
uint16_t adapter_get_dev_id(struct btd_adapter *adapter)
g_source_remove(adapter->discov_id);
adapter->discov_id = 0;
} else
- adapter_ops->stop_discovery(adapter->dev_id);
+ mgmt_stop_discovery(adapter->dev_id);
}
static int found_device_cmp(gconstpointer a, gconstpointer b)
}
if (confirm_name)
- adapter_ops->confirm_name(adapter->dev_id, bdaddr, bdaddr_type,
+ mgmt_confirm_name(adapter->dev_id, bdaddr, bdaddr_type,
name_known);
alias = read_stored_data(&adapter->bdaddr, bdaddr, "aliases");
{
char mode[14], address[18];
- if (!adapter_ops)
- return -EINVAL;
-
if (!main_opts.remember_powered)
return -EINVAL;
g_str_equal(mode, "off"))
return 0;
- return adapter_ops->set_powered(adapter->dev_id, TRUE);
+ return mgmt_set_powered(adapter->dev_id, TRUE);
}
static gboolean switch_off_timeout(gpointer user_data)
{
struct btd_adapter *adapter = user_data;
- adapter_ops->set_powered(adapter->dev_id, FALSE);
+ mgmt_set_powered(adapter->dev_id, FALSE);
adapter->off_timer = 0;
return FALSE;
int btd_adapter_switch_online(struct btd_adapter *adapter)
{
- if (!adapter_ops)
- return -EINVAL;
-
if (adapter->up)
return -EALREADY;
if (adapter->off_timer)
off_timer_remove(adapter);
- return adapter_ops->set_powered(adapter->dev_id, TRUE);
+ return mgmt_set_powered(adapter->dev_id, TRUE);
}
int btd_adapter_switch_offline(struct btd_adapter *adapter)
{
- if (!adapter_ops)
- return -EINVAL;
-
if (!adapter->up)
return -EALREADY;
adapter->global_mode = MODE_OFF;
if (adapter->connections == NULL)
- return adapter_ops->set_powered(adapter->dev_id, FALSE);
+ return mgmt_set_powered(adapter->dev_id, FALSE);
g_slist_foreach(adapter->connections,
(GFunc) device_request_disconnect, NULL);
return read_pin_code(&sba, &dba, pin_buf);
}
-int btd_register_adapter_ops(struct btd_adapter_ops *ops, gboolean priority)
-{
- if (ops->setup == NULL)
- return -EINVAL;
-
- if (priority)
- ops_candidates = g_slist_prepend(ops_candidates, ops);
- else
- ops_candidates = g_slist_append(ops_candidates, ops);
-
- return 0;
-}
-
-void btd_adapter_cleanup_ops(struct btd_adapter_ops *ops)
-{
- ops_candidates = g_slist_remove(ops_candidates, ops);
- ops->cleanup();
-
- if (adapter_ops == ops)
- adapter_ops = NULL;
-}
-
-int adapter_ops_setup(void)
-{
- GSList *l;
- int ret;
-
- if (!ops_candidates)
- return -EINVAL;
-
- for (l = ops_candidates; l != NULL; l = g_slist_next(l)) {
- struct btd_adapter_ops *ops = l->data;
-
- ret = ops->setup();
- if (ret < 0)
- continue;
-
- adapter_ops = ops;
- break;
- }
-
- return ret;
-}
-
void btd_adapter_register_powered_callback(struct btd_adapter *adapter,
btd_adapter_powered_cb cb)
{
int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
gboolean enable)
{
- if (!adapter_ops)
- return -EINVAL;
-
if (!adapter->up)
return -EINVAL;
- return adapter_ops->set_fast_connectable(adapter->dev_id, enable);
+ return mgmt_set_fast_connectable(adapter->dev_id, enable);
}
int btd_adapter_read_clock(struct btd_adapter *adapter, bdaddr_t *bdaddr,
int which, int timeout, uint32_t *clock,
uint16_t *accuracy)
{
- if (!adapter_ops)
- return -EINVAL;
-
if (!adapter->up)
return -EINVAL;
- return adapter_ops->read_clock(adapter->dev_id, bdaddr, which,
+ return mgmt_read_clock(adapter->dev_id, bdaddr, which,
timeout, clock, accuracy);
}
bdaddr_t *bdaddr, uint8_t bdaddr_type)
{
- return adapter_ops->disconnect(adapter->dev_id, bdaddr, bdaddr_type);
+ return mgmt_disconnect(adapter->dev_id, bdaddr, bdaddr_type);
}
int btd_adapter_remove_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint8_t bdaddr_type)
{
- return adapter_ops->remove_bonding(adapter->dev_id, bdaddr,
- bdaddr_type);
+ return mgmt_unpair_device(adapter->dev_id, bdaddr, bdaddr_type);
}
int btd_adapter_pincode_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
const char *pin, size_t pin_len)
{
- return adapter_ops->pincode_reply(adapter->dev_id, bdaddr, pin,
- pin_len);
+ return mgmt_pincode_reply(adapter->dev_id, bdaddr, pin, pin_len);
}
int btd_adapter_confirm_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint8_t bdaddr_type, gboolean success)
{
- return adapter_ops->confirm_reply(adapter->dev_id, bdaddr, bdaddr_type,
+ return mgmt_confirm_reply(adapter->dev_id, bdaddr, bdaddr_type,
success);
}
int btd_adapter_passkey_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint8_t bdaddr_type, uint32_t passkey)
{
- return adapter_ops->passkey_reply(adapter->dev_id, bdaddr, bdaddr_type,
+ return mgmt_passkey_reply(adapter->dev_id, bdaddr, bdaddr_type,
passkey);
}
uint16_t product, uint16_t version,
uint16_t source)
{
- return adapter_ops->set_did(adapter->dev_id, vendor, product, version,
- source);
+ return mgmt_set_did(adapter->dev_id, vendor, product, version, source);
}
int adapter_create_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint8_t addr_type, uint8_t io_cap)
{
suspend_discovery(adapter);
- return adapter_ops->create_bonding(adapter->dev_id, bdaddr,
- addr_type, io_cap);
+ return mgmt_create_bonding(adapter->dev_id, bdaddr, addr_type, io_cap);
}
int adapter_cancel_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr)
{
- return adapter_ops->cancel_bonding(adapter->dev_id, bdaddr);
+ return mgmt_cancel_bonding(adapter->dev_id, bdaddr);
}
void adapter_bonding_complete(struct btd_adapter *adapter, bdaddr_t *bdaddr,
if (adapter->discov_suspended) {
adapter->discov_suspended = FALSE;
- adapter_ops->start_discovery(adapter->dev_id);
+ mgmt_start_discovery(adapter->dev_id);
}
}
int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
{
- return adapter_ops->read_local_oob_data(adapter->dev_id);
+ return mgmt_read_local_oob_data(adapter->dev_id);
}
int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
bdaddr_t *bdaddr, uint8_t *hash, uint8_t *randomizer)
{
- return adapter_ops->add_remote_oob_data(adapter->dev_id, bdaddr, hash,
+ return mgmt_add_remote_oob_data(adapter->dev_id, bdaddr, hash,
randomizer);
}
int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
bdaddr_t *bdaddr)
{
- return adapter_ops->remove_remote_oob_data(adapter->dev_id, bdaddr);
+ return mgmt_remove_remote_oob_data(adapter->dev_id, bdaddr);
}
diff --git a/src/adapter.h b/src/adapter.h
index 73cd770..602bb6f 100644
--- a/src/adapter.h
+++ b/src/adapter.h
typedef void (*bt_hci_result_t) (uint8_t status, gpointer user_data);
-struct btd_adapter_ops {
- int (*setup) (void);
- void (*cleanup) (void);
- int (*set_powered) (int index, gboolean powered);
- int (*set_discoverable) (int index, gboolean discoverable,
- uint16_t timeout);
- int (*set_pairable) (int index, gboolean pairable);
- int (*start_discovery) (int index);
- int (*stop_discovery) (int index);
-
- int (*set_name) (int index, const char *name);
- int (*set_dev_class) (int index, uint8_t major, uint8_t minor);
- int (*set_fast_connectable) (int index, gboolean enable);
- int (*read_clock) (int index, bdaddr_t *bdaddr, int which, int timeout,
- uint32_t *clock, uint16_t *accuracy);
- int (*read_bdaddr) (int index, bdaddr_t *bdaddr);
- int (*block_device) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
- int (*unblock_device) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
- int (*get_conn_list) (int index, GSList **conns);
- int (*disconnect) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
- int (*remove_bonding) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
- int (*pincode_reply) (int index, bdaddr_t *bdaddr, const char *pin,
- size_t pin_len);
- int (*confirm_reply) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
- gboolean success);
- int (*passkey_reply) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
- uint32_t passkey);
- int (*set_did) (int index, uint16_t vendor, uint16_t product,
- uint16_t version, uint16_t source);
- int (*add_uuid) (int index, uuid_t *uuid, uint8_t svc_hint);
- int (*remove_uuid) (int index, uuid_t *uuid);
- int (*load_keys) (int index, GSList *keys, gboolean debug_keys);
- int (*set_io_capability) (int index, uint8_t io_capability);
- int (*create_bonding) (int index, bdaddr_t *bdaddr,
- uint8_t bdaddr_type, uint8_t io_cap);
- int (*cancel_bonding) (int index, bdaddr_t *bdaddr);
- int (*read_local_oob_data) (int index);
- int (*add_remote_oob_data) (int index, bdaddr_t *bdaddr, uint8_t *hash,
- uint8_t *randomizer);
- int (*remove_remote_oob_data) (int index, bdaddr_t *bdaddr);
- int (*confirm_name) (int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
- gboolean name_known);
- int (*load_ltks) (int index, GSList *keys);
-};
-
-int btd_register_adapter_ops(struct btd_adapter_ops *ops, gboolean priority);
-void btd_adapter_cleanup_ops(struct btd_adapter_ops *btd_adapter_ops);
-int adapter_ops_setup(void);
-
typedef void (*btd_adapter_powered_cb) (struct btd_adapter *adapter,
gboolean powered);
void btd_adapter_register_powered_callback(struct btd_adapter *adapter,
diff --git a/src/main.c b/src/main.c
index 286baa0..a0d6c6f 100644
--- a/src/main.c
+++ b/src/main.c
#include "dbus-common.h"
#include "agent.h"
#include "manager.h"
+#include "mgmt.h"
#define BLUEZ_NAME "org.bluez"
uint16_t mtu = 0;
GKeyFile *config;
guint signal;
+ int mgmt_err;
init_defaults();
* daemon needs to be re-worked. */
plugin_init(config, option_plugin, option_noplugin);
- if (adapter_ops_setup() < 0) {
- error("adapter_ops_setup failed");
+ mgmt_err = mgmt_setup();
+ if (mgmt_err < 0) {
+ error("mgmt setup failed: %s", strerror(-mgmt_err));
exit(1);
}
if (config)
g_key_file_free(config);
+ mgmt_cleanup();
+
info("Exit");
__btd_log_cleanup();
diff --git a/plugins/mgmtops.c b/src/mgmt.c
similarity index 92%
rename from plugins/mgmtops.c
rename to src/mgmt.c
index 27cec09..c55b1a8 100644
--- a/plugins/mgmtops.c
+++ b/src/mgmt.c
*
* Copyright (C) 2010 Nokia Corporation
* Copyright (C) 2010 Marcel Holtmann <marcel@holtmann.org>
+ * Copyright (C) 2011-2012 Intel Corporation. All rights reserved.
*
* 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
#include <bluetooth/sdp_lib.h>
#include <bluetooth/mgmt.h>
-#include "plugin.h"
#include "log.h"
#include "adapter.h"
#include "manager.h"
#include "event.h"
#include "oob.h"
#include "eir.h"
+#include "mgmt.h"
#define MGMT_BUF_SIZE 1024
return mgmt_set_mode(index, MGMT_OP_SET_CONNECTABLE, connectable);
}
-static int mgmt_set_discoverable(int index, gboolean discoverable,
- uint16_t timeout)
+int mgmt_set_discoverable(int index, gboolean discoverable, uint16_t timeout)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_set_discoverable)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_set_pairable(int index, gboolean pairable)
+int mgmt_set_pairable(int index, gboolean pairable)
{
DBG("index %d pairable %d", index, pairable);
return mgmt_set_mode(index, MGMT_OP_SET_PAIRABLE, pairable);
bonding_complete(info, &ev->addr.bdaddr, ev->status);
}
-static int mgmt_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin,
+int mgmt_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin,
size_t pin_len)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_pin_code_reply)];
}
}
-static int mgmt_confirm_reply(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
+int mgmt_confirm_reply(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
gboolean success)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_user_confirm_reply)];
return 0;
}
-static int mgmt_passkey_reply(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
+int mgmt_passkey_reply(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
uint32_t passkey)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_user_passkey_reply)];
memcpy(uuid128, uuid, sizeof(*uuid));
}
-static int mgmt_add_uuid(int index, uuid_t *uuid, uint8_t svc_hint)
+int mgmt_add_uuid(int index, uuid_t *uuid, uint8_t svc_hint)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_add_uuid)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_remove_uuid(int index, uuid_t *uuid)
+int mgmt_remove_uuid(int index, uuid_t *uuid)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_remove_uuid)];
struct mgmt_hdr *hdr = (void *) buf;
}
}
-static int mgmt_set_powered(int index, gboolean powered)
+int mgmt_set_powered(int index, gboolean powered)
{
struct controller_info *info = &controllers[index];
return mgmt_set_mode(index, MGMT_OP_SET_POWERED, powered);
}
-static int mgmt_set_name(int index, const char *name)
+int mgmt_set_name(int index, const char *name)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_set_local_name)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_set_dev_class(int index, uint8_t major, uint8_t minor)
+int mgmt_set_dev_class(int index, uint8_t major, uint8_t minor)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_set_dev_class)];
struct mgmt_hdr *hdr = (void *) buf;
return TRUE;
}
-static int mgmt_setup(void)
+int mgmt_setup(void)
{
struct mgmt_hdr hdr;
struct sockaddr_hci addr;
return err;
}
-static void mgmt_cleanup(void)
+void mgmt_cleanup(void)
{
g_free(controllers);
controllers = NULL;
}
}
-static int mgmt_start_discovery(int index)
+int mgmt_start_discovery(int index)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_start_discovery)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_stop_discovery(int index)
+int mgmt_stop_discovery(int index)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_start_discovery)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_set_fast_connectable(int index, gboolean enable)
+int mgmt_set_fast_connectable(int index, gboolean enable)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_mode)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_read_clock(int index, bdaddr_t *bdaddr, int which, int timeout,
+int mgmt_read_clock(int index, bdaddr_t *bdaddr, int which, int timeout,
uint32_t *clock, uint16_t *accuracy)
{
char addr[18];
return -ENOSYS;
}
-static int mgmt_read_bdaddr(int index, bdaddr_t *bdaddr)
+int mgmt_read_bdaddr(int index, bdaddr_t *bdaddr)
{
char addr[18];
struct controller_info *info = &controllers[index];
return 0;
}
-static int mgmt_block_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
+int mgmt_block_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_block_device)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_unblock_device(int index, bdaddr_t *bdaddr,
- uint8_t bdaddr_type)
+int mgmt_unblock_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_unblock_device)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_get_conn_list(int index, GSList **conns)
+int mgmt_get_conn_list(int index, GSList **conns)
{
struct controller_info *info = &controllers[index];
return 0;
}
-static int mgmt_disconnect(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
+int mgmt_disconnect(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_disconnect)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_unpair_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
+int mgmt_unpair_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_unpair_device)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_set_did(int index, uint16_t vendor, uint16_t product,
+int mgmt_set_did(int index, uint16_t vendor, uint16_t product,
uint16_t version, uint16_t source)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_set_device_id)];
return 0;
}
-static int mgmt_load_link_keys(int index, GSList *keys, gboolean debug_keys)
+int mgmt_load_link_keys(int index, GSList *keys, gboolean debug_keys)
{
char *buf;
struct mgmt_hdr *hdr;
return err;
}
-static int mgmt_set_io_capability(int index, uint8_t io_capability)
+int mgmt_set_io_capability(int index, uint8_t io_capability)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_set_io_capability)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_create_bonding(int index, bdaddr_t *bdaddr, uint8_t addr_type, uint8_t io_cap)
+int mgmt_create_bonding(int index, bdaddr_t *bdaddr, uint8_t addr_type, uint8_t io_cap)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_pair_device)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_cancel_bonding(int index, bdaddr_t *bdaddr)
+int mgmt_cancel_bonding(int index, bdaddr_t *bdaddr)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_addr_info)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_read_local_oob_data(int index)
+int mgmt_read_local_oob_data(int index)
{
struct mgmt_hdr hdr;
return 0;
}
-static int mgmt_add_remote_oob_data(int index, bdaddr_t *bdaddr,
+int mgmt_add_remote_oob_data(int index, bdaddr_t *bdaddr,
uint8_t *hash, uint8_t *randomizer)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_add_remote_oob_data)];
return 0;
}
-static int mgmt_remove_remote_oob_data(int index, bdaddr_t *bdaddr)
+int mgmt_remove_remote_oob_data(int index, bdaddr_t *bdaddr)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_remove_remote_oob_data)];
struct mgmt_hdr *hdr = (void *) buf;
return 0;
}
-static int mgmt_confirm_name(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
+int mgmt_confirm_name(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
gboolean name_known)
{
char buf[MGMT_HDR_SIZE + sizeof(struct mgmt_cp_confirm_name)];
return 0;
}
-static int mgmtops_load_ltks(int index, GSList *keys)
+int mgmt_load_ltks(int index, GSList *keys)
{
char *buf;
struct mgmt_hdr *hdr;
return err;
}
-
-static struct btd_adapter_ops mgmt_ops = {
- .setup = mgmt_setup,
- .cleanup = mgmt_cleanup,
- .set_powered = mgmt_set_powered,
- .set_discoverable = mgmt_set_discoverable,
- .set_pairable = mgmt_set_pairable,
- .start_discovery = mgmt_start_discovery,
- .stop_discovery = mgmt_stop_discovery,
- .set_name = mgmt_set_name,
- .set_dev_class = mgmt_set_dev_class,
- .set_fast_connectable = mgmt_set_fast_connectable,
- .read_clock = mgmt_read_clock,
- .read_bdaddr = mgmt_read_bdaddr,
- .block_device = mgmt_block_device,
- .unblock_device = mgmt_unblock_device,
- .get_conn_list = mgmt_get_conn_list,
- .disconnect = mgmt_disconnect,
- .remove_bonding = mgmt_unpair_device,
- .pincode_reply = mgmt_pincode_reply,
- .confirm_reply = mgmt_confirm_reply,
- .passkey_reply = mgmt_passkey_reply,
- .set_did = mgmt_set_did,
- .add_uuid = mgmt_add_uuid,
- .remove_uuid = mgmt_remove_uuid,
- .load_keys = mgmt_load_link_keys,
- .set_io_capability = mgmt_set_io_capability,
- .create_bonding = mgmt_create_bonding,
- .cancel_bonding = mgmt_cancel_bonding,
- .read_local_oob_data = mgmt_read_local_oob_data,
- .add_remote_oob_data = mgmt_add_remote_oob_data,
- .remove_remote_oob_data = mgmt_remove_remote_oob_data,
- .confirm_name = mgmt_confirm_name,
- .load_ltks = mgmtops_load_ltks,
-};
-
-static int mgmt_init(void)
-{
- return btd_register_adapter_ops(&mgmt_ops, TRUE);
-}
-
-static void mgmt_exit(void)
-{
- btd_adapter_cleanup_ops(&mgmt_ops);
-}
-
-BLUETOOTH_PLUGIN_DEFINE(mgmtops, VERSION,
- BLUETOOTH_PLUGIN_PRIORITY_LOW, mgmt_init, mgmt_exit)
diff --git a/src/mgmt.h b/src/mgmt.h
new file mode 100644
index 0000000..0658198
--- /dev/null
+++ b/src/mgmt.h
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Copyright (C) 2010 Marcel Holtmann <marcel@holtmann.org>
+ * Copyright (C) 2011-2012 Intel Corporation. All rights reserved.
+ *
+ * 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
+ *
+ */
+
+int mgmt_setup(void);
+void mgmt_cleanup(void);
+
+int mgmt_set_powered(int index, gboolean powered);
+int mgmt_set_discoverable(int index, gboolean discoverable, uint16_t timeout);
+int mgmt_set_pairable(int index, gboolean pairable);
+int mgmt_set_name(int index, const char *name);
+int mgmt_set_dev_class(int index, uint8_t major, uint8_t minor);
+int mgmt_set_fast_connectable(int index, gboolean enable);
+
+int mgmt_start_discovery(int index);
+int mgmt_stop_discovery(int index);
+
+int mgmt_read_clock(int index, bdaddr_t *bdaddr, int which, int timeout,
+ uint32_t *clock, uint16_t *accuracy);
+int mgmt_read_bdaddr(int index, bdaddr_t *bdaddr);
+
+int mgmt_block_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
+int mgmt_unblock_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
+
+int mgmt_get_conn_list(int index, GSList **conns);
+
+int mgmt_disconnect(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
+
+int mgmt_unpair_device(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type);
+
+int mgmt_add_uuid(int index, uuid_t *uuid, uint8_t svc_hint);
+int mgmt_remove_uuid(int index, uuid_t *uuid);
+
+int mgmt_set_did(int index, uint16_t vendor, uint16_t product,
+ uint16_t version, uint16_t source);
+
+int mgmt_load_link_keys(int index, GSList *keys, gboolean debug_keys);
+int mgmt_load_ltks(int index, GSList *keys);
+
+int mgmt_set_io_capability(int index, uint8_t io_capability);
+
+int mgmt_create_bonding(int index, bdaddr_t *bdaddr, uint8_t addr_type,
+ uint8_t io_cap);
+int mgmt_cancel_bonding(int index, bdaddr_t *bdaddr);
+
+int mgmt_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin,
+ size_t pin_len);
+int mgmt_confirm_reply(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
+ gboolean success);
+int mgmt_passkey_reply(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
+ uint32_t passkey);
+
+int mgmt_read_local_oob_data(int index);
+
+int mgmt_add_remote_oob_data(int index, bdaddr_t *bdaddr,
+ uint8_t *hash, uint8_t *randomizer);
+int mgmt_remove_remote_oob_data(int index, bdaddr_t *bdaddr);
+
+int mgmt_confirm_name(int index, bdaddr_t *bdaddr, uint8_t bdaddr_type,
+ gboolean name_known);