X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fagent.c;h=d6113af745fa8237167239ae97c95c59636c65c5;hb=7ef7e96fc2f3eb620fffb6f277339214efe83747;hp=b87f4e8759d0ce0fb02ceb2013fe0ca132a97f61;hpb=69c61e26f144e85f57d270b8d792a1da9751cba6;p=platform%2Fupstream%2Fconnman.git diff --git a/src/agent.c b/src/agent.c old mode 100644 new mode 100755 index b87f4e8..d6113af --- a/src/agent.c +++ b/src/agent.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2010 Intel Corporation. All rights reserved. + * Copyright (C) 2007-2013 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as @@ -28,655 +28,633 @@ #include #include +#include +#include #include "connman.h" +#define agent_ref(agent) \ + agent_ref_debug(agent, __FILE__, __LINE__, __func__) +#define agent_unref(agent) \ + agent_unref_debug(agent, __FILE__, __LINE__, __func__) + static DBusConnection *connection = NULL; -static guint agent_watch = 0; -static gchar *agent_path = NULL; -static gchar *agent_sender = NULL; +static GHashTable *agent_hash = NULL; +static struct connman_agent *default_agent = NULL; + +struct connman_agent { + int refcount; + char *owner; + char *path; + struct connman_agent_request *pending; + GList *queue; /* queued requests for this agent */ + guint watch; +}; + +struct connman_agent_request { + void *user_context; + void *user_data; + DBusMessage *msg; + DBusPendingCall *call; + int timeout; + agent_queue_cb callback; + struct connman_agent_driver *driver; +}; -static void agent_free(void) +static GSList *driver_list = NULL; + +void *connman_agent_get_info(const char *dbus_sender, const char **sender, + const char **path) { - agent_watch = 0; + struct connman_agent *agent; + + if (!dbus_sender) + agent = default_agent; + else { + agent = g_hash_table_lookup(agent_hash, dbus_sender); + if (!agent) + agent = default_agent; + } - g_free(agent_sender); - agent_sender = NULL; + if (agent) { + if (sender) + *sender = agent->owner; + if (path) + *path = agent->path; + } else { + if (sender) + *sender = NULL; + if (path) + *path = NULL; + } - g_free(agent_path); - agent_path = NULL; + return agent; } -static void agent_disconnect(DBusConnection *connection, void *data) +static void agent_request_free(struct connman_agent_request *request) { - DBG("data %p", data); + if (!request) + return; + + if (request->user_context) { + if (request->driver && request->driver->context_unref) + request->driver->context_unref(request->user_context); + } - agent_free(); + if (request->msg) + dbus_message_unref(request->msg); + + if (request->call) { + dbus_pending_call_cancel(request->call); + dbus_pending_call_unref(request->call); + } + + g_free(request); } -int __connman_agent_register(const char *sender, const char *path) +static void agent_finalize_pending(struct connman_agent *agent, + DBusMessage *reply) { - DBG("sender %s path %s", sender, path); + struct connman_agent_request *pending = agent->pending; + if (pending) { + agent->pending = NULL; + pending->callback(reply, pending->user_data); + agent_request_free(pending); + } +} - if (agent_path != NULL) - return -EEXIST; +static void agent_receive_message(DBusPendingCall *call, void *user_data); + +static int agent_send_next_request(struct connman_agent *agent) +{ + if (agent->pending) + return -EBUSY; + + if (!agent->queue) + return 0; + + agent->pending = agent->queue->data; + agent->queue = g_list_remove(agent->queue, agent->pending); + + if (!agent->pending->msg) + goto fail; - agent_sender = g_strdup(sender); - agent_path = g_strdup(path); + if (!dbus_connection_send_with_reply(connection, agent->pending->msg, + &agent->pending->call, + agent->pending->timeout)) + goto fail; - agent_watch = g_dbus_add_disconnect_watch(connection, sender, - agent_disconnect, NULL, NULL); + if (!agent->pending->call) + goto fail; + if (!dbus_pending_call_set_notify(agent->pending->call, + agent_receive_message, + agent, NULL)) + goto fail; + + dbus_message_unref(agent->pending->msg); + agent->pending->msg = NULL; return 0; + +fail: + agent_finalize_pending(agent, NULL); + return -ESRCH; } -int __connman_agent_unregister(const char *sender, const char *path) +static int send_cancel_request(struct connman_agent *agent, + struct connman_agent_request *request) { - DBG("sender %s path %s", sender, path); + DBusMessage *message; + const char *interface = NULL; - if (agent_path == NULL) - return -ESRCH; + if (request && request->driver) + interface = request->driver->interface; - if (agent_watch > 0) - g_dbus_remove_watch(connection, agent_watch); + DBG("send cancel req to %s %s iface %s", agent->owner, agent->path, + interface); - agent_free(); + message = dbus_message_new_method_call(agent->owner, + agent->path, + interface, + "Cancel"); + if (!message) { + connman_error("Couldn't allocate D-Bus message"); + return -ENOMEM; + } + g_dbus_send_message(connection, message); return 0; } -struct request_input_reply { - struct connman_service *service; - authentication_cb_t callback; - void *user_data; -}; - -static void request_input_passphrase_reply(DBusPendingCall *call, void *user_data) +static void agent_receive_message(DBusPendingCall *call, void *user_data) { - struct request_input_reply *passphrase_reply = user_data; - connman_bool_t values_received = FALSE; - connman_bool_t wps = FALSE; - char *identity = NULL; - char *passphrase = NULL; - char *wpspin = NULL; - char *key; - char *name = NULL; - int name_len = 0; - DBusMessageIter iter, dict; - DBusMessage *reply = dbus_pending_call_steal_reply(call); - - if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) - goto done; - - values_received = TRUE; - - dbus_message_iter_init(reply, &iter); - dbus_message_iter_recurse(&iter, &dict); - while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { - DBusMessageIter entry, value; - - dbus_message_iter_recurse(&dict, &entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) - break; - - dbus_message_iter_get_basic(&entry, &key); - - if (g_str_equal(key, "Identity")) { - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) - != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - dbus_message_iter_get_basic(&value, &identity); - - } else if (g_str_equal(key, "Passphrase")) { - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - dbus_message_iter_get_basic(&value, &passphrase); - - } else if (g_str_equal(key, "WPS")) { - wps = TRUE; - - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) - != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - dbus_message_iter_get_basic(&value, &wpspin); - break; - } else if (g_str_equal(key, "Name")) { - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) - != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - dbus_message_iter_get_basic(&value, &name); - name_len = strlen(name); - } else if (g_str_equal(key, "SSID")) { - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) - != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - if (dbus_message_iter_get_arg_type(&value) - != DBUS_TYPE_VARIANT) - break; - if (dbus_message_iter_get_element_type(&value) - != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_get_fixed_array(&value, &name, - &name_len); - } - dbus_message_iter_next(&dict); + struct connman_agent *agent = user_data; + DBusMessage *reply; + int err; + + DBG("agent %p req %p", agent, agent->pending); + + reply = dbus_pending_call_steal_reply(call); + dbus_pending_call_unref(call); + agent->pending->call = NULL; + + if (dbus_message_is_error(reply, + "org.freedesktop.DBus.Error.Timeout") || + dbus_message_is_error(reply, + "org.freedesktop.DBus.Error.TimedOut")) { + send_cancel_request(agent, agent->pending); } -done: - passphrase_reply->callback(passphrase_reply->service, values_received, - name, name_len, - identity, passphrase, - wps, wpspin, - passphrase_reply->user_data); - connman_service_unref(passphrase_reply->service); + agent_finalize_pending(agent, reply); dbus_message_unref(reply); - dbus_pending_call_unref(call); - g_free(passphrase_reply); + + err = agent_send_next_request(agent); + if (err < 0 && err != -EBUSY) + DBG("send next request failed (%s/%d)", strerror(-err), -err); } -static void request_input_append_alternates(DBusMessageIter *iter, - void *user_data) +static struct connman_agent_driver *get_driver(void) { - const char *str = user_data; - char **alternates, **alternative; + return g_slist_nth_data(driver_list, 0); +} - if (str == NULL) - return; +int connman_agent_queue_message(void *user_context, + DBusMessage *msg, int timeout, + agent_queue_cb callback, void *user_data, + void *agent_data) +{ + struct connman_agent_request *queue_data; + struct connman_agent_driver *driver; + struct connman_agent *agent = agent_data; + int err; - alternates = g_strsplit(str, ",", 0); - if (alternates == NULL) - return; + if (!user_context || !callback) + return -EBADMSG; - for (alternative = alternates; *alternative != NULL; alternative++) - dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, - alternative); + queue_data = g_new0(struct connman_agent_request, 1); + if (!queue_data) + return -ENOMEM; - g_strfreev(alternates); -} + driver = get_driver(); + DBG("driver %p", driver); -static void request_input_append_identity(DBusMessageIter *iter, - void *user_data) -{ - char *str = "string"; + if (driver && driver->context_ref) + queue_data->user_context = driver->context_ref(user_context); + else + queue_data->user_context = user_context; + + queue_data->driver = driver; + queue_data->msg = dbus_message_ref(msg); + queue_data->timeout = timeout; + queue_data->callback = callback; + queue_data->user_data = user_data; + agent->queue = g_list_append(agent->queue, queue_data); - connman_dbus_dict_append_basic(iter, "Type", - DBUS_TYPE_STRING, &str); - str = "mandatory"; - connman_dbus_dict_append_basic(iter, "Requirement", - DBUS_TYPE_STRING, &str); + err = agent_send_next_request(agent); + if (err < 0 && err != -EBUSY) + DBG("send next request failed (%s/%d)", strerror(-err), -err); + + return err; } -static void request_input_append_passphrase(DBusMessageIter *iter, - void *user_data) +static void set_default_agent(void) { - struct connman_service *service = user_data; - char *value; - const char *phase2; + struct connman_agent *agent = NULL; + GHashTableIter iter; + gpointer key, value; - switch (__connman_service_get_security(service)) { - case CONNMAN_SERVICE_SECURITY_WEP: - value = "wep"; - break; - case CONNMAN_SERVICE_SECURITY_PSK: - value = "psk"; - break; - case CONNMAN_SERVICE_SECURITY_8021X: - phase2 = __connman_service_get_phase2(service); + if (default_agent) + return; - if (phase2 != NULL && ( - g_str_has_suffix(phase2, "GTC") == TRUE || - g_str_has_suffix(phase2, "OTP") == TRUE)) - value = "response"; - else - value = "passphrase"; + g_hash_table_iter_init(&iter, agent_hash); + if (g_hash_table_iter_next(&iter, &key, &value)) + agent = value; - break; - default: - value = "string"; - break; - } - connman_dbus_dict_append_basic(iter, "Type", - DBUS_TYPE_STRING, &value); - value = "mandatory"; - connman_dbus_dict_append_basic(iter, "Requirement", - DBUS_TYPE_STRING, &value); - - if (__connman_service_wps_enabled(service) == TRUE) { - connman_dbus_dict_append_array(iter, "Alternates", - DBUS_TYPE_STRING, - request_input_append_alternates, - "WPS"); - } + if (agent) + DBG("default agent set to %s %s", agent->owner, agent->path); + else + DBG("default agent cleared"); + + default_agent = agent; } -static void request_input_append_wps(DBusMessageIter *iter, void *user_data) +static void agent_disconnect(DBusConnection *conn, void *user_data) { - const char *str = "wpspin"; + struct connman_agent *agent = user_data; + + DBG("agent %s disconnected", agent->owner); - connman_dbus_dict_append_basic(iter, "Type", - DBUS_TYPE_STRING, &str); - str = "alternate"; - connman_dbus_dict_append_basic(iter, "Requirement", - DBUS_TYPE_STRING, &str); + if (agent->watch > 0) { + g_dbus_remove_watch(conn, agent->watch); + agent->watch = 0; + } + + g_hash_table_remove(agent_hash, agent->owner); } -static void request_input_append_name(DBusMessageIter *iter, void *user_data) +static struct connman_agent *agent_ref_debug(struct connman_agent *agent, + const char *file, int line, const char *caller) { - const char *str = "string"; - - connman_dbus_dict_append_basic(iter, "Type", - DBUS_TYPE_STRING, &str); - str = "mandatory"; - connman_dbus_dict_append_basic(iter, "Requirement", - DBUS_TYPE_STRING, &str); - connman_dbus_dict_append_array(iter, "Alternates", - DBUS_TYPE_STRING, - request_input_append_alternates, - "SSID"); + DBG("%p ref %d by %s:%d:%s()", agent, agent->refcount + 1, + file, line, caller); + + __sync_fetch_and_add(&agent->refcount, 1); + + return agent; } -static void request_input_append_ssid(DBusMessageIter *iter, void *user_data) +static struct connman_agent *agent_create(const char *name, const char *path) { - const char *str = "ssid"; + struct connman_agent *agent; + + agent = g_new0(struct connman_agent, 1); + + agent->owner = g_strdup(name); + agent->path = g_strdup(path); + + agent->watch = g_dbus_add_disconnect_watch(connection, + name, agent_disconnect, + agent, NULL); - connman_dbus_dict_append_basic(iter, "Type", - DBUS_TYPE_STRING, &str); - str = "alternate"; - connman_dbus_dict_append_basic(iter, "Requirement", - DBUS_TYPE_STRING, &str); + return agent_ref(agent); } -static void request_input_append_password(DBusMessageIter *iter, - void *user_data) +int connman_agent_register(const char *sender, const char *path) { - char *str = "passphrase"; + struct connman_agent *agent; + + DBG("sender %s path %s", sender, path); + + agent = g_hash_table_lookup(agent_hash, sender); + if (agent) + return -EEXIST; - connman_dbus_dict_append_basic(iter, "Type", - DBUS_TYPE_STRING, &str); - str = "mandatory"; - connman_dbus_dict_append_basic(iter, "Requirement", - DBUS_TYPE_STRING, &str); + agent = agent_create(sender, path); + if (!agent) + return -EINVAL; + + DBG("agent %s", agent->owner); + + g_hash_table_replace(agent_hash, agent->owner, agent); + + if (!default_agent) + set_default_agent(); + + return 0; } -static void request_input_login_reply(DBusPendingCall *call, void *user_data) +struct report_error_data { + void *user_context; + report_error_cb_t callback; + void *user_data; +}; + +static void report_error_reply(DBusMessage *reply, void *user_data) { - struct request_input_reply *username_password_reply = user_data; - char *username = NULL; - char *password = NULL; - char *key; - DBusMessageIter iter, dict; - DBusMessage *reply = dbus_pending_call_steal_reply(call); - - if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) - goto done; - - dbus_message_iter_init(reply, &iter); - dbus_message_iter_recurse(&iter, &dict); - while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { - DBusMessageIter entry, value; - - dbus_message_iter_recurse(&dict, &entry); - if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) - break; - - dbus_message_iter_get_basic(&entry, &key); - - if (g_str_equal(key, "Username")) { - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) - != DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - dbus_message_iter_get_basic(&value, &username); - - } else if (g_str_equal(key, "Password")) { - dbus_message_iter_next(&entry); - if (dbus_message_iter_get_arg_type(&entry) != - DBUS_TYPE_VARIANT) - break; - dbus_message_iter_recurse(&entry, &value); - dbus_message_iter_get_basic(&value, &password); - } + struct report_error_data *report_error = user_data; + bool retry = false; + const char *dbus_err; + + if (!reply) + goto out; - dbus_message_iter_next(&dict); + if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { + dbus_err = dbus_message_get_error_name(reply); + if (dbus_err && + strcmp(dbus_err, + CONNMAN_AGENT_INTERFACE ".Error.Retry") == 0) + retry = true; } -done: - username_password_reply->callback(username_password_reply->service, - TRUE, NULL, 0, - username, password, - FALSE, NULL, - username_password_reply->user_data); - connman_service_unref(username_password_reply->service); - dbus_message_unref(reply); - g_free(username_password_reply); + report_error->callback(report_error->user_context, retry, + report_error->user_data); +out: + g_free(report_error); } -int __connman_agent_request_passphrase_input(struct connman_service *service, - authentication_cb_t callback, void *user_data) +int connman_agent_report_error_full(void *user_context, const char *path, + const char *method, const char *error, + report_error_cb_t callback, + const char *dbus_sender, void *user_data) { DBusMessage *message; - const char *path; DBusMessageIter iter; - DBusMessageIter dict; - DBusPendingCall *call; - struct request_input_reply *passphrase_reply; + struct report_error_data *report_error; + struct connman_agent *agent; + int err; + + agent = connman_agent_get_info(dbus_sender, NULL, NULL); - if (service == NULL || agent_path == NULL || callback == NULL) + DBG("agent %p sender %s context %p path %s", agent, + dbus_sender, user_context, agent ? agent->path : "-"); + + if (!user_context || !agent || !agent->path || !error || !callback) return -ESRCH; - message = dbus_message_new_method_call(agent_sender, agent_path, - CONNMAN_AGENT_INTERFACE, - "RequestInput"); - if (message == NULL) + message = dbus_message_new_method_call(agent->owner, agent->path, + CONNMAN_AGENT_INTERFACE, method); + if (!message) return -ENOMEM; dbus_message_iter_init_append(message, &iter); - path = __connman_service_get_path(service); dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path); + dbus_message_iter_append_basic(&iter, + DBUS_TYPE_STRING, &error); - connman_dbus_dict_open(&iter, &dict); - - if (__connman_service_is_hidden(service)) { - connman_dbus_dict_append_dict(&dict, "Name", - request_input_append_name, NULL); - connman_dbus_dict_append_dict(&dict, "SSID", - request_input_append_ssid, NULL); - } - - if (__connman_service_get_security(service) == - CONNMAN_SERVICE_SECURITY_8021X) { - connman_dbus_dict_append_dict(&dict, "Identity", - request_input_append_identity, service); - } - - connman_dbus_dict_append_dict(&dict, "Passphrase", - request_input_append_passphrase, service); - - if (__connman_service_wps_enabled(service) == TRUE) { - connman_dbus_dict_append_dict(&dict, "WPS", - request_input_append_wps, NULL); - } - - connman_dbus_dict_close(&iter, &dict); - - passphrase_reply = g_try_new0(struct request_input_reply, 1); - if (passphrase_reply == NULL) { + report_error = g_try_new0(struct report_error_data, 1); + if (!report_error) { dbus_message_unref(message); return -ENOMEM; } - if (dbus_connection_send_with_reply(connection, message, - &call, -1) == FALSE) { - dbus_message_unref(message); - g_free(passphrase_reply); - return -ESRCH; - } + report_error->user_context = user_context; + report_error->callback = callback; + report_error->user_data = user_data; - if (call == NULL) { + err = connman_agent_queue_message(user_context, message, + connman_timeout_input_request(), + report_error_reply, report_error, + agent); + if (err < 0 && err != -EBUSY) { + DBG("error %d sending error request", err); + g_free(report_error); dbus_message_unref(message); - g_free(passphrase_reply); return -ESRCH; } - passphrase_reply->service = connman_service_ref(service); - passphrase_reply->callback = callback; - passphrase_reply->user_data = user_data; - - dbus_pending_call_set_notify(call, request_input_passphrase_reply, - passphrase_reply, NULL); - dbus_message_unref(message); - return -EIO; + return -EINPROGRESS; } -int __connman_agent_request_login_input(struct connman_service *service, - authentication_cb_t callback, void *user_data) +int connman_agent_report_error(void *user_context, const char *path, + const char *error, + report_error_cb_t callback, + const char *dbus_sender, void *user_data) { - DBusMessage *message; - const char *path; - DBusMessageIter iter; - DBusMessageIter dict; - DBusPendingCall *call; - struct request_input_reply *username_password_reply; - - if (service == NULL || agent_path == NULL || callback == NULL) - return -ESRCH; + return connman_agent_report_error_full(user_context, path, + "ReportError", error, callback, dbus_sender, + user_data); +} - message = dbus_message_new_method_call(agent_sender, agent_path, - CONNMAN_AGENT_INTERFACE, - "RequestInput"); - if (message == NULL) - return -ENOMEM; +static gint compare_priority(gconstpointer a, gconstpointer b) +{ + const struct connman_agent_driver *driver1 = a; + const struct connman_agent_driver *driver2 = b; - dbus_message_iter_init_append(message, &iter); + return driver2->priority - driver1->priority; +} - path = __connman_service_get_path(service); - dbus_message_iter_append_basic(&iter, - DBUS_TYPE_OBJECT_PATH, &path); +/** + * connman_agent_driver_register: + * @driver: Agent driver definition + * + * Register a new agent driver + * + * Returns: %0 on success + */ +int connman_agent_driver_register(struct connman_agent_driver *driver) +{ + DBG("Registering driver %p name %s", driver, driver->name); - connman_dbus_dict_open(&iter, &dict); + driver_list = g_slist_insert_sorted(driver_list, driver, + compare_priority); - connman_dbus_dict_append_dict(&dict, "Username", - request_input_append_identity, service); + return 0; +} - connman_dbus_dict_append_dict(&dict, "Password", - request_input_append_password, service); +static void release_driver(void) +{ + connman_agent_driver_unregister(get_driver()); +} - connman_dbus_dict_close(&iter, &dict); +static void cancel_all_requests(struct connman_agent *agent) +{ + GList *list; - username_password_reply = g_try_new0(struct request_input_reply, 1); - if (username_password_reply == NULL) { - dbus_message_unref(message); - return -ENOMEM; - } + DBG("request %p pending %p", agent->pending, agent->queue); - if (dbus_connection_send_with_reply(connection, message, - &call, -1) == FALSE) { - dbus_message_unref(message); - g_free(username_password_reply); - return -ESRCH; - } + if (agent->pending) { + if (agent->pending->call) + send_cancel_request(agent, agent->pending); - if (call == NULL) { - dbus_message_unref(message); - g_free(username_password_reply); - return -ESRCH; + agent_finalize_pending(agent, NULL); } - username_password_reply->service = connman_service_ref(service); - username_password_reply->callback = callback; - username_password_reply->user_data = user_data; + for (list = agent->queue; list; list = list->next) { + struct connman_agent_request *request = list->data; - dbus_pending_call_set_notify(call, request_input_login_reply, - username_password_reply, NULL); + if (!request) + continue; - dbus_message_unref(message); + request->callback(NULL, request->user_data); + agent_request_free(request); + } - return -EIO; + g_list_free(agent->queue); + agent->queue = NULL; } -struct request_browser_reply_data { - struct connman_service *service; - browser_authentication_cb_t callback; - void *user_data; -}; - -static void request_browser_reply(DBusPendingCall *call, void *user_data) +void connman_agent_cancel(void *user_context) { - struct request_browser_reply_data *browser_reply_data = user_data; - DBusMessage *reply = dbus_pending_call_steal_reply(call); - connman_bool_t result = FALSE; + GHashTableIter iter; + gpointer key, value; + int err; - if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) - goto done; + DBG("context %p", user_context); - result = TRUE; + g_hash_table_iter_init(&iter, agent_hash); + while (g_hash_table_iter_next(&iter, &key, &value)) { + GList *list, *next; + struct connman_agent *agent = value; -done: - browser_reply_data->callback(browser_reply_data->service, - result, browser_reply_data->user_data); - connman_service_unref(browser_reply_data->service); - dbus_message_unref(reply); - g_free(browser_reply_data); -} + /* + * Cancel all the pending requests to a given agent and service + */ + list = agent->queue; + while (list) { + struct connman_agent_request *request = list->data; -int __connman_agent_request_browser(struct connman_service *service, - browser_authentication_cb_t callback, - const char *url, void *user_data) -{ - struct request_browser_reply_data *browser_reply_data; - DBusPendingCall *call; - DBusMessage *message; - DBusMessageIter iter; - const char *path; + next = list->next; - if (service == NULL || agent_path == NULL || callback == NULL) - return -ESRCH; + if (request && request->user_context && + request->user_context == + user_context) { + DBG("cancel pending %p", request); - if (url == NULL) - url = ""; + agent->queue = g_list_delete_link(agent->queue, + list); - message = dbus_message_new_method_call(agent_sender, agent_path, - CONNMAN_AGENT_INTERFACE, - "RequestBrowser"); - if (message == NULL) - return -ENOMEM; + request->callback(NULL, request->user_data); - dbus_message_iter_init_append(message, &iter); + agent_request_free(request); + } - path = __connman_service_get_path(service); - dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path); + list = next; + } - dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url); + /* + * If there is a request from client to a given service, + * we need to cancel it. + */ + if (agent->pending && agent->pending->user_context && + agent->pending->user_context == user_context) { + DBG("cancel request %p", agent->pending); - browser_reply_data = g_try_new0(struct request_browser_reply_data, 1); - if (browser_reply_data == NULL) { - dbus_message_unref(message); - return -ENOMEM; - } + if (agent->pending->call) + send_cancel_request(agent, agent->pending); - if (dbus_connection_send_with_reply(connection, message, - &call, -1) == FALSE) { - dbus_message_unref(message); - g_free(browser_reply_data); - return -ESRCH; - } + agent_finalize_pending(agent, NULL); - if (call == NULL) { - dbus_message_unref(message); - g_free(browser_reply_data); - return -ESRCH; + err = agent_send_next_request(agent); + if (err < 0 && err != -EBUSY) + DBG("send next request failed (%s/%d)", + strerror(-err), -err); + } } +} - browser_reply_data->service = connman_service_ref(service); - browser_reply_data->callback = callback; - browser_reply_data->user_data = user_data; +static void agent_unref_debug(struct connman_agent *agent, + const char *file, int line, const char *caller) +{ + DBG("%p ref %d by %s:%d:%s()", agent, agent->refcount - 1, + file, line, caller); - dbus_pending_call_set_notify(call, request_browser_reply, - browser_reply_data, NULL); + if (__sync_fetch_and_sub(&agent->refcount, 1) != 1) + return; - dbus_message_unref(message); + cancel_all_requests(agent); - return -EIO; -} + g_free(agent->owner); + g_free(agent->path); -struct report_error_data { - struct connman_service *service; - report_error_cb_t callback; - void *user_data; -}; + if (agent == default_agent) { + default_agent = NULL; + set_default_agent(); + } + + g_free(agent); +} -static void report_error_reply(DBusPendingCall *call, void *user_data) +static void agent_release(struct connman_agent *agent, const char *interface) { - struct report_error_data *report_error = user_data; - DBusMessage *reply = dbus_pending_call_steal_reply(call); - gboolean retry = FALSE; - const char *dbus_err; + DBusMessage *message; - if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { - dbus_err = dbus_message_get_error_name(reply); - if (dbus_err != NULL && - strcmp(dbus_err, - CONNMAN_AGENT_INTERFACE ".Error.Retry") == 0) - retry = TRUE; + DBG("release agent %s %s", agent->owner, agent->path); + + message = dbus_message_new_method_call(agent->owner, agent->path, + interface, "Release"); + if (!message) { + connman_error("Couldn't allocate D-Bus message"); + return; } - report_error->callback(report_error->service, retry, - report_error->user_data); - connman_service_unref(report_error->service); - g_free(report_error); - dbus_message_unref(reply); + dbus_message_set_no_reply(message, TRUE); + g_dbus_send_message(connection, message); } -int __connman_agent_report_error(struct connman_service *service, - const char *error, - report_error_cb_t callback, void *user_data) +static void release_agents(void) { - DBusMessage *message; - DBusMessageIter iter; - const char *path; - struct report_error_data *report_error; - DBusPendingCall *call; + GHashTableIter iter; + gpointer key, value; - if (service == NULL || agent_path == NULL || error == NULL || - callback == NULL) - return -ESRCH; + g_hash_table_iter_init(&iter, agent_hash); + while (g_hash_table_iter_next(&iter, &key, &value)) + agent_release(value, get_driver()->interface); +} - message = dbus_message_new_method_call(agent_sender, agent_path, - CONNMAN_AGENT_INTERFACE, - "ReportError"); - if (message == NULL) - return -ENOMEM; +/** + * connman_agent_driver_unregister: + * @driver: Agent driver definition + * + * Remove a previously registered agent driver + */ +void connman_agent_driver_unregister(struct connman_agent_driver *driver) +{ + GSList *list; - dbus_message_iter_init_append(message, &iter); + if (!driver) + return; - path = __connman_service_get_path(service); - dbus_message_iter_append_basic(&iter, - DBUS_TYPE_OBJECT_PATH, &path); - dbus_message_iter_append_basic(&iter, - DBUS_TYPE_STRING, &error); + DBG("Unregistering driver %p name %s", driver, driver->name); - report_error = g_try_new0(struct report_error_data, 1); - if (report_error == NULL) { - dbus_message_unref(message); - return -ENOMEM; - } + release_agents(); - if (dbus_connection_send_with_reply(connection, message, - &call, -1) == FALSE) { - dbus_message_unref(message); - g_free(report_error); - return -ESRCH; + for (list = driver_list; list; list = list->next) { + if (driver != list->data) + continue; + + g_hash_table_remove_all(agent_hash); + break; } - if (call == NULL) { - dbus_message_unref(message); - g_free(report_error); - return -ESRCH; + driver_list = g_slist_remove(driver_list, driver); +} + +static void agent_destroy(gpointer data) +{ + struct connman_agent *agent = data; + + DBG("agent %s req %p", agent->owner, agent->pending); + + if (agent->watch > 0) { + g_dbus_remove_watch(connection, agent->watch); + agent->watch = 0; } - report_error->service = connman_service_ref(service); - report_error->callback = callback; - report_error->user_data = user_data; - dbus_pending_call_set_notify(call, report_error_reply, - report_error, NULL); - dbus_message_unref(message); + agent_unref(agent); +} + +int connman_agent_unregister(const char *sender, const char *path) +{ + DBG("sender %s path %s", sender, path); - return -EIO; + if (!g_hash_table_remove(agent_hash, sender)) + return -ESRCH; + + return 0; } int __connman_agent_init(void) @@ -684,37 +662,28 @@ int __connman_agent_init(void) DBG(""); connection = connman_dbus_get_connection(); - if (connection == NULL) - return -1; + if (!connection) + return -EINVAL; + + agent_hash = g_hash_table_new_full(g_str_hash, g_str_equal, + NULL, agent_destroy); + if (!agent_hash) + return -ENOMEM; return 0; } void __connman_agent_cleanup(void) { - DBusMessage *message; - DBG(""); - if (connection == NULL) + if (!connection) return; - if (agent_watch > 0) - g_dbus_remove_watch(connection, agent_watch); - - if (agent_path == NULL) - return; - - message = dbus_message_new_method_call(agent_sender, agent_path, - CONNMAN_AGENT_INTERFACE, "Release"); - if (message == NULL) - return; - - dbus_message_set_no_reply(message, TRUE); - - g_dbus_send_message(connection, message); + g_hash_table_destroy(agent_hash); - agent_free(); + release_driver(); dbus_connection_unref(connection); + connection = NULL; }