User is able to register multiple agents to ConnMan. When
ConnMan needs to ask something from the user, it uses
the nearest agent available.
---
include/agent.h | 9 +-
src/agent-connman.c | 29 ++-
src/agent.c | 461 +++++++++++++++++++++++++++++++---------------
src/connman.h | 3 +-
src/service.c | 16 +-
vpn/plugins/l2tp.c | 18 +-
vpn/plugins/openconnect.c | 17 +-
vpn/plugins/openvpn.c | 3 +-
vpn/plugins/pptp.c | 18 +-
vpn/plugins/vpn.c | 6 +-
vpn/plugins/vpn.h | 3 +-
vpn/plugins/vpnc.c | 3 +-
vpn/vpn-provider.c | 4 +-
vpn/vpn-provider.h | 3 +-
14 files changed, 398 insertions(+), 195 deletions(-)
diff --git a/include/agent.h b/include/agent.h
index 81941dd..fcfc9b2 100644
--- a/include/agent.h
+++ b/include/agent.h
@@ -54,7 +54,8 @@ typedef void (* report_error_cb_t) (void *user_context,
int connman_agent_report_error(void *user_context, const char *path,
const char *error,
- report_error_cb_t callback, void *user_data);
+ report_error_cb_t callback,
+ const char *dbus_sender, void *user_data);
int connman_agent_register(const char *sender, const char *path);
int connman_agent_unregister(const char *sender, const char *path);
@@ -64,9 +65,11 @@ typedef void (*agent_queue_cb)(DBusMessage *reply, void
*user_data);
int connman_agent_queue_message(void *user_context,
DBusMessage *msg, int timeout,
- agent_queue_cb callback, void *user_data);
+ agent_queue_cb callback, void *user_data,
+ void *agent_data);
-void connman_agent_get_info(const char **sender, const char **path);
+void *connman_agent_get_info(const char *dbus_sender, const char **sender,
+ const char **path);
#ifdef __cplusplus
}
diff --git a/src/agent-connman.c b/src/agent-connman.c
index 664a5b3..7f63a3b 100644
--- a/src/agent-connman.c
+++ b/src/agent-connman.c
@@ -403,7 +403,8 @@ done:
}
int __connman_agent_request_passphrase_input(struct connman_service *service,
- authentication_cb_t callback, void *user_data)
+ authentication_cb_t callback,
+ const char *dbus_sender, void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
@@ -411,10 +412,14 @@ int __connman_agent_request_passphrase_input(struct
connman_service *service,
DBusMessageIter dict;
struct request_input_reply *passphrase_reply;
int err;
+ void *agent;
+
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
- connman_agent_get_info(&agent_sender, &agent_path);
+ DBG("agent %p service %p path %s", agent, service, agent_path);
- if (!service || !agent_path || !callback)
+ if (!service || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
@@ -471,7 +476,7 @@ int __connman_agent_request_passphrase_input(struct
connman_service *service,
err = connman_agent_queue_message(service, message,
connman_timeout_input_request(),
request_input_passphrase_reply,
- passphrase_reply);
+ passphrase_reply, agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent message", err);
@@ -494,10 +499,11 @@ int __connman_agent_request_login_input(struct
connman_service *service,
DBusMessageIter dict;
struct request_input_reply *username_password_reply;
int err;
+ void *agent;
- connman_agent_get_info(&agent_sender, &agent_path);
+ agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
- if (!service || !agent_path || !callback)
+ if (!service || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
@@ -534,7 +540,8 @@ int __connman_agent_request_login_input(struct
connman_service *service,
err = connman_agent_queue_message(service, message,
connman_timeout_input_request(),
- request_input_login_reply, username_password_reply);
+ request_input_login_reply, username_password_reply,
+ agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
@@ -581,10 +588,11 @@ int __connman_agent_request_browser(struct
connman_service *service,
DBusMessageIter iter;
const char *path, *agent_sender, *agent_path;
int err;
+ void *agent;
- connman_agent_get_info(&agent_sender, &agent_path);
+ agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
- if (!service || !agent_path || !callback)
+ if (!service || !agent || !agent_path || !callback)
return -ESRCH;
if (!url)
@@ -615,7 +623,8 @@ int __connman_agent_request_browser(struct connman_service
*service,
err = connman_agent_queue_message(service, message,
connman_timeout_browser_launch(),
- request_browser_reply, browser_reply_data);
+ request_browser_reply, browser_reply_data,
+ agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending browser request", err);
diff --git a/src/agent.c b/src/agent.c
index 9031673..25da224 100644
--- a/src/agent.c
+++ b/src/agent.c
@@ -33,10 +33,23 @@
#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 *request;
+ GList *pending; /* pending and queued requests for this agent */
+ guint watch;
+};
struct connman_agent_request {
void *user_context;
@@ -48,119 +61,142 @@ struct connman_agent_request {
struct connman_agent_driver *driver;
};
-static GList *agent_queue = NULL;
-static struct connman_agent_request *agent_request = NULL;
static GSList *driver_list = NULL;
-void connman_agent_get_info(const char **sender, const char **path)
+void *connman_agent_get_info(const char *dbus_sender, const char **sender,
+ const char **path)
{
- *sender = agent_sender;
- *path = agent_path;
+ 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;
+ }
+
+ if (agent) {
+ if (sender)
+ *sender = agent->owner;
+ if (path)
+ *path = agent->path;
+ } else {
+ if (sender)
+ *sender = NULL;
+ if (path)
+ *path = NULL;
+ }
+
+ return agent;
}
-static void agent_data_free(struct connman_agent_request *data)
+static void agent_request_free(struct connman_agent_request *request)
{
- if (!data)
+ if (!request)
return;
- if (data->user_context) {
- if (data->driver && data->driver->context_unref)
- data->driver->context_unref(data->user_context);
+
+ if (request->user_context) {
+ if (request->driver && request->driver->context_unref)
+ request->driver->context_unref(request->user_context);
+ }
+
+ if (request->msg)
+ dbus_message_unref(request->msg);
+
+ if (request->call) {
+ dbus_pending_call_cancel(request->call);
+ dbus_pending_call_unref(request->call);
}
- if (data->msg)
- dbus_message_unref(data->msg);
- if (data->call)
- dbus_pending_call_cancel(data->call);
- g_free(data);
+ g_free(request);
}
static void agent_receive_message(DBusPendingCall *call, void *user_data);
-static int agent_send_next_request(void)
+static int agent_send_next_request(struct connman_agent *agent)
{
- if (agent_request)
+ if (agent->request)
return -EBUSY;
- if (!agent_queue)
+ if (!agent->pending)
return 0;
- agent_request = agent_queue->data;
- agent_queue = g_list_remove(agent_queue, agent_request);
+ agent->request = agent->pending->data;
+ agent->pending = g_list_remove(agent->pending, agent->request);
- if (!dbus_connection_send_with_reply(connection, agent_request->msg,
- &agent_request->call,
- agent_request->timeout))
+ if (!dbus_connection_send_with_reply(connection, agent->request->msg,
+ &agent->request->call,
+ agent->request->timeout))
goto fail;
- if (!agent_request->call)
+ if (!agent->request->call)
goto fail;
- if (!dbus_pending_call_set_notify(agent_request->call,
+ if (!dbus_pending_call_set_notify(agent->request->call,
agent_receive_message,
- agent_request, NULL))
+ agent, NULL))
goto fail;
- dbus_message_unref(agent_request->msg);
- agent_request->msg = NULL;
+ dbus_message_unref(agent->request->msg);
+ agent->request->msg = NULL;
return 0;
fail:
- agent_data_free(agent_request);
- agent_request = NULL;
+ agent->request->callback(agent->request->msg,
+ agent->request->user_data);
+ agent_request_free(agent->request);
+ agent->request = NULL;
return -ESRCH;
}
-static int agent_send_cancel(struct connman_agent_request *agent)
+static int send_cancel_request(struct connman_agent *agent,
+ struct connman_agent_request *request)
{
DBusMessage *message;
- if (!agent_sender || !agent || !agent->driver)
- return 0;
+ DBG("send cancel req to %s %s", agent->owner, agent->path);
- message = dbus_message_new_method_call(agent_sender, agent_path,
- agent->driver->interface, "Cancel");
- if (message) {
- dbus_message_set_no_reply(message, TRUE);
- g_dbus_send_message(connection, message);
- return 0;
+ message = dbus_message_new_method_call(agent->owner,
+ agent->path,
+ request->driver->interface,
+ "Cancel");
+ if (!message) {
+ connman_error("Couldn't allocate D-Bus message");
+ return -ENOMEM;
}
- connman_warn("Failed to send Cancel message to agent");
- return -ESRCH;
+ g_dbus_send_message(connection, message);
+
+ return 0;
}
static void agent_receive_message(DBusPendingCall *call, void *user_data)
{
- struct connman_agent_request *queue_data = user_data;
+ struct connman_agent *agent = user_data;
DBusMessage *reply;
int err;
- DBG("waiting for %p received %p", agent_request, queue_data);
-
- if (agent_request != queue_data) {
- connman_error("Agent callback expected %p got %p",
- agent_request, queue_data);
- return;
- }
+ DBG("agent %p req %p", agent, agent->request);
reply = dbus_pending_call_steal_reply(call);
dbus_pending_call_unref(call);
- queue_data->call = NULL;
+ agent->request->call = NULL;
if (dbus_message_is_error(reply,
"org.freedesktop.DBus.Error.Timeout") ||
dbus_message_is_error(reply,
"org.freedesktop.DBus.Error.TimedOut")) {
- agent_send_cancel(queue_data->user_context);
+ send_cancel_request(agent, agent->request);
}
- queue_data->callback(reply, queue_data->user_data);
+ agent->request->callback(reply, agent->request->user_data);
dbus_message_unref(reply);
- agent_data_free(queue_data);
- agent_request = NULL;
+ agent_request_free(agent->request);
+ agent->request = NULL;
- err = agent_send_next_request();
+ err = agent_send_next_request(agent);
if (err < 0)
DBG("send next request failed (%s/%d)", strerror(-err), -err);
}
@@ -172,10 +208,12 @@ static struct connman_agent_driver *get_driver(void)
int connman_agent_queue_message(void *user_context,
DBusMessage *msg, int timeout,
- agent_queue_cb callback, void *user_data)
+ 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;
if (!user_context || !callback)
@@ -198,103 +236,108 @@ int connman_agent_queue_message(void *user_context,
queue_data->timeout = timeout;
queue_data->callback = callback;
queue_data->user_data = user_data;
- agent_queue = g_list_append(agent_queue, queue_data);
+ agent->pending = g_list_append(agent->pending, queue_data);
- err = agent_send_next_request();
+ err = agent_send_next_request(agent);
if (err < 0)
DBG("send next request failed (%s/%d)", strerror(-err), -err);
return err;
}
-void connman_agent_cancel(void *user_context)
+static void set_default_agent(struct connman_agent *agent)
{
- GList *item, *next;
- struct connman_agent_request *queued_req;
- int err;
+ if (default_agent == agent)
+ return;
- DBG("context %p", user_context);
+ if (agent)
+ DBG("default agent set to %s %s", agent->owner, agent->path);
+ else
+ DBG("default agent cleared");
+
+ default_agent = agent;
+}
- item = agent_queue;
+static struct connman_agent *elect_default_agent(void)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ struct connman_agent *agent = NULL;
- while (item) {
- next = g_list_next(item);
- queued_req = item->data;
+ g_hash_table_iter_init(&iter, agent_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ agent = value;
- if (queued_req->user_context == user_context ||
- !user_context) {
- agent_data_free(queued_req);
- agent_queue = g_list_delete_link(agent_queue, item);
- }
+ if (default_agent != agent)
+ break;
- item = next;
+ agent = NULL;
}
- if (!agent_request)
- return;
+ return agent;
+}
- if (agent_request->user_context != user_context &&
- user_context)
- return;
+static void agent_disconnect(DBusConnection *conn, void *user_data)
+{
+ struct connman_agent *agent = user_data;
- agent_send_cancel(agent_request);
+ DBG("agent %s disconnected", agent->owner);
- agent_data_free(agent_request);
- agent_request = NULL;
+ if (agent->watch > 0) {
+ g_dbus_remove_watch(conn, agent->watch);
+ agent->watch = 0;
+ }
- err = agent_send_next_request();
- if (err < 0)
- DBG("send next request failed (%s/%d)", strerror(-err), -err);
+ g_hash_table_remove(agent_hash, agent->owner);
}
-static void agent_free(void)
+static struct connman_agent *agent_ref_debug(struct connman_agent *agent,
+ const char *file, int line, const char *caller)
{
- if (agent_watch > 0)
- g_dbus_remove_watch(connection, agent_watch);
-
- agent_watch = 0;
-
- g_free(agent_sender);
- agent_sender = NULL;
+ DBG("%p ref %d by %s:%d:%s()", agent, agent->refcount + 1,
+ file, line, caller);
- g_free(agent_path);
- agent_path = NULL;
+ __sync_fetch_and_add(&agent->refcount, 1);
- connman_agent_cancel(NULL);
+ return agent;
}
-static void agent_disconnect(DBusConnection *conn, void *data)
+static struct connman_agent *agent_create(const char *name, const char *path)
{
- DBG("data %p", data);
- agent_free();
-}
+ struct connman_agent *agent;
-int connman_agent_register(const char *sender, const char *path)
-{
- DBG("sender %s path %s", sender, path);
- if (agent_path)
- return -EEXIST;
+ agent = g_new0(struct connman_agent, 1);
- agent_sender = g_strdup(sender);
- agent_path = g_strdup(path);
+ agent->owner = g_strdup(name);
+ agent->path = g_strdup(path);
- agent_watch = g_dbus_add_disconnect_watch(connection, sender,
- agent_disconnect, NULL, NULL);
+ agent->watch = g_dbus_add_disconnect_watch(connection,
+ name, agent_disconnect,
+ agent, NULL);
- return 0;
+ return agent_ref(agent);
}
-int connman_agent_unregister(const char *sender, const char *path)
+int connman_agent_register(const char *sender, const char *path)
{
+ struct connman_agent *agent;
+
DBG("sender %s path %s", sender, path);
- if (!agent_path)
- return -ESRCH;
+ agent = g_hash_table_lookup(agent_hash, sender);
+ if (agent)
+ return -EEXIST;
+
+ agent = agent_create(sender, path);
+ if (!agent)
+ return -EINVAL;
- if (agent_watch > 0)
- g_dbus_remove_watch(connection, agent_watch);
+ DBG("agent %s", agent->owner);
- agent_free();
+ g_hash_table_replace(agent_hash, agent->owner, agent);
+
+ if (!default_agent)
+ set_default_agent(agent);
return 0;
}
@@ -326,18 +369,24 @@ static void report_error_reply(DBusMessage *reply, void
*user_data)
int connman_agent_report_error(void *user_context, const char *path,
const char *error,
- report_error_cb_t callback, void *user_data)
+ report_error_cb_t callback,
+ const char *dbus_sender, void *user_data)
{
DBusMessage *message;
DBusMessageIter iter;
struct report_error_data *report_error;
+ struct connman_agent *agent;
int err;
- if (!user_context || !agent_path || !error ||
- !callback)
+ agent = connman_agent_get_info(dbus_sender, NULL, 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,
+ message = dbus_message_new_method_call(agent->owner, agent->path,
CONNMAN_AGENT_INTERFACE,
"ReportError");
if (!message)
@@ -362,7 +411,8 @@ int connman_agent_report_error(void *user_context, const
char *path,
err = connman_agent_queue_message(user_context, message,
connman_timeout_input_request(),
- report_error_reply, report_error);
+ report_error_reply, report_error,
+ agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending error request", err);
g_free(report_error);
@@ -375,6 +425,23 @@ int connman_agent_report_error(void *user_context, const
char *path,
return -EINPROGRESS;
}
+static void agent_release(struct connman_agent *agent, const char *interface)
+{
+ DBusMessage *message;
+
+ DBG("release agent %s %s", agent->owner, agent->path);
+
+ message = dbus_message_new_method_call(agent->owner, agent->path,
+ interface, "Release");
+ if (message == NULL) {
+ connman_error("Couldn't allocate D-Bus message");
+ return;
+ }
+
+ dbus_message_set_no_reply(message, TRUE);
+ g_dbus_send_message(connection, message);
+}
+
static gint compare_priority(gconstpointer a, gconstpointer b)
{
const struct connman_agent_driver *driver1 = a;
@@ -401,6 +468,94 @@ int connman_agent_driver_register(struct
connman_agent_driver *driver)
return 0;
}
+static void release_driver(void)
+{
+ connman_agent_driver_unregister(get_driver());
+}
+
+static void cancel_all_requests(struct connman_agent *agent)
+{
+ GList *list;
+
+ DBG("request %p pending %p", agent->request, agent->pending);
+
+ if (agent->request) {
+ agent->pending = g_list_prepend(agent->pending,
+ agent->request);
+ agent->request = NULL;
+ }
+
+ for (list = agent->pending; list; list = list->next) {
+ struct connman_agent_request *request = list->data;
+
+ if (!request)
+ continue;
+
+ DBG("canceling %p", request);
+
+ request->callback(request->msg, request->user_data);
+
+ if (request->call)
+ send_cancel_request(agent, request);
+
+ agent_request_free(request);
+ }
+
+ g_list_free(agent->pending);
+ agent->pending = NULL;
+}
+
+void connman_agent_cancel(void *user_context)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ struct connman_agent *agent = NULL;
+ int err;
+
+ DBG("context %p", user_context);
+
+ g_hash_table_iter_init(&iter, agent_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_agent *item = value;
+
+ if (item->request && item->request->user_context &&
+ item->request->user_context == user_context) {
+ agent = item;
+ break;
+ }
+ }
+
+ if (!agent)
+ return;
+
+ cancel_all_requests(agent);
+
+ err = agent_send_next_request(agent);
+ if (err < 0)
+ DBG("send next request failed (%s/%d)", strerror(-err), -err);
+}
+
+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);
+
+ if (__sync_fetch_and_sub(&agent->refcount, 1) != 1)
+ return;
+
+ cancel_all_requests(agent);
+ g_list_free(agent->pending);
+
+ g_free(agent->owner);
+ g_free(agent->path);
+
+ if (agent == default_agent)
+ set_default_agent(elect_default_agent());
+
+ g_free(agent);
+}
+
/**
* connman_agent_driver_unregister:
* @driver: Agent driver definition
@@ -416,42 +571,41 @@ void connman_agent_driver_unregister(struct
connman_agent_driver *driver)
DBG("Unregistering driver %p name %s", driver, driver->name);
- if (!agent_sender && !agent_path)
- goto out;
-
for (list = driver_list; list; list = list->next) {
- DBusMessage *message;
-
if (driver != list->data)
continue;
- DBG("Sending release to %s path %s iface %s", agent_sender,
- agent_path, driver->interface);
+ g_hash_table_remove_all(agent_hash);
+ break;
+ }
- message = dbus_message_new_method_call(agent_sender, agent_path,
- driver->interface, "Release");
- if (message) {
- dbus_message_set_no_reply(message, TRUE);
- g_dbus_send_message(connection, message);
- }
+ driver_list = g_slist_remove(driver_list, driver);
+}
+
+static void agent_destroy(gpointer data)
+{
+ struct connman_agent *agent = data;
- agent_free();
+ DBG("agent %s req %p", agent->owner, agent->request);
- /*
- * ATM agent_free() unsets the agent_sender and agent_path
- * variables so we can unregister only once.
- * This needs proper fix later.
- */
- break;
+ if (agent->watch > 0) {
+ g_dbus_remove_watch(connection, agent->watch);
+ agent->watch = 0;
}
-out:
- driver_list = g_slist_remove(driver_list, driver);
+ agent_release(agent, get_driver()->interface);
+
+ agent_unref(agent);
}
-static void release_all_agents(void)
+int connman_agent_unregister(const char *sender, const char *path)
{
- connman_agent_driver_unregister(get_driver());
+ DBG("sender %s path %s", sender, path);
+
+ if (!g_hash_table_remove(agent_hash, sender))
+ return -ESRCH;
+
+ return 0;
}
int __connman_agent_init(void)
@@ -460,7 +614,12 @@ int __connman_agent_init(void)
connection = connman_dbus_get_connection();
if (!connection)
- return -1;
+ 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;
}
@@ -472,10 +631,10 @@ void __connman_agent_cleanup(void)
if (!connection)
return;
- if (agent_watch > 0)
- g_dbus_remove_watch(connection, agent_watch);
+ set_default_agent(NULL);
+ g_hash_table_destroy(agent_hash);
- release_all_agents();
+ release_driver();
dbus_connection_unref(connection);
connection = NULL;
diff --git a/src/connman.h b/src/connman.h
index 38b59dd..c03c9f4 100644
--- a/src/connman.h
+++ b/src/connman.h
@@ -102,7 +102,8 @@ typedef void (* browser_authentication_cb_t) (struct
connman_service *service,
bool authentication_done,
const char *error, void *user_data);
int __connman_agent_request_passphrase_input(struct connman_service *service,
- authentication_cb_t callback, void *user_data);
+ authentication_cb_t callback,
+ const char *dbus_sender, void *user_data);
int __connman_agent_request_login_input(struct connman_service *service,
authentication_cb_t callback, void *user_data);
int __connman_agent_request_browser(struct connman_service *service,
diff --git a/src/service.c b/src/service.c
index d821d1f..b119479 100644
--- a/src/service.c
+++ b/src/service.c
@@ -5080,6 +5080,14 @@ static void single_connected_tech(struct connman_service
*allowed)
g_slist_free(services);
}
+static const char *get_dbus_sender(struct connman_service *service)
+{
+ if (!service->pending)
+ return NULL;
+
+ return dbus_message_get_sender(service->pending);
+}
+
static int service_indicate_state(struct connman_service *service)
{
enum connman_service_state old_state, new_state;
@@ -5242,7 +5250,9 @@ static int service_indicate_state(struct connman_service
*service)
if (service->userconnect &&
connman_agent_report_error(service, service->path,
error2string(service->error),
- report_error_cb, NULL) == -EINPROGRESS)
+ report_error_cb,
+ get_dbus_sender(service),
+ NULL) == -EINPROGRESS)
return 0;
service_complete(service);
} else
@@ -5821,7 +5831,9 @@ int __connman_service_connect(struct connman_service
*service)
}
err = __connman_agent_request_passphrase_input(service,
- request_input_cb, pending);
+ request_input_cb,
+ get_dbus_sender(service),
+ pending);
if (service->hidden && err != -EINPROGRESS)
service->pending = pending;
diff --git a/vpn/plugins/l2tp.c b/vpn/plugins/l2tp.c
index 02108af..f07055c 100644
--- a/vpn/plugins/l2tp.c
+++ b/vpn/plugins/l2tp.c
@@ -561,7 +561,8 @@ typedef void (* request_cb_t)(struct vpn_provider *provider,
const char *error, void *user_data);
static int request_input(struct vpn_provider *provider,
- request_cb_t callback, void *user_data)
+ request_cb_t callback, const char *dbus_sender,
+ void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
@@ -569,10 +570,11 @@ static int request_input(struct vpn_provider *provider,
DBusMessageIter dict;
struct request_input_reply *l2tp_reply;
int err;
+ void *agent;
- connman_agent_get_info(&agent_sender, &agent_path);
-
- if (!provider || !agent_path || !callback)
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ if (!provider || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
@@ -607,7 +609,7 @@ static int request_input(struct vpn_provider *provider,
err = connman_agent_queue_message(provider, message,
connman_timeout_input_request(),
- request_input_reply, l2tp_reply);
+ request_input_reply, l2tp_reply, agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
@@ -716,7 +718,8 @@ static void request_input_cb(struct vpn_provider *provider,
static int l2tp_connect(struct vpn_provider *provider,
struct connman_task *task, const char *if_name,
- vpn_provider_connect_cb_t cb, void *user_data)
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
{
const char *username, *password;
int err;
@@ -744,7 +747,8 @@ static int l2tp_connect(struct vpn_provider *provider,
data->cb = cb;
data->user_data = user_data;
- err = request_input(provider, request_input_cb, data);
+ err = request_input(provider, request_input_cb, dbus_sender,
+ data);
if (err != -EINPROGRESS) {
free_private_data(data);
goto done;
diff --git a/vpn/plugins/openconnect.c b/vpn/plugins/openconnect.c
index b341ef9..2b732ae 100644
--- a/vpn/plugins/openconnect.c
+++ b/vpn/plugins/openconnect.c
@@ -392,7 +392,8 @@ err:
}
static int request_cookie_input(struct vpn_provider *provider,
- struct oc_private_data *data)
+ struct oc_private_data *data,
+ const char *dbus_sender)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
@@ -400,10 +401,11 @@ static int request_cookie_input(struct vpn_provider
*provider,
DBusMessageIter dict;
const char *str;
int err;
+ void *agent;
- connman_agent_get_info(&agent_sender, &agent_path);
-
- if (!provider || !agent_path)
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ if (!provider || !agent || !agent_path)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
@@ -447,7 +449,7 @@ static int request_cookie_input(struct vpn_provider
*provider,
err = connman_agent_queue_message(provider, message,
connman_timeout_input_request(),
- request_input_cookie_reply, data);
+ request_input_cookie_reply, data, agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
@@ -463,7 +465,8 @@ static int request_cookie_input(struct vpn_provider
*provider,
static int oc_connect(struct vpn_provider *provider,
struct connman_task *task, const char *if_name,
- vpn_provider_connect_cb_t cb, void *user_data)
+ vpn_provider_connect_cb_t cb,
+ const char *dbus_sender, void *user_data)
{
const char *vpnhost, *vpncookie, *servercert;
int err;
@@ -490,7 +493,7 @@ static int oc_connect(struct vpn_provider *provider,
data->cb = cb;
data->user_data = user_data;
- err = request_cookie_input(provider, data);
+ err = request_cookie_input(provider, data, dbus_sender);
if (err != -EINPROGRESS) {
vpn_provider_indicate_error(data->provider,
VPN_PROVIDER_ERROR_LOGIN_FAILED);
diff --git a/vpn/plugins/openvpn.c b/vpn/plugins/openvpn.c
index 941275b..35013c4 100644
--- a/vpn/plugins/openvpn.c
+++ b/vpn/plugins/openvpn.c
@@ -308,7 +308,8 @@ static int task_append_config_data(struct vpn_provider
*provider,
static int ov_connect(struct vpn_provider *provider,
struct connman_task *task, const char *if_name,
- vpn_provider_connect_cb_t cb, void *user_data)
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
{
const char *option;
int err = 0, fd;
diff --git a/vpn/plugins/pptp.c b/vpn/plugins/pptp.c
index 8ae0edc..c8b75c7 100644
--- a/vpn/plugins/pptp.c
+++ b/vpn/plugins/pptp.c
@@ -353,7 +353,8 @@ typedef void (* request_cb_t)(struct vpn_provider *provider,
const char *error, void *user_data);
static int request_input(struct vpn_provider *provider,
- request_cb_t callback, void *user_data)
+ request_cb_t callback, const char *dbus_sender,
+ void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
@@ -361,10 +362,11 @@ static int request_input(struct vpn_provider *provider,
DBusMessageIter dict;
struct request_input_reply *pptp_reply;
int err;
+ void *agent;
- connman_agent_get_info(&agent_sender, &agent_path);
-
- if (!provider || !agent_path || !callback)
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ if (!provider || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
@@ -399,7 +401,7 @@ static int request_input(struct vpn_provider *provider,
err = connman_agent_queue_message(provider, message,
connman_timeout_input_request(),
- request_input_reply, pptp_reply);
+ request_input_reply, pptp_reply, agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
@@ -522,7 +524,8 @@ static void request_input_cb(struct vpn_provider *provider,
static int pptp_connect(struct vpn_provider *provider,
struct connman_task *task, const char *if_name,
- vpn_provider_connect_cb_t cb, void *user_data)
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
{
const char *username, *password;
int err;
@@ -552,7 +555,8 @@ static int pptp_connect(struct vpn_provider *provider,
data->cb = cb;
data->user_data = user_data;
- err = request_input(provider, request_input_cb, data);
+ err = request_input(provider, request_input_cb, dbus_sender,
+ data);
if (err != -EINPROGRESS) {
free_private_data(data);
goto done;
diff --git a/vpn/plugins/vpn.c b/vpn/plugins/vpn.c
index d86d459..2fdb483 100644
--- a/vpn/plugins/vpn.c
+++ b/vpn/plugins/vpn.c
@@ -354,7 +354,8 @@ exist_err:
}
static int vpn_connect(struct vpn_provider *provider,
- vpn_provider_connect_cb_t cb, void *user_data)
+ vpn_provider_connect_cb_t cb,
+ const char *dbus_sender, void *user_data)
{
struct vpn_data *data = vpn_provider_get_data(provider);
struct vpn_driver_data *vpn_driver_data;
@@ -430,7 +431,8 @@ static int vpn_connect(struct vpn_provider *provider,
}
ret = vpn_driver_data->vpn_driver->connect(provider, data->task,
- data->if_name, cb, user_data);
+ data->if_name, cb, dbus_sender,
+ user_data);
if (ret < 0 && ret != -EINPROGRESS) {
stop_vpn(provider);
connman_task_destroy(data->task);
diff --git a/vpn/plugins/vpn.h b/vpn/plugins/vpn.h
index 6f86aac..0dd2470 100644
--- a/vpn/plugins/vpn.h
+++ b/vpn/plugins/vpn.h
@@ -45,7 +45,8 @@ struct vpn_driver {
int (*notify) (DBusMessage *msg, struct vpn_provider *provider);
int (*connect) (struct vpn_provider *provider,
struct connman_task *task, const char *if_name,
- vpn_provider_connect_cb_t cb, void *user_data);
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data);
void (*disconnect) (struct vpn_provider *provider);
int (*error_code) (int exit_code);
int (*save) (struct vpn_provider *provider, GKeyFile *keyfile);
diff --git a/vpn/plugins/vpnc.c b/vpn/plugins/vpnc.c
index d6233f8..4c41efe 100644
--- a/vpn/plugins/vpnc.c
+++ b/vpn/plugins/vpnc.c
@@ -264,7 +264,8 @@ static int vc_save(struct vpn_provider *provider, GKeyFile
*keyfile)
static int vc_connect(struct vpn_provider *provider,
struct connman_task *task, const char *if_name,
- vpn_provider_connect_cb_t cb, void *user_data)
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
{
const char *option;
int err = 0, fd;
diff --git a/vpn/vpn-provider.c b/vpn/vpn-provider.c
index 96ea442..cf75523 100644
--- a/vpn/vpn-provider.c
+++ b/vpn/vpn-provider.c
@@ -1078,7 +1078,9 @@ int __vpn_provider_connect(struct vpn_provider *provider,
DBusMessage *msg)
if (provider->driver && provider->driver->connect) {
dbus_message_ref(msg);
- err = provider->driver->connect(provider, connect_cb, msg);
+ err = provider->driver->connect(provider, connect_cb,
+ dbus_message_get_sender(msg),
+ msg);
} else
return -EOPNOTSUPP;
diff --git a/vpn/vpn-provider.h b/vpn/vpn-provider.h
index e84b734..ead9330 100644
--- a/vpn/vpn-provider.h
+++ b/vpn/vpn-provider.h
@@ -126,7 +126,8 @@ struct vpn_provider_driver {
int (*probe) (struct vpn_provider *provider);
int (*remove) (struct vpn_provider *provider);
int (*connect) (struct vpn_provider *provider,
- vpn_provider_connect_cb_t cb, void *user_data);
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data);
int (*disconnect) (struct vpn_provider *provider);
int (*save) (struct vpn_provider *provider, GKeyFile *keyfile);
};
--
1.7.11.7
_______________________________________________
connman mailing list
[email protected]
https://lists.connman.net/mailman/listinfo/connman
