static int request_input(struct vpn_provider *provider,
request_cb_t callback, void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
DBusMessageIter iter;
DBusMessageIter dict;
struct request_input_reply *pptp_reply;
int err;
connman_agent_get_info(&agent_sender, &agent_path);
if (provider == NULL || agent_path == NULL || callback == NULL)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
VPN_AGENT_INTERFACE,
"RequestInput");
if (message == NULL)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
path = vpn_provider_get_path(provider);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_OBJECT_PATH, &path);
connman_dbus_dict_open(&iter, &dict);
vpn_agent_append_user_info(&dict, provider, "PPTP.User");
vpn_agent_append_host_and_name(&dict, provider);
connman_dbus_dict_close(&iter, &dict);
pptp_reply = g_try_new0(struct request_input_reply, 1);
if (pptp_reply == NULL) {
dbus_message_unref(message);
return -ENOMEM;
}
pptp_reply->provider = provider;
pptp_reply->callback = callback;
pptp_reply->user_data = user_data;
err = connman_agent_queue_message(provider, message,
connman_timeout_input_request(),
request_input_reply, pptp_reply);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
g_free(pptp_reply);
return err;
}
dbus_message_unref(message);
return -EINPROGRESS;
}
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;
DBusMessage *message;
DBusMessageIter iter;
const char *path, *agent_sender, *agent_path;
int err;
void *agent;
agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
if (!service || !agent || !agent_path || !callback)
return -ESRCH;
if (!url)
url = "";
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE,
"RequestBrowser");
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, &url);
browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
if (!browser_reply_data) {
dbus_message_unref(message);
return -ENOMEM;
}
browser_reply_data->service = service;
browser_reply_data->callback = callback;
browser_reply_data->user_data = user_data;
err = connman_agent_queue_message(service, message,
connman_timeout_browser_launch(),
request_browser_reply, browser_reply_data,
agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending browser request", err);
dbus_message_unref(message);
g_free(browser_reply_data);
return err;
}
dbus_message_unref(message);
return -EINPROGRESS;
}
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;
DBusMessageIter iter;
struct report_error_data *report_error;
struct connman_agent *agent;
int err;
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->owner, agent->path,
CONNMAN_AGENT_INTERFACE, method);
if (!message)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_OBJECT_PATH, &path);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING, &error);
report_error = g_try_new0(struct report_error_data, 1);
if (!report_error) {
dbus_message_unref(message);
return -ENOMEM;
}
report_error->user_context = user_context;
report_error->callback = callback;
report_error->user_data = user_data;
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);
return -ESRCH;
}
dbus_message_unref(message);
return -EINPROGRESS;
}
int __connman_agent_request_login_input(struct connman_service *service,
authentication_cb_t callback, void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
DBusMessageIter iter;
DBusMessageIter dict;
struct request_input_reply *username_password_reply;
int err;
void *agent;
agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
if (!service || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE,
"RequestInput");
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);
connman_dbus_dict_open(&iter, &dict);
connman_dbus_dict_append_dict(&dict, "Username",
request_input_append_identity, service);
connman_dbus_dict_append_dict(&dict, "Password",
request_input_append_password, service);
connman_dbus_dict_close(&iter, &dict);
username_password_reply = g_try_new0(struct request_input_reply, 1);
if (!username_password_reply) {
dbus_message_unref(message);
return -ENOMEM;
}
username_password_reply->service = service;
username_password_reply->callback = callback;
username_password_reply->user_data = user_data;
err = connman_agent_queue_message(service, message,
connman_timeout_input_request(),
request_input_login_reply, username_password_reply,
agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
g_free(username_password_reply);
return err;
}
dbus_message_unref(message);
return -EINPROGRESS;
}
int __connman_agent_request_passphrase_input(struct connman_service *service,
authentication_cb_t callback,
const char *dbus_sender, void *user_data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
DBusMessageIter iter;
DBusMessageIter dict;
struct request_input_reply *passphrase_reply;
int err;
void *agent;
agent = connman_agent_get_info(dbus_sender, &agent_sender,
&agent_path);
DBG("agent %p service %p path %s", agent, service, agent_path);
if (!service || !agent || !agent_path || !callback)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE,
"RequestInput");
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);
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);
}
if (__connman_service_get_security(service) !=
CONNMAN_SERVICE_SECURITY_NONE) {
connman_dbus_dict_append_dict(&dict, "Passphrase",
request_input_append_passphrase, service);
previous_passphrase_handler(&dict, service);
}
if (__connman_service_wps_enabled(service))
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) {
dbus_message_unref(message);
return -ENOMEM;
}
passphrase_reply->service = service;
passphrase_reply->callback = callback;
passphrase_reply->user_data = user_data;
err = connman_agent_queue_message(service, message,
connman_timeout_input_request(),
request_input_passphrase_reply,
passphrase_reply, agent);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent message", err);
dbus_message_unref(message);
g_free(passphrase_reply);
return err;
}
dbus_message_unref(message);
return -EINPROGRESS;
}
static int request_cookie_input(struct vpn_provider *provider,
struct oc_private_data *data)
{
DBusMessage *message;
const char *path, *agent_sender, *agent_path;
DBusMessageIter iter;
DBusMessageIter dict;
const char *str;
int err;
connman_agent_get_info(&agent_sender, &agent_path);
if (provider == NULL || agent_path == NULL)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
VPN_AGENT_INTERFACE,
"RequestInput");
if (message == NULL)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
path = vpn_provider_get_path(provider);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_OBJECT_PATH, &path);
connman_dbus_dict_open(&iter, &dict);
str = vpn_provider_get_string(provider, "OpenConnect.CACert");
if (str != NULL)
connman_dbus_dict_append_dict(&dict, "OpenConnect.CACert",
request_input_append_informational,
(void *)str);
str = vpn_provider_get_string(provider, "OpenConnect.ClientCert");
if (str != NULL)
connman_dbus_dict_append_dict(&dict, "OpenConnect.ClientCert",
request_input_append_informational,
(void *)str);
connman_dbus_dict_append_dict(&dict, "OpenConnect.ServerCert",
request_input_append_mandatory, NULL);
connman_dbus_dict_append_dict(&dict, "OpenConnect.VPNHost",
request_input_append_mandatory, NULL);
connman_dbus_dict_append_dict(&dict, "OpenConnect.Cookie",
request_input_append_mandatory, NULL);
vpn_agent_append_host_and_name(&dict, provider);
connman_dbus_dict_close(&iter, &dict);
err = connman_agent_queue_message(provider, message,
connman_timeout_input_request(),
request_input_cookie_reply, data);
if (err < 0 && err != -EBUSY) {
DBG("error %d sending agent request", err);
dbus_message_unref(message);
return err;
}
dbus_message_unref(message);
return -EINPROGRESS;
}