static void avctp_control_confirm(struct avctp *session, GIOChannel *chan,
struct btd_device *dev)
{
const bdaddr_t *src;
const bdaddr_t *dst;
if (session->control != NULL) {
error("Control: Refusing unexpected connect");
g_io_channel_shutdown(chan, TRUE, NULL);
return;
}
avctp_set_state(session, AVCTP_STATE_CONNECTING);
session->control = avctp_channel_create(session, chan, NULL);
src = adapter_get_address(device_get_adapter(dev));
dst = device_get_address(dev);
session->auth_id = btd_request_authorization(src, dst,
AVRCP_TARGET_UUID,
auth_cb, session);
if (session->auth_id == 0)
goto drop;
session->control->watch = g_io_add_watch(chan, G_IO_ERR | G_IO_HUP |
G_IO_NVAL, session_cb, session);
return;
drop:
avctp_set_state(session, AVCTP_STATE_DISCONNECTED);
}
int audio_device_request_authorization(struct audio_device *dev,
const char *uuid, service_auth_cb cb,
void *user_data)
{
struct dev_priv *priv = dev->priv;
struct service_auth *auth;
int err;
auth = g_try_new0(struct service_auth, 1);
if (!auth)
return -ENOMEM;
auth->cb = cb;
auth->user_data = user_data;
priv->auths = g_slist_append(priv->auths, auth);
if (g_slist_length(priv->auths) > 1)
return 0;
if (priv->authorized || audio_device_is_connected(dev)) {
priv->auth_idle_id = g_idle_add(auth_idle_cb, dev);
return 0;
}
err = btd_request_authorization(&dev->src, &dev->dst, uuid, auth_cb,
dev);
if (err < 0) {
priv->auths = g_slist_remove(priv->auths, auth);
g_free(auth);
}
return err;
}
static void confirm_cb(GIOChannel *io, gpointer user_data)
{
struct dun_server *server = user_data;
struct dun_client *client = &server->client;
GError *err = NULL;
if (client->io) {
error("Rejecting DUN connection since one already exists");
return;
}
bt_io_get(io, BT_IO_RFCOMM, &err,
BT_IO_OPT_DEST_BDADDR, &client->bda,
BT_IO_OPT_INVALID);
if (err != NULL) {
error("Unable to get DUN source and dest address: %s",
err->message);
g_error_free(err);
return;
}
if (btd_request_authorization(&server->bda, &client->bda, DUN_UUID,
auth_cb, user_data) < 0) {
error("Requesting DUN authorization failed");
return;
}
client->io_watch = g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) auth_watch, server);
client->io = g_io_channel_ref(io);
}
static DBusMessage *cancel_authorization(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
struct service_adapter *serv_adapter = data;
struct pending_auth *auth;
const gchar *sender;
sender = dbus_message_get_sender(msg);
auth = find_pending_by_sender(serv_adapter, sender);
if (auth == NULL)
return btd_error_does_not_exist(msg);
btd_cancel_authorization(auth->id);
reply = btd_error_not_authorized(auth->msg);
dbus_message_unref(auth->msg);
g_dbus_send_message(btd_get_dbus_connection(), reply);
serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
auth);
g_free(auth);
auth = next_pending(serv_adapter);
if (auth == NULL)
goto done;
auth->id = btd_request_authorization(get_address(serv_adapter),
&auth->dst, auth->uuid,
auth_cb, serv_adapter);
done:
return dbus_message_new_method_return(msg);
}
static void connect_confirm_cb(GIOChannel *io, gpointer data)
{
struct sap_server *server = data;
struct sap_connection *conn = server->conn;
GError *gerr = NULL;
bdaddr_t src, dst;
char dstaddr[18];
int err;
DBG("conn %p io %p", conn, io);
if (!io)
return;
if (conn) {
DBG("Another SAP connection already exists.");
g_io_channel_shutdown(io, TRUE, NULL);
return;
}
conn = g_try_new0(struct sap_connection, 1);
if (!conn) {
error("Can't allocate memory for incoming SAP connection.");
g_io_channel_shutdown(io, TRUE, NULL);
return;
}
g_io_channel_set_encoding(io, NULL, NULL);
g_io_channel_set_buffered(io, FALSE);
server->conn = conn;
conn->io = g_io_channel_ref(io);
conn->state = SAP_STATE_DISCONNECTED;
bt_io_get(io, BT_IO_RFCOMM, &gerr,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_INVALID);
if (gerr) {
error("%s", gerr->message);
g_error_free(gerr);
sap_server_remove_conn(server);
return;
}
ba2str(&dst, dstaddr);
err = btd_request_authorization(&src, &dst, SAP_UUID, connect_auth_cb,
server);
if (err < 0) {
error("Authorization failure (err %d)", err);
sap_server_remove_conn(server);
return;
}
DBG("Authorizing incoming SAP connection from %s", dstaddr);
}
static void confirm_event(GIOChannel *chan, gpointer user_data)
{
struct network_adapter *na = user_data;
struct network_server *ns;
int perr;
bdaddr_t src, dst;
char address[18];
GError *err = NULL;
bt_io_get(chan, BT_IO_L2CAP, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_DEST, address,
BT_IO_OPT_INVALID);
if (err) {
error("%s", err->message);
g_error_free(err);
goto drop;
}
DBG("BNEP: incoming connect from %s", address);
if (na->setup) {
error("Refusing connect from %s: setup in progress", address);
goto drop;
}
ns = find_server(na->servers, BNEP_SVC_NAP);
if (!ns)
goto drop;
if (!ns->record_id)
goto drop;
if (!ns->bridge)
goto drop;
na->setup = g_new0(struct network_session, 1);
bacpy(&na->setup->dst, &dst);
na->setup->io = g_io_channel_ref(chan);
perr = btd_request_authorization(&src, &dst, BNEP_SVC_UUID,
auth_cb, na);
if (perr < 0) {
error("Refusing connect from %s: %s (%d)", address,
strerror(-perr), -perr);
setup_destroy(na);
goto drop;
}
return;
drop:
g_io_channel_shutdown(chan, TRUE, NULL);
}
static void confirm_event_cb(GIOChannel *chan, gpointer user_data)
{
struct input_server *server = user_data;
bdaddr_t src, dst;
GError *err = NULL;
char addr[18];
guint ret;
DBG("");
bt_io_get(chan, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_INVALID);
if (err) {
error("%s", err->message);
g_error_free(err);
goto drop;
}
ba2str(&dst, addr);
if (server->confirm) {
error("Refusing connection from %s: setup in progress", addr);
goto drop;
}
if (!input_device_exists(&src, &dst) && !dev_is_sixaxis(&src, &dst)) {
error("Refusing connection from %s: unknown device", addr);
goto drop;
}
server->confirm = g_io_channel_ref(chan);
ret = btd_request_authorization(&src, &dst, HID_UUID,
auth_callback, server);
if (ret != 0)
return;
error("input: authorization for device %s failed", addr);
g_io_channel_unref(server->confirm);
server->confirm = NULL;
drop:
input_device_close_channels(&src, &dst);
g_io_channel_shutdown(chan, TRUE, NULL);
}
static DBusMessage *cancel_authorization(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
struct service_adapter *serv_adapter = data;
struct pending_auth *auth;
const gchar *sender;
bdaddr_t src;
sender = dbus_message_get_sender(msg);
auth = find_pending_by_sender(serv_adapter, sender);
if (auth == NULL)
return does_not_exist(msg);
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
btd_cancel_authorization(&src, &auth->dst);
reply = not_authorized(auth->msg);
dbus_message_unref(auth->msg);
g_dbus_send_message(auth->conn, reply);
dbus_connection_unref(auth->conn);
serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
auth);
g_free(auth);
auth = next_pending(serv_adapter);
if (auth == NULL)
goto done;
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
btd_request_authorization(&src, &auth->dst,
auth->uuid, auth_cb, serv_adapter);
done:
return dbus_message_new_method_return(msg);
}
static void confirm_event_cb(GIOChannel *chan, gpointer user_data)
{
struct input_server *server = user_data;
bdaddr_t src, dst;
GError *err = NULL;
char addr[18];
int ret;
bt_io_get(chan, BT_IO_L2CAP, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_INVALID);
if (err) {
error("%s", err->message);
g_error_free(err);
goto drop;
}
if (server->confirm) {
char address[18];
ba2str(&dst, address);
error("Refusing connection from %s: setup in progress",
address);
goto drop;
}
server->confirm = g_io_channel_ref(chan);
ret = btd_request_authorization(&src, &dst, HID_UUID,
auth_callback, server);
if (ret == 0)
return;
ba2str(&src, addr);
error("input: authorization for %s failed: %s (%d)",
addr, strerror(-ret), ret);
g_io_channel_unref(server->confirm);
server->confirm = NULL;
drop:
input_device_close_channels(&src, &dst);
g_io_channel_shutdown(chan, TRUE, NULL);
}
static void auth_cb(DBusError *derr, void *user_data)
{
struct service_adapter *serv_adapter = user_data;
DBusMessage *reply;
struct pending_auth *auth;
bdaddr_t src;
auth = next_pending(serv_adapter);
if (auth == NULL) {
info("Authorization cancelled: Client exited");
return;
}
if (derr) {
error("Access denied: %s", derr->message);
reply = btd_error_not_authorized(auth->msg);
dbus_message_unref(auth->msg);
g_dbus_send_message(auth->conn, reply);
goto done;
}
g_dbus_send_reply(auth->conn, auth->msg,
DBUS_TYPE_INVALID);
done:
dbus_connection_unref(auth->conn);
serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
auth);
g_free(auth);
auth = next_pending(serv_adapter);
if (auth == NULL)
return;
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
btd_request_authorization(&src, &auth->dst,
auth->uuid, auth_cb, serv_adapter);
}
static void confirm_event_cb(GIOChannel *chan, gpointer user_data)
{
struct serial_proxy *prx = user_data;
int perr;
char address[18];
GError *err = NULL;
bt_io_get(chan, BT_IO_RFCOMM, &err,
BT_IO_OPT_DEST_BDADDR, &prx->dst,
BT_IO_OPT_DEST, address,
BT_IO_OPT_INVALID);
if (err) {
error("%s", err->message);
g_error_free(err);
goto drop;
}
if (prx->rfcomm) {
error("Refusing connect from %s: Proxy already in use",
address);
goto drop;
}
debug("Serial Proxy: incoming connect from %s", address);
prx->rfcomm = g_io_channel_ref(chan);
perr = btd_request_authorization(&prx->src, &prx->dst,
prx->uuid128, auth_cb, prx);
if (perr < 0) {
error("Refusing connect from %s: %s (%d)", address,
strerror(-perr), -perr);
g_io_channel_unref(prx->rfcomm);
prx->rfcomm = NULL;
goto drop;
}
return;
drop:
g_io_channel_shutdown(chan, TRUE, NULL);
}
static void avctp_control_confirm(struct avctp *session, GIOChannel *chan,
struct btd_device *dev)
{
const bdaddr_t *src;
const bdaddr_t *dst;
if (session->control != NULL) {
error("Control: Refusing unexpected connect");
g_io_channel_shutdown(chan, TRUE, NULL);
/*
* Close AVCTP channel if remote tried connect
* at the same time
* AVRCP SPEC V1.5 4.1.1 Connection Establishment
*/
avctp_set_state(session, AVCTP_STATE_DISCONNECTED, -EAGAIN);
return;
}
avctp_set_state(session, AVCTP_STATE_CONNECTING, 0);
session->control = avctp_channel_create(session, chan, 2, NULL);
src = btd_adapter_get_address(device_get_adapter(dev));
dst = device_get_address(dev);
session->auth_id = btd_request_authorization(src, dst,
AVRCP_REMOTE_UUID,
auth_cb, session);
if (session->auth_id == 0)
goto drop;
session->control->watch = g_io_add_watch(chan, G_IO_ERR | G_IO_HUP |
G_IO_NVAL, session_cb, session);
return;
drop:
avctp_set_state(session, AVCTP_STATE_DISCONNECTED, -EIO);
}
static void ext_confirm(GIOChannel *io, gpointer user_data)
{
struct ext_io *server = user_data;
struct ext_profile *ext = server->ext;
struct ext_io *conn;
GError *gerr = NULL;
bdaddr_t src, dst;
char addr[18];
bt_io_get(io, &gerr,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_DEST, addr,
BT_IO_OPT_INVALID);
if (gerr != NULL) {
error("%s failed to get connect data: %s", ext->name,
gerr->message);
g_error_free(gerr);
return;
}
DBG("incoming connect from %s", addr);
conn = create_conn(server, io);
conn->auth_id = btd_request_authorization(&src, &dst, ext->uuid,
ext_auth, conn);
if (conn->auth_id == 0) {
error("%s authorization failure", ext->name);
ext_io_destroy(conn);
return;
}
ext->conns = g_slist_append(ext->conns, conn);
DBG("%s authorizing connection from %s", ext->name, addr);
}
static DBusMessage *request_authorization(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct record_data *user_record;
struct service_adapter *serv_adapter = data;
sdp_record_t *record;
sdp_list_t *services;
const char *sender;
dbus_uint32_t handle;
const char *address;
struct pending_auth *auth;
char uuid_str[MAX_LEN_UUID_STR];
uuid_t *uuid, *uuid128;
bdaddr_t src;
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
DBUS_TYPE_UINT32, &handle,
DBUS_TYPE_INVALID) == FALSE)
return NULL;
sender = dbus_message_get_sender(msg);
if (find_pending_by_sender(serv_adapter, sender))
return btd_error_does_not_exist(msg);
user_record = find_record(serv_adapter, handle, sender);
if (!user_record) {
user_record = find_record(serv_adapter_any, handle, sender);
if (!user_record)
return btd_error_not_authorized(msg);
}
record = sdp_record_find(user_record->handle);
if (record == NULL)
return btd_error_not_authorized(msg);
if (sdp_get_service_classes(record, &services) < 0) {
sdp_record_free(record);
return btd_error_not_authorized(msg);
}
if (services == NULL)
return btd_error_not_authorized(msg);
uuid = services->data;
uuid128 = sdp_uuid_to_uuid128(uuid);
sdp_list_free(services, bt_free);
if (sdp_uuid2strn(uuid128, uuid_str, MAX_LEN_UUID_STR) < 0) {
bt_free(uuid128);
return btd_error_not_authorized(msg);
}
bt_free(uuid128);
auth = g_new0(struct pending_auth, 1);
auth->msg = dbus_message_ref(msg);
auth->conn = dbus_connection_ref(connection);
auth->sender = user_record->sender;
memcpy(auth->uuid, uuid_str, MAX_LEN_UUID_STR);
str2ba(address, &auth->dst);
serv_adapter->pending_list = g_slist_append(serv_adapter->pending_list,
auth);
auth = next_pending(serv_adapter);
if (auth == NULL)
return btd_error_does_not_exist(msg);
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
if (btd_request_authorization(&src, &auth->dst, auth->uuid, auth_cb,
serv_adapter) < 0) {
serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
auth);
g_free(auth);
return btd_error_not_authorized(msg);
}
return NULL;
}
static void connect_confirm_cb(GIOChannel *io, gpointer data)
{
struct sap_connection *conn = server->conn;
GError *gerr = NULL;
bdaddr_t src, dst;
char srcaddr[18], dstaddr[18];
int err;
DBG("io %p data %p ", io, data);
if (!io)
return;
if (conn) {
g_io_channel_shutdown(io, TRUE, NULL);
return;
}
conn = g_try_new0(struct sap_connection, 1);
if (!conn) {
error("Can't allocate memory for incomming SAP connection.");
g_io_channel_shutdown(io, TRUE, NULL);
return;
}
g_io_channel_set_encoding(io, NULL, NULL);
g_io_channel_set_buffered(io, FALSE);
server->conn = conn;
conn->io = g_io_channel_ref(io);
conn->state = SAP_STATE_DISCONNECTED;
bt_io_get(io, BT_IO_RFCOMM, &gerr,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_INVALID);
if (gerr) {
error("%s", gerr->message);
g_error_free(gerr);
sap_conn_remove(conn);
return;
}
//client_to_be_authorized = &dst;
ba2str(&dst, dstaddr);
ba2str(&src, srcaddr);
if(sap_check_weak_linkkey(srcaddr, dstaddr) == TRUE)
{
DBG("SAP weak_key was detected.");
sap_connect_rsp(conn, SAP_STATUS_CONNECTION_FAILED,
SAP_BUF_SIZE);
sap_conn_remove(conn);
return;
}
err = btd_request_authorization(&src, &dst, SAP_UUID,
connect_auth_cb, conn);
if (err < 0) {
DBG("Authorization denied: %d %s", err, strerror(err));
sap_conn_remove(conn);
return;
}
DBG("SAP incoming connection (sock %d) authorization.",
g_io_channel_unix_get_fd(io));
}
