dbus_bool_t connman_dbus_setting_changed_dict(const char *owner,
const char *path, const char *key,
connman_dbus_append_cb_t function,
void *user_data)
{
DBusMessage *msg;
DBusMessageIter array, dict;
if (!owner || !path)
return FALSE;
msg = dbus_message_new_method_call(owner, path,
CONNMAN_NOTIFICATION_INTERFACE,
"Update");
if (!msg)
return FALSE;
dbus_message_iter_init_append(msg, &array);
connman_dbus_dict_open(&array, &dict);
connman_dbus_dict_append_dict(&dict, key, function, user_data);
connman_dbus_dict_close(&array, &dict);
g_dbus_send_message(connection, msg);
return TRUE;
}
static void append_properties(DBusMessageIter *iter, struct connman_peer *peer)
{
const char *state = state2string(peer->state);
DBusMessageIter dict;
connman_dbus_dict_open(iter, &dict);
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &state);
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &peer->name);
connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4, peer);
connman_dbus_dict_append_array(&dict, "Services",
DBUS_TYPE_DICT_ENTRY,
append_peer_services, peer);
connman_dbus_dict_close(iter, &dict);
}
static void previous_passphrase_handler(DBusMessageIter *iter,
struct connman_service *service)
{
enum connman_service_security security;
struct previous_passphrase_data data;
struct connman_network *network;
network = __connman_service_get_network(service);
data.passphrase = connman_network_get_string(network, "WiFi.PinWPS");
if (connman_network_get_bool(network, "WiFi.UseWPS") &&
data.passphrase) {
data.type = "wpspin";
} else {
data.passphrase = __connman_service_get_passphrase(service);
if (!data.passphrase)
return;
security = __connman_service_get_security(service);
switch (security) {
case CONNMAN_SERVICE_SECURITY_WEP:
data.type = "wep";
break;
case CONNMAN_SERVICE_SECURITY_PSK:
data.type = "psk";
break;
/*
* This should never happen: no passphrase is set if security
* is not one of the above. */
default:
break;
}
}
connman_dbus_dict_append_dict(iter, "PreviousPassphrase",
request_input_append_previouspassphrase, &data);
}
static void append_notify(DBusMessageIter *dict,
struct connman_session *session)
{
struct session_info *info = session->info;
struct session_info *info_last = session->info_last;
struct connman_service *service;
enum connman_service_type type;
const char *name, *bearer;
char *ifname;
int idx;
if (session->append_all || info->state != info_last->state) {
const char *state = state2string(info->state);
connman_dbus_dict_append_basic(dict, "State",
DBUS_TYPE_STRING,
&state);
info_last->state = info->state;
}
if (session->append_all || session->service != session->service_last) {
if (session->service) {
service = session->service;
name = __connman_service_get_name(service);
idx = __connman_service_get_index(service);
ifname = connman_inet_ifname(idx);
if (!ifname)
ifname = g_strdup("");
type = connman_service_get_type(service);
bearer = service2bearer(type);
} else {
service = NULL;
name = "";
ifname = g_strdup("");
bearer = "";
}
connman_dbus_dict_append_basic(dict, "Name",
DBUS_TYPE_STRING,
&name);
connman_dbus_dict_append_dict(dict, "IPv4",
append_ipconfig_ipv4,
service);
connman_dbus_dict_append_dict(dict, "IPv6",
append_ipconfig_ipv6,
service);
connman_dbus_dict_append_basic(dict, "Interface",
DBUS_TYPE_STRING,
&ifname);
connman_dbus_dict_append_basic(dict, "Bearer",
DBUS_TYPE_STRING,
&bearer);
g_free(ifname);
session->service_last = session->service;
}
if (session->append_all ||
info->config.type != info_last->config.type) {
const char *type = type2string(info->config.type);
connman_dbus_dict_append_basic(dict, "ConnectionType",
DBUS_TYPE_STRING,
&type);
info_last->config.type = info->config.type;
}
if (session->append_all ||
info->config.allowed_bearers != info_last->config.allowed_bearers) {
connman_dbus_dict_append_array(dict, "AllowedBearers",
DBUS_TYPE_STRING,
append_allowed_bearers,
info);
info_last->config.allowed_bearers = info->config.allowed_bearers;
}
session->append_all = false;
}
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 void append_notify(DBusMessageIter *dict,
struct connman_session *session)
{
struct session_info *info = session->info;
struct session_info *info_last = session->info_last;
struct connman_service *service;
const char *name, *ifname, *bearer;
if (session->append_all == TRUE ||
info->state != info_last->state) {
const char *state = state2string(info->state);
connman_dbus_dict_append_basic(dict, "State",
DBUS_TYPE_STRING,
&state);
info_last->state = info->state;
}
if (session->append_all == TRUE ||
info->entry != info_last->entry) {
if (info->entry == NULL) {
name = "";
ifname = "";
service = NULL;
bearer = "";
} else {
name = info->entry->name;
ifname = info->entry->ifname;
service = info->entry->service;
bearer = info->entry->bearer;
}
connman_dbus_dict_append_basic(dict, "Name",
DBUS_TYPE_STRING,
&name);
connman_dbus_dict_append_dict(dict, "IPv4",
append_ipconfig_ipv4,
service);
connman_dbus_dict_append_dict(dict, "IPv6",
append_ipconfig_ipv6,
service);
connman_dbus_dict_append_basic(dict, "Interface",
DBUS_TYPE_STRING,
&ifname);
connman_dbus_dict_append_basic(dict, "Bearer",
DBUS_TYPE_STRING,
&bearer);
info_last->entry = info->entry;
}
if (session->append_all == TRUE ||
info->config.type != info_last->config.type) {
const char *type = type2string(info->config.type);
connman_dbus_dict_append_basic(dict, "ConnectionType",
DBUS_TYPE_STRING,
&type);
info_last->config.type = info->config.type;
}
if (session->append_all == TRUE ||
info->config.allowed_bearers != info_last->config.allowed_bearers) {
connman_dbus_dict_append_array(dict, "AllowedBearers",
DBUS_TYPE_STRING,
append_allowed_bearers,
info);
info_last->config.allowed_bearers = info->config.allowed_bearers;
}
session->append_all = FALSE;
}
int __connman_agent_request_input(struct connman_service *service,
authentication_cb_t callback, void *user_data)
{
DBusMessage *message;
const char *path;
DBusMessageIter iter;
DBusMessageIter dict;
DBusPendingCall *call;
struct request_input_reply *passphrase_reply;
if (service == NULL || agent_path == NULL || callback == NULL)
return -ESRCH;
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE,
"RequestInput");
if (message == NULL)
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_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) {
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;
}
if (call == NULL) {
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;
}
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;
}
