static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct agent *agent; const char *sender, *path; sender = dbus_message_get_sender(msg); agent = g_hash_table_lookup(agent_list, sender); if (!agent) return btd_error_does_not_exist(msg); DBG("agent %s", agent->owner); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) == FALSE) return btd_error_invalid_args(msg); if (g_str_equal(path, agent->path) == FALSE) return btd_error_does_not_exist(msg); agent_disconnect(conn, agent); return dbus_message_new_method_return(msg); }
static DBusMessage *unregister_watcher(DBusConnection *conn, DBusMessage *msg, void *data) { struct heartrate_adapter *hradapter = data; struct watcher *watcher; const char *sender = dbus_message_get_sender(msg); char *path; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); watcher = find_watcher(hradapter->watchers, sender, path); if (watcher == NULL) return btd_error_does_not_exist(msg); hradapter->watchers = g_slist_remove(hradapter->watchers, watcher); g_dbus_remove_watch(conn, watcher->id); if (g_slist_length(hradapter->watchers) == 0) g_slist_foreach(hradapter->devices, disable_measurement, 0); DBG("heartrate watcher [%s] unregistered", path); return dbus_message_new_method_return(msg); }
static DBusMessage *unregister_advertisement(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct btd_advertising *manager = user_data; DBusMessageIter args; struct advertisement *ad; struct dbus_obj_match match; DBG("UnregisterAdvertisement"); if (!dbus_message_iter_init(msg, &args)) return btd_error_invalid_args(msg); if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH) return btd_error_invalid_args(msg); dbus_message_iter_get_basic(&args, &match.path); match.owner = dbus_message_get_sender(msg); ad = queue_find(manager->ads, match_advertisement, &match); if (!ad) return btd_error_does_not_exist(msg); advertisement_remove(ad); return dbus_message_new_method_return(msg); }
static DBusMessage *port_disconnect(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct serial_device *device = user_data; struct serial_port *port; const char *dev, *owner, *caller; if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &dev, DBUS_TYPE_INVALID) == FALSE) return NULL; port = find_port(device->ports, dev); if (!port) return btd_error_does_not_exist(msg); if (!port->listener_id) return btd_error_not_connected(msg); owner = dbus_message_get_sender(port->msg); caller = dbus_message_get_sender(msg); if (!g_str_equal(owner, caller)) return btd_error_not_authorized(msg); port_release(port); g_dbus_remove_watch(conn, port->listener_id); port->listener_id = 0; return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); }
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 DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg, void *data) { struct audio_device *device = data; struct gateway *gw = device->gateway; const char *path; if (!gw->agent) goto done; if (strcmp(gw->agent->name, dbus_message_get_sender(msg)) != 0) return btd_error_not_authorized(msg); if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); if (strcmp(gw->agent->path, path) != 0) return btd_error_does_not_exist(msg); g_dbus_remove_watch(conn, gw->agent->watch); agent_free(gw->agent); gw->agent = NULL; done: return dbus_message_new_method_return(msg); }
static DBusMessage *request_default(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct agent *agent; const char *sender, *path; sender = dbus_message_get_sender(msg); agent = g_hash_table_lookup(agent_list, sender); if (!agent) return btd_error_does_not_exist(msg); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) == FALSE) return btd_error_invalid_args(msg); if (g_str_equal(path, agent->path) == FALSE) return btd_error_does_not_exist(msg); if (!add_default_agent(agent)) return btd_error_failed(msg, "Failed to set as default"); return dbus_message_new_method_return(msg); }
static DBusMessage *port_connect(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct serial_device *device = user_data; struct serial_port *port; const char *pattern; int err; if (dbus_message_has_member(msg, "ConnectFD") && DBUS_TYPE_UNIX_FD < 0) return btd_error_not_supported(msg); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, DBUS_TYPE_INVALID) == FALSE) return NULL; port = find_port(device->ports, pattern); if (!port) { char *endptr = NULL; int channel; channel = strtol(pattern, &endptr, 10); if ((endptr && *endptr != '\0') || channel < 1 || channel > 30) return btd_error_does_not_exist(msg); port = create_port(device, NULL, channel); } if (port->listener_id) return btd_error_failed(msg, "Port already in use"); port->listener_id = g_dbus_add_disconnect_watch(conn, dbus_message_get_sender(msg), port_owner_exited, port, NULL); port->msg = dbus_message_ref(msg); err = connect_port(port); if (err < 0) { error("%s", strerror(-err)); g_dbus_remove_watch(conn, port->listener_id); port->listener_id = 0; return btd_error_failed(msg, strerror(-err)); } return NULL; }
static DBusMessage *unregister_endpoint(DBusConnection *conn, DBusMessage *msg, void *data) { struct media_adapter *adapter = data; struct media_endpoint *endpoint; const char *sender, *path; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); sender = dbus_message_get_sender(msg); endpoint = media_adapter_find_endpoint(adapter, sender, path, NULL); if (endpoint == NULL) return btd_error_does_not_exist(msg); media_endpoint_remove(endpoint); return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); }
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; }