diff --git a/src/adapter.c b/src/adapter.c
index d597025..ea306e4 100644
--- a/src/adapter.c
+++ b/src/adapter.c
uint32_t dev_class;
if (length < sizeof(*rp)) {
- error("Wrong size of class of device changed parameters");
+ btd_error(adapter->dev_id,
+ "Wrong size of class of device changed parameters");
return;
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to set device class: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to set device class: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
set_dev_class_complete, adapter, NULL) > 0)
return;
- error("Failed to set class of device for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id,
+ "Failed to set class of device for index %u", adapter->dev_id);
}
void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
uint32_t settings;
if (length < sizeof(settings)) {
- error("Wrong size of new settings parameters");
+ btd_error(adapter->dev_id,
+ "Wrong size of new settings parameters");
return;
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to set mode: %s (0x%02x)",
+ btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
set_mode_complete, adapter, NULL) > 0)
return true;
- error("Failed to set mode for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to set mode for index %u",
+ adapter->dev_id);
return false;
}
set_mode_complete, adapter, NULL) > 0)
return true;
- error("Failed to set mode for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to set mode for index %u",
+ adapter->dev_id);
return false;
}
const struct mgmt_cp_set_local_name *rp = param;
if (length < sizeof(*rp)) {
- error("Wrong size of local name changed parameters");
+ btd_error(adapter->dev_id,
+ "Wrong size of local name changed parameters");
return;
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to set local name: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to set local name: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
strncpy(maxname, name, MAX_NAME_LENGTH);
if (!g_utf8_validate(maxname, -1, NULL)) {
- error("Name change failed: supplied name isn't valid UTF-8");
+ btd_error(adapter->dev_id,
+ "Name change failed: supplied name isn't valid UTF-8");
return -EINVAL;
}
set_local_name_complete, adapter, NULL) > 0)
return 0;
- error("Failed to set local name for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to set local name for index %u",
+ adapter->dev_id);
return -EIO;
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to add UUID: %s (0x%02x)",
+ btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
uint128_t uint128;
if (!is_supported_uuid(uuid)) {
- warn("Ignoring unsupported UUID for addition");
+ btd_warn(adapter->dev_id,
+ "Ignoring unsupported UUID for addition");
return 0;
}
add_uuid_complete, adapter, NULL) > 0)
return 0;
- error("Failed to add UUID for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to add UUID for index %u",
+ adapter->dev_id);
return -EIO;
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to remove UUID: %s (0x%02x)",
+ btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
uint128_t uint128;
if (!is_supported_uuid(uuid)) {
- warn("Ignoring unsupported UUID for removal");
+ btd_warn(adapter->dev_id,
+ "Ignoring unsupported UUID for removal");
return 0;
}
remove_uuid_complete, adapter, NULL) > 0)
return 0;
- error("Failed to remove UUID for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
+ adapter->dev_id);
return -EIO;
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to clear UUIDs: %s (0x%02x)",
+ btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
clear_uuids_complete, adapter, NULL) > 0)
return 0;
- error("Failed to clear UUIDs for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
+ adapter->dev_id);
return -EIO;
}
DBG("status 0x%02x", status);
if (length < sizeof(*rp)) {
- error("Wrong size of start scanning return parameters");
+ btd_error(adapter->dev_id,
+ "Wrong size of start scanning return parameters");
return;
}
* around the time we called stop_passive_scanning().
*/
if (status != MGMT_STATUS_SUCCESS && status != MGMT_STATUS_REJECTED) {
- error("Stopping passive scanning failed: %s",
+ btd_error(adapter->dev_id, "Stopping passive scanning failed: %s",
mgmt_errstr(status));
return;
}
err = device_connect_le(dev);
if (err < 0) {
- error("LE auto connection failed: %s (%d)",
- strerror(-err), -err);
+ btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
+ strerror(-err), -err);
trigger_passive_scanning(adapter);
}
}
DBG("status 0x%02x", status);
if (length < sizeof(*rp)) {
- error("Wrong size of start discovery return parameters");
+ btd_error(adapter->dev_id,
+ "Wrong size of start discovery return parameters");
return;
}
struct btd_adapter *adapter = user_data;
if (length < sizeof(*ev)) {
- error("Too small discovering event");
+ btd_error(adapter->dev_id, "Too small discovering event");
return;
}
DBG("");
if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
- error("discovery_filter_to_mgmt_cp returned error");
+ btd_error(adapter->dev_id,
+ "discovery_filter_to_mgmt_cp returned error");
return;
}
if (status != MGMT_STATUS_SUCCESS) {
const char *dbus_err;
- error("Failed to set mode: %s (0x%02x)",
+ btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
mgmt_errstr(status), status);
if (status == MGMT_STATUS_RFKILLED)
g_free(data);
failed:
- error("Failed to set mode for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to set mode for index %u",
+ adapter->dev_id);
g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
}
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to load link keys for hci%u: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to load link keys for hci%u: %s (0x%02x)",
adapter->dev_id, mgmt_errstr(status), status);
return;
}
cp = g_try_malloc0(cp_size);
if (cp == NULL) {
- error("No memory for link keys for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "No memory for link keys for hci%u",
+ adapter->dev_id);
return;
}
g_free(cp);
if (id == 0)
- error("Failed to load link keys for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
+ adapter->dev_id);
}
static gboolean load_ltks_timeout(gpointer user_data)
{
struct btd_adapter *adapter = user_data;
- error("Loading LTKs timed out for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Loading LTKs timed out for hci%u",
+ adapter->dev_id);
adapter->load_ltks_timeout = 0;
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to load LTKs for hci%u: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to load LTKs for hci%u: %s (0x%02x)",
adapter->dev_id, mgmt_errstr(status), status);
}
cp = g_try_malloc0(cp_size);
if (cp == NULL) {
- error("No memory for LTKs for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
+ adapter->dev_id);
return;
}
g_free(cp);
if (adapter->load_ltks_id == 0) {
- error("Failed to load LTKs for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
+ adapter->dev_id);
return;
}
struct btd_adapter *adapter = user_data;
if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
- info("Load IRKs failed: Kernel doesn't support LE Privacy");
+ btd_info(adapter->dev_id,
+ "Load IRKs failed: Kernel doesn't support LE Privacy");
return;
}
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to load IRKs for hci%u: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to load IRKs for hci%u: %s (0x%02x)",
adapter->dev_id, mgmt_errstr(status), status);
return;
}
cp = g_try_malloc0(cp_size);
if (cp == NULL) {
- error("No memory for IRKs for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
+ adapter->dev_id);
return;
}
g_free(cp);
if (id == 0)
- error("Failed to IRKs for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
+ adapter->dev_id);
}
static void load_conn_params_complete(uint8_t status, uint16_t length,
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("hci%u Load Connection Parameters failed: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "hci%u Load Connection Parameters failed: %s (0x%02x)",
adapter->dev_id, mgmt_errstr(status), status);
return;
}
cp = g_try_malloc0(cp_size);
if (cp == NULL) {
- error("Failed to allocate memory for connection parameters");
+ btd_error(adapter->dev_id,
+ "Failed to allocate memory for connection parameters");
return;
}
g_free(cp);
if (id == 0)
- error("Load connection parameters failed");
+ btd_error(adapter->dev_id, "Load connection parameters failed");
}
static uint8_t get_le_addr_type(GKeyFile *keyfile)
dir = opendir(dirname);
if (!dir) {
- error("Unable to open adapter storage directory: %s", dirname);
+ btd_error(adapter->dev_id,
+ "Unable to open adapter storage directory: %s",
+ dirname);
return;
}
err = driver->probe(adapter);
if (err < 0) {
- error("%s: %s (%d)", driver->name, strerror(-err), -err);
+ btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
+ strerror(-err), -err);
return;
}
err = profile->adapter_probe(profile, adapter);
if (err < 0) {
- error("%s: %s (%d)", profile->name, strerror(-err), -err);
+ btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
+ strerror(-err), -err);
return;
}
device_add_connection(device, bdaddr_type);
if (g_slist_find(adapter->connections, device)) {
- error("Device is already marked as connected");
+ btd_error(adapter->dev_id,
+ "Device is already marked as connected");
return;
}
uint16_t i, conn_count;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to get connections: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to get connections: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
if (length < sizeof(*rp)) {
- error("Wrong size of get connections response");
+ btd_error(adapter->dev_id,
+ "Wrong size of get connections response");
return;
}
if (conn_count * sizeof(struct mgmt_addr_info) +
sizeof(*rp) != length) {
- error("Incorrect packet size for get connections response");
+ btd_error(adapter->dev_id,
+ "Incorrect packet size for get connections response");
return;
}
get_connections_complete, adapter, NULL) > 0)
return;
- error("Failed to get connections for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to get connections for index %u",
+ adapter->dev_id);
}
bool btd_adapter_get_pairable(struct btd_adapter *adapter)
}
if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
- error("Can't add %s to non-LE capable adapter connect list",
+ btd_error(adapter->dev_id,
+ "Can't add %s to non-LE capable adapter connect list",
device_get_path(device));
return -ENOTSUP;
}
char addr[18];
if (length < sizeof(*rp)) {
- error("Too small Add Device complete event");
+ btd_error(adapter->dev_id,
+ "Too small Add Device complete event");
return;
}
dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
rp->addr.type);
if (!dev) {
- error("Add Device complete for unknown device %s", addr);
+ btd_error(adapter->dev_id,
+ "Add Device complete for unknown device %s", addr);
return;
}
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to add device %s: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to add device %s: %s (0x%02x)",
addr, mgmt_errstr(status), status);
return;
}
char addr[18];
if (length < sizeof(*rp)) {
- error("Too small Add Device complete event");
+ btd_error(adapter->dev_id,
+ "Too small Add Device complete event");
return;
}
dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
rp->addr.type);
if (!dev) {
- error("Add Device complete for unknown device %s", addr);
+ btd_error(adapter->dev_id,
+ "Add Device complete for unknown device %s", addr);
return;
}
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to add device %s (%u): %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to add device %s (%u): %s (0x%02x)",
addr, rp->addr.type, mgmt_errstr(status), status);
adapter->connect_list = g_slist_remove(adapter->connect_list,
dev);
{
struct btd_adapter *adapter = user_data;
- error("Confirm name timed out for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Confirm name timed out for hci%u",
+ adapter->dev_id);
adapter->confirm_name_timeout = 0;
struct btd_adapter *adapter = user_data;
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to confirm name for hci%u: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to confirm name for hci%u: %s (0x%02x)",
adapter->dev_id, mgmt_errstr(status), status);
}
* cancel it to be safe here.
*/
if (adapter->confirm_name_id > 0) {
- warn("Found pending confirm name for hci%u", adapter->dev_id);
+ btd_warn(adapter->dev_id,
+ "Found pending confirm name for hci%u",
+ adapter->dev_id);
mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
}
confirm_name_complete, adapter, NULL);
if (adapter->confirm_name_id == 0) {
- error("Failed to confirm name for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to confirm name for hci%u",
+ adapter->dev_id);
return;
}
}
if (!dev) {
- error("Unable to create object for found device %s", addr);
+ btd_error(adapter->dev_id,
+ "Unable to create object for found device %s", addr);
eir_data_free(&eir_data);
return;
}
char addr[18];
if (length < sizeof(*ev)) {
- error("Too short device found event (%u bytes)", length);
+ btd_error(adapter->dev_id,
+ "Too short device found event (%u bytes)", length);
return;
}
eir_len = btohs(ev->eir_len);
if (length != sizeof(*ev) + eir_len) {
- error("Device found event size mismatch (%u != %zu)",
+ btd_error(adapter->dev_id,
+ "Device found event size mismatch (%u != %zu)",
length, sizeof(*ev) + eir_len);
return;
}
DBG("");
if (!g_slist_find(adapter->connections, device)) {
- error("No matching connection for device");
+ btd_error(adapter->dev_id, "No matching connection for device");
return;
}
auth->agent = agent_get(NULL);
if (auth->agent == NULL) {
- warn("Authentication attempt without agent");
+ btd_warn(adapter->dev_id,
+ "Authentication attempt without agent");
auth->cb(&err, auth->user_data);
goto next;
}
/* Device connected? */
if (!g_slist_find(adapter->connections, device))
- error("Authorization request for non-connected device!?");
+ btd_error(adapter->dev_id,
+ "Authorization request for non-connected device!?");
auth = g_try_new0(struct service_auth, 1);
if (!auth)
int err;
if (length < sizeof(*ev)) {
- error("Too small user confirm request event");
+ btd_error(adapter->dev_id,
+ "Too small user confirm request event");
return;
}
device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
ev->addr.type);
if (!device) {
- error("Unable to get device object for %s", addr);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", addr);
return;
}
err = device_confirm_passkey(device, btohl(ev->value),
ev->confirm_hint);
if (err < 0) {
- error("device_confirm_passkey: %s", strerror(-err));
+ btd_error(adapter->dev_id,
+ "device_confirm_passkey: %s", strerror(-err));
btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
ev->addr.type, FALSE);
}
int err;
if (length < sizeof(*ev)) {
- error("Too small passkey request event");
+ btd_error(adapter->dev_id, "Too small passkey request event");
return;
}
device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
ev->addr.type);
if (!device) {
- error("Unable to get device object for %s", addr);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", addr);
return;
}
err = device_request_passkey(device);
if (err < 0) {
- error("device_request_passkey: %s", strerror(-err));
+ btd_error(adapter->dev_id,
+ "device_request_passkey: %s", strerror(-err));
btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
ev->addr.type, INVALID_PASSKEY);
}
int err;
if (length < sizeof(*ev)) {
- error("Too small passkey notify event");
+ btd_error(adapter->dev_id, "Too small passkey notify event");
return;
}
device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
ev->addr.type);
if (!device) {
- error("Unable to get device object for %s", addr);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", addr);
return;
}
err = device_notify_passkey(device, passkey, ev->entered);
if (err < 0)
- error("device_notify_passkey: %s", strerror(-err));
+ btd_error(adapter->dev_id,
+ "device_notify_passkey: %s", strerror(-err));
}
struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
struct btd_adapter_pin_cb_iter *iter;
if (length < sizeof(*ev)) {
- error("Too small PIN code request event");
+ btd_error(adapter->dev_id, "Too small PIN code request event");
return;
}
device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
ev->addr.type);
if (!device) {
- error("Unable to get device object for %s", addr);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", addr);
return;
}
if (display && device_is_bonding(device, NULL)) {
err = device_notify_pincode(device, ev->secure, pin);
if (err < 0) {
- error("device_notify_pin: %s", strerror(-err));
+ btd_error(adapter->dev_id,
+ "device_notify_pin: %s",
+ strerror(-err));
btd_adapter_pincode_reply(adapter,
&ev->addr.bdaddr,
NULL, 0);
err = device_request_pincode(device, ev->secure);
if (err < 0) {
- error("device_request_pin: %s", strerror(-err));
+ btd_error(adapter->dev_id, "device_request_pin: %s",
+ strerror(-err));
btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
}
}
struct pair_device_data *data = user_data;
struct btd_adapter *adapter = data->adapter;
- error("Pair device timed out for hci%u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Pair device timed out for hci%u",
+ adapter->dev_id);
adapter->pair_device_timeout = 0;
* powered.
*/
if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
- error("Pair device failed: %s (0x%02x)",
+ btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
mgmt_errstr(status), status);
bonding_attempt_complete(adapter, &data->bdaddr,
}
if (length < sizeof(*rp)) {
- error("Too small pair device response");
+ btd_error(adapter->dev_id, "Too small pair device response");
return;
}
uint8_t addr_type, uint8_t io_cap)
{
if (adapter->pair_device_id > 0) {
- error("Unable pair since another pairing is in progress");
+ btd_error(adapter->dev_id,
+ "Unable pair since another pairing is in progress");
return -EBUSY;
}
free_pair_device_data);
if (id == 0) {
- error("Failed to pair %s for hci%u", addr, adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
+ addr, adapter->dev_id);
free_pair_device_data(data);
return -EIO;
}
struct btd_adapter *adapter = user_data;
if (status == MGMT_STATUS_NOT_CONNECTED) {
- warn("Disconnecting failed: already disconnected");
+ btd_warn(adapter->dev_id,
+ "Disconnecting failed: already disconnected");
} else if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to disconnect device: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to disconnect device: %s (0x%02x)",
mgmt_errstr(status), status);
return;
}
if (length < sizeof(*rp)) {
- error("Too small device disconnect response");
+ btd_error(adapter->dev_id,
+ "Too small device disconnect response");
return;
}
struct btd_adapter *adapter = user_data;
if (length < sizeof(*ev)) {
- error("Too small auth failed mgmt event");
+ btd_error(adapter->dev_id, "Too small auth failed mgmt event");
return;
}
char dst[18];
if (length < sizeof(*ev)) {
- error("Too small new link key event");
+ btd_error(adapter->dev_id, "Too small new link key event");
return;
}
ev->store_hint);
if (ev->key.pin_len > 16) {
- error("Invalid PIN length (%u) in new_key event",
+ btd_error(adapter->dev_id,
+ "Invalid PIN length (%u) in new_key event",
ev->key.pin_len);
return;
}
device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
if (!device) {
- error("Unable to get device object for %s", dst);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", dst);
return;
}
char dst[18];
if (length < sizeof(*ev)) {
- error("Too small long term key event");
+ btd_error(adapter->dev_id, "Too small long term key event");
return;
}
device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
if (!device) {
- error("Unable to get device object for %s", dst);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", dst);
return;
}
char dst[18];
if (length < sizeof(*ev)) {
- error("Too small CSRK event");
+ btd_error(adapter->dev_id, "Too small CSRK event");
return;
}
device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
if (!device) {
- error("Unable to get device object for %s", dst);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", dst);
return;
}
char dst[18], rpa[18];
if (length < sizeof(*ev)) {
- error("Too small New IRK event");
+ btd_error(adapter->dev_id, "Too small New IRK event");
return;
}
}
if (!device) {
- error("Unable to get device object for %s", dst);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", dst);
return;
}
if (length < sizeof(*ev)) {
- error("Too small New Connection Parameter event");
+ btd_error(adapter->dev_id,
+ "Too small New Connection Parameter event");
return;
}
dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
if (!dev) {
- error("Unable to get device object for %s", dst);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", dst);
return;
}
const uint8_t *hash, *randomizer;
if (status != MGMT_STATUS_SUCCESS) {
- error("Read local OOB data failed: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Read local OOB data failed: %s (0x%02x)",
mgmt_errstr(status), status);
hash = NULL;
randomizer = NULL;
} else if (length < sizeof(*rp)) {
- error("Too small read local OOB data response");
+ btd_error(adapter->dev_id,
+ "Too small read local OOB data response");
return;
} else {
hash = rp->hash192;
adapter_methods, NULL,
adapter_properties, adapter,
adapter_free)) {
- error("Adapter interface init failed on path %s",
+ btd_error(adapter->dev_id,
+ "Adapter interface init failed on path %s",
adapter->path);
g_free(adapter->path);
adapter->path = NULL;
adapter->database = btd_gatt_database_new(adapter);
if (!adapter->database) {
- error("Failed to create GATT database for adapter");
+ btd_error(adapter->dev_id,
+ "Failed to create GATT database for adapter");
adapters = g_slist_remove(adapters, adapter);
return -EINVAL;
}
adapter->adv_manager =
btd_advertising_manager_new(adapter);
} else {
- info("LEAdvertisingManager skipped, LE unavailable");
+ btd_info(adapter->dev_id,
+ "LEAdvertisingManager skipped, LE unavailable");
}
}
uint8_t reason;
if (length < sizeof(struct mgmt_addr_info)) {
- error("Too small device disconnected event");
+ btd_error(adapter->dev_id,
+ "Too small device disconnected event");
return;
}
bool name_known;
if (length < sizeof(*ev)) {
- error("Too small device connected event");
+ btd_error(adapter->dev_id, "Too small device connected event");
return;
}
eir_len = btohs(ev->eir_len);
if (length < sizeof(*ev) + eir_len) {
- error("Too small device connected event");
+ btd_error(adapter->dev_id, "Too small device connected event");
return;
}
device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
ev->addr.type);
if (!device) {
- error("Unable to get device object for %s", addr);
+ btd_error(adapter->dev_id,
+ "Unable to get device object for %s", addr);
return;
}
char addr[18];
if (length < sizeof(*ev)) {
- error("Too small device blocked event");
+ btd_error(adapter->dev_id, "Too small device blocked event");
return;
}
char addr[18];
if (length < sizeof(*ev)) {
- error("Too small device unblocked event");
+ btd_error(adapter->dev_id, "Too small device unblocked event");
return;
}
char addr[18];
if (length < sizeof(*ev)) {
- error("Too small connect failed event");
+ btd_error(adapter->dev_id, "Too small connect failed event");
return;
}
char addr[18];
if (length < sizeof(*ev)) {
- error("Too small device unpaired event");
+ btd_error(adapter->dev_id, "Too small device unpaired event");
return;
}
device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
ev->addr.type);
if (!device) {
- warn("No device object for unpaired device %s", addr);
+ btd_warn(adapter->dev_id,
+ "No device object for unpaired device %s", addr);
return;
}
clear_devices_complete, adapter, NULL) > 0)
return 0;
- error("Failed to clear devices for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "Failed to clear devices for index %u",
+ adapter->dev_id);
return -EIO;
}
DBG("index %u status 0x%02x", adapter->dev_id, status);
if (status != MGMT_STATUS_SUCCESS) {
- error("Failed to read info for index %u: %s (0x%02x)",
+ btd_error(adapter->dev_id,
+ "Failed to read info for index %u: %s (0x%02x)",
adapter->dev_id, mgmt_errstr(status), status);
goto failed;
}
if (length < sizeof(*rp)) {
- error("Too small read info complete response");
+ btd_error(adapter->dev_id,
+ "Too small read info complete response");
goto failed;
}
if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
- error("No Bluetooth address for index %u", adapter->dev_id);
+ btd_error(adapter->dev_id, "No Bluetooth address for index %u",
+ adapter->dev_id);
goto failed;
}
break;
case BT_MODE_BREDR:
if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
- error("Ignoring adapter withouth BR/EDR support");
+ btd_error(adapter->dev_id,
+ "Ignoring adapter withouth BR/EDR support");
goto failed;
}
break;
case BT_MODE_LE:
if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
- error("Ignoring adapter withouth LE support");
+ btd_error(adapter->dev_id,
+ "Ignoring adapter withouth LE support");
goto failed;
}
err = adapter_register(adapter);
if (err < 0) {
- error("Unable to register new adapter");
+ btd_error(adapter->dev_id, "Unable to register new adapter");
goto failed;
}
adapter = btd_adapter_lookup(index);
if (adapter) {
- warn("Ignoring index added for an already existing adapter");
+ btd_warn(adapter->dev_id,
+ "Ignoring index added for an already existing adapter");
return;
}
adapter = btd_adapter_new(index);
if (!adapter) {
- error("Unable to create new adapter for index %u", index);
+ btd_error(adapter->dev_id,
+ "Unable to create new adapter for index %u", index);
return;
}
read_info_complete, adapter, NULL) > 0)
return;
- error("Failed to read controller info for index %u", index);
+ btd_error(adapter->dev_id,
+ "Failed to read controller info for index %u", index);
adapter_list = g_list_remove(adapter_list, adapter);