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)); }