static DBusHandlerResult register_passkey_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct passkey_agent *agent, ref;
struct adapter *adapter;
DBusMessage *reply;
const char *path, *addr;
if (!data) {
error("register_passkey_agent called without any adapter info!");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
adapter = data;
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_STRING, &addr,
DBUS_TYPE_INVALID))
return error_invalid_arguments(conn, msg, NULL);
if ((check_address(addr) < 0) || (path[0] != '/'))
return error_invalid_arguments(conn, msg, NULL);
memset(&ref, 0, sizeof(ref));
ref.name = (char *) dbus_message_get_sender(msg);
ref.addr = (char *) addr;
ref.path = (char *) path;
if (g_slist_find_custom(adapter->passkey_agents, &ref, (GCompareFunc) agent_cmp))
return error_passkey_agent_already_exists(conn, msg);
agent = passkey_agent_new(adapter, conn, ref.name, path, addr);
if (!agent)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
reply = dbus_message_new_method_return(msg);
if (!reply) {
agent->exited = 1;
passkey_agent_free(agent);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
/* Only add a name listener if there isn't one already for this name */
ref.addr = NULL;
ref.path = NULL;
if (!g_slist_find_custom(adapter->passkey_agents, &ref, (GCompareFunc) agent_cmp))
name_listener_add(conn, ref.name, (name_cb_t) agent_exited, adapter);
agent->timeout = g_timeout_add(AGENT_TIMEOUT, (GSourceFunc)agent_timeout, agent);
adapter->passkey_agents = g_slist_append(adapter->passkey_agents, agent);
return send_message_and_unref(conn, reply);
}
static DBusHandlerResult unregister_default_passkey_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
const char *path, *name;
if (!default_agent)
return error_passkey_agent_does_not_exist(conn, msg);
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_INVALID))
return error_invalid_arguments(conn, msg, NULL);
name = dbus_message_get_sender(msg);
if (strcmp(name, default_agent->name) || strcmp(path, default_agent->path))
return error_passkey_agent_does_not_exist(conn, msg);
reply = dbus_message_new_method_return(msg);
if (!reply)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
name_listener_remove(conn, default_agent->name,
(name_cb_t) default_agent_exited, NULL);
info("Default passkey agent (%s, %s) unregistered",
default_agent->name, default_agent->path);
default_agent->exited = 1;
passkey_agent_free(default_agent);
default_agent = NULL;
return send_message_and_unref(conn, reply);
}
/*
* Phdc Manager requests to be removed from the existing list of managers.
*/
static DBusMessage *dbus_unregister_phdc_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct near_phdc_data *mgr;
DBusMessageIter iter;
const char *path, *role, *sender;
DBG("conn %p", conn);
if (!dbus_message_iter_init(msg, &iter))
return error_invalid_arguments(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
return error_invalid_arguments(msg);
sender = dbus_message_get_sender(msg);
dbus_message_iter_get_basic(&iter, &path);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return error_invalid_arguments(msg);
dbus_message_iter_get_basic(&iter, &role);
/* look for specific path */
mgr = search_mgr_list_by_path(path);
if (!mgr)
return error_not_found(msg);
DBG("%s", mgr->sender);
if (strncmp(sender, mgr->sender, strlen(mgr->sender)))
return error_permission_denied(msg);
/* remove it */
near_p2p_unregister(mgr->p2p_driver);
g_hash_table_remove(mgr_list, mgr->p2p_driver->service_name);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusHandlerResult unregister_passkey_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct adapter *adapter;
GSList *match;
struct passkey_agent ref, *agent;
DBusMessage *reply;
const char *path, *addr;
if (!data) {
error("unregister_passkey_agent called without any adapter info!");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
adapter = data;
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_STRING, &addr,
DBUS_TYPE_INVALID))
return error_invalid_arguments(conn, msg, NULL);
memset(&ref, 0, sizeof(ref));
ref.name = (char *) dbus_message_get_sender(msg);
ref.path = (char *) path;
ref.addr = (char *) addr;
match = g_slist_find_custom(adapter->passkey_agents, &ref, (GCompareFunc) agent_cmp);
if (!match)
return error_passkey_agent_does_not_exist(conn, msg);
agent = match->data;
name_listener_remove(agent->conn, agent->name,
(name_cb_t) agent_exited, adapter);
adapter->passkey_agents = g_slist_remove(adapter->passkey_agents, agent);
agent->exited = 1;
passkey_agent_free(agent);
reply = dbus_message_new_method_return(msg);
if (!reply)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
return send_message_and_unref(conn, reply);
}
static DBusHandlerResult register_default_auth_agent(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
DBusMessage *reply;
const char *path;
if (default_auth_agent)
return error_auth_agent_already_exists(conn, msg);
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_INVALID))
return error_invalid_arguments(conn, msg, NULL);
default_auth_agent = auth_agent_new(conn,
dbus_message_get_sender(msg), path);
if (!default_auth_agent)
goto need_memory;
reply = dbus_message_new_method_return(msg);
if (!reply)
goto need_memory;
name_listener_add(conn, default_auth_agent->name,
(name_cb_t) default_auth_agent_exited, NULL);
info("Default authorization agent (%s, %s) registered",
default_auth_agent->name, default_auth_agent->path);
return send_message_and_unref(conn, reply);
need_memory:
if (default_auth_agent) {
auth_agent_free(default_auth_agent);
default_auth_agent = NULL;
}
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
