static void append_route(DBusMessageIter *iter, void *user_data)
{
struct vpn_route *route = user_data;
DBusMessageIter item;
int family = 0;
connman_dbus_dict_open(iter, &item);
if (route == NULL)
goto empty_dict;
if (route->family == AF_INET)
family = 4;
else if (route->family == AF_INET6)
family = 6;
if (family != 0)
connman_dbus_dict_append_basic(&item, "ProtocolFamily",
DBUS_TYPE_INT32, &family);
if (route->network != NULL)
connman_dbus_dict_append_basic(&item, "Network",
DBUS_TYPE_STRING, &route->network);
if (route->netmask != NULL)
connman_dbus_dict_append_basic(&item, "Netmask",
DBUS_TYPE_STRING, &route->netmask);
if (route->gateway != NULL)
connman_dbus_dict_append_basic(&item, "Gateway",
DBUS_TYPE_STRING, &route->gateway);
empty_dict:
connman_dbus_dict_close(iter, &item);
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
DBusMessageIter array, dict;
dbus_bool_t offlinemode;
const char *str;
DBG("conn %p", conn);
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &array);
connman_dbus_dict_open(&array, &dict);
str = __connman_notifier_get_state();
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &str);
offlinemode = __connman_technology_get_offlinemode();
connman_dbus_dict_append_basic(&dict, "OfflineMode",
DBUS_TYPE_BOOLEAN, &offlinemode);
connman_dbus_dict_append_basic(&dict, "SessionMode",
DBUS_TYPE_BOOLEAN,
&sessionmode);
connman_dbus_dict_close(&array, &dict);
return reply;
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
DBusMessageIter array, dict;
connman_bool_t offlinemode, sessionmode;
const char *str;
DBG("conn %p", conn);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &array);
connman_dbus_dict_open(&array, &dict);
connman_dbus_dict_append_array(&dict, "Services",
DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL);
connman_dbus_dict_append_array(&dict, "Technologies",
DBUS_TYPE_OBJECT_PATH, __connman_technology_list, NULL);
str = __connman_notifier_get_state();
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &str);
offlinemode = __connman_technology_get_offlinemode();
connman_dbus_dict_append_basic(&dict, "OfflineMode",
DBUS_TYPE_BOOLEAN, &offlinemode);
connman_dbus_dict_append_array(&dict, "AvailableTechnologies",
DBUS_TYPE_STRING, __connman_notifier_list_registered, NULL);
connman_dbus_dict_append_array(&dict, "EnabledTechnologies",
DBUS_TYPE_STRING, __connman_notifier_list_enabled, NULL);
connman_dbus_dict_append_array(&dict, "ConnectedTechnologies",
DBUS_TYPE_STRING, __connman_notifier_list_connected, NULL);
str = __connman_service_default();
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "DefaultTechnology",
DBUS_TYPE_STRING, &str);
connman_dbus_dict_append_array(&dict, "AvailableDebugs",
DBUS_TYPE_STRING, __connman_debug_list_available, NULL);
connman_dbus_dict_append_array(&dict, "EnabledDebugs",
DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL);
sessionmode = __connman_session_mode();
connman_dbus_dict_append_basic(&dict, "SessionMode",
DBUS_TYPE_BOOLEAN,
&sessionmode);
connman_dbus_dict_close(&array, &dict);
return reply;
}
static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
{
const char *str = "ssid";
connman_dbus_dict_append_basic(iter, "Type",
DBUS_TYPE_STRING, &str);
str = "alternate";
connman_dbus_dict_append_basic(iter, "Requirement",
DBUS_TYPE_STRING, &str);
}
static void request_input_append_identity(DBusMessageIter *iter,
void *user_data)
{
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);
}
static void request_input_append_password(DBusMessageIter *iter,
void *user_data)
{
char *str = "passphrase";
connman_dbus_dict_append_basic(iter, "Type",
DBUS_TYPE_STRING, &str);
str = "mandatory";
connman_dbus_dict_append_basic(iter, "Requirement",
DBUS_TYPE_STRING, &str);
}
static void request_input_append_name(DBusMessageIter *iter, void *user_data)
{
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");
}
static void request_input_append_previouspassphrase(DBusMessageIter *iter,
void *user_data)
{
struct previous_passphrase_data *data = user_data;
const char *requirement = "informational";
connman_dbus_dict_append_basic(iter, "Type",
DBUS_TYPE_STRING, &data->type);
connman_dbus_dict_append_basic(iter, "Requirement",
DBUS_TYPE_STRING, &requirement);
connman_dbus_dict_append_basic(iter, "Value",
DBUS_TYPE_STRING, &data->passphrase);
}
static void request_input_append_informational(DBusMessageIter *iter,
void *user_data)
{
const char *str;
str = "string";
connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str);
str = "informational";
connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING,
&str);
str = user_data;
connman_dbus_dict_append_basic(iter, "Value", DBUS_TYPE_STRING, &str);
}
void __connman_provider_append_properties(struct connman_provider *provider,
DBusMessageIter *iter)
{
if (provider->host != NULL)
connman_dbus_dict_append_basic(iter, "Host",
DBUS_TYPE_STRING, &provider->host);
if (provider->domain != NULL)
connman_dbus_dict_append_basic(iter, "Domain",
DBUS_TYPE_STRING, &provider->domain);
if (provider->type != NULL)
connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
&provider->type);
}
dbus_bool_t connman_dbus_setting_changed_basic(const char *owner,
const char *path, const char *key,
int type, void *val)
{
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_basic(&dict, key, type, val);
connman_dbus_dict_close(&array, &dict);
g_dbus_send_message(connection, msg);
return TRUE;
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
DBusMessageIter array, dict;
struct timeval tv;
const char *str;
DBG("conn %p", conn);
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &array);
connman_dbus_dict_open(&array, &dict);
if (gettimeofday(&tv, NULL) == 0) {
dbus_uint64_t val = tv.tv_sec;
connman_dbus_dict_append_basic(&dict, "Time",
DBUS_TYPE_UINT64, &val);
}
str = time_updates2string(time_updates_config);
if (str)
connman_dbus_dict_append_basic(&dict, "TimeUpdates",
DBUS_TYPE_STRING, &str);
if (timezone_config)
connman_dbus_dict_append_basic(&dict, "Timezone",
DBUS_TYPE_STRING, &timezone_config);
str = timezone_updates2string(timezone_updates_config);
if (str)
connman_dbus_dict_append_basic(&dict, "TimezoneUpdates",
DBUS_TYPE_STRING, &str);
connman_dbus_dict_append_array(&dict, "Timeservers",
DBUS_TYPE_STRING, append_timeservers, NULL);
connman_dbus_dict_close(&array, &dict);
return reply;
}
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 request_input_append_passphrase(DBusMessageIter *iter,
void *user_data)
{
struct connman_service *service = user_data;
char *value;
const char *phase2;
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 (phase2 && (
g_str_has_suffix(phase2, "GTC") ||
g_str_has_suffix(phase2, "OTP")))
value = "response";
else
value = "passphrase";
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)) {
connman_dbus_dict_append_array(iter, "Alternates",
DBUS_TYPE_STRING,
request_input_append_alternates,
"WPS");
}
}
static void append_dhcp_server_ipv4(DBusMessageIter *iter, void *user_data)
{
struct connman_peer *peer = user_data;
const char *str = "dhcp";
const char *gateway;
const char *subnet;
if (!peer->ip_pool)
return;
gateway = __connman_ippool_get_gateway(peer->ip_pool);
subnet = __connman_ippool_get_subnet_mask(peer->ip_pool);
connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str);
connman_dbus_dict_append_basic(iter, "Address",
DBUS_TYPE_STRING, &gateway);
connman_dbus_dict_append_basic(iter, "Netmask",
DBUS_TYPE_STRING, &subnet);
connman_dbus_dict_append_basic(iter, "Gateway",
DBUS_TYPE_STRING, &gateway);
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *message, void *user_data)
{
struct connman_technology *technology = user_data;
DBusMessage *reply;
DBusMessageIter array, dict;
const char *str;
reply = dbus_message_new_method_return(message);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &array);
connman_dbus_dict_open(&array, &dict);
str = state2string(technology->state);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &str);
str = get_name(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &str);
str = __connman_service_type2string(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Type",
DBUS_TYPE_STRING, &str);
connman_dbus_dict_append_basic(&dict, "Tethering",
DBUS_TYPE_BOOLEAN,
&technology->tethering);
if (technology->tethering_ident != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
if (technology->tethering_passphrase != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
connman_dbus_dict_close(&array, &dict);
return reply;
}
static void append_properties(DBusMessageIter *iter,
struct connman_technology *technology)
{
DBusMessageIter dict;
const char *str;
connman_dbus_dict_open(iter, &dict);
str = get_name(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &str);
str = __connman_service_type2string(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Type",
DBUS_TYPE_STRING, &str);
__sync_synchronize();
connman_dbus_dict_append_basic(&dict, "Powered",
DBUS_TYPE_BOOLEAN,
&technology->enabled);
connman_dbus_dict_append_basic(&dict, "Connected",
DBUS_TYPE_BOOLEAN,
&technology->connected);
connman_dbus_dict_append_basic(&dict, "Tethering",
DBUS_TYPE_BOOLEAN,
&technology->tethering);
if (technology->tethering_ident != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
if (technology->tethering_passphrase != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
connman_dbus_dict_close(iter, &dict);
}
void session_append_settings(DBusMessageIter *dict,
struct test_session_info *info)
{
const char *policy;
connman_dbus_dict_append_basic(dict, "Priority",
DBUS_TYPE_BOOLEAN,
&info->priority);
connman_dbus_dict_append_array(dict, "AllowedBearers",
DBUS_TYPE_STRING,
append_allowed_bearers,
info);
connman_dbus_dict_append_basic(dict, "AvoidHandover",
DBUS_TYPE_BOOLEAN,
&info->avoid_handover);
connman_dbus_dict_append_basic(dict, "StayConnected",
DBUS_TYPE_BOOLEAN,
&info->stay_connected);
connman_dbus_dict_append_basic(dict, "PeriodicConnect",
DBUS_TYPE_UINT32,
&info->periodic_connect);
connman_dbus_dict_append_basic(dict, "IdleTimeout",
DBUS_TYPE_UINT32,
&info->idle_timeout);
connman_dbus_dict_append_basic(dict, "EmergencyCall",
DBUS_TYPE_BOOLEAN,
&info->ecall);
policy = roamingpolicy2string(info->roaming_policy);
connman_dbus_dict_append_basic(dict, "RoamingPolicy",
DBUS_TYPE_STRING,
&policy);
}
static void create_proxy_configuration(void)
{
DBusMessage *msg;
DBusMessageIter iter, dict;
DBusPendingCall *call;
dbus_bool_t result;
char *interface;
const char *method;
const char *str;
char **str_list;
if (default_service == NULL)
return;
DBG("");
msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH,
PACRUNNER_INTERFACE, "CreateProxyConfiguration");
if (msg == NULL)
return;
dbus_message_set_auto_start(msg, FALSE);
dbus_message_iter_init_append(msg, &iter);
connman_dbus_dict_open(&iter, &dict);
switch(connman_service_get_proxy_method(default_service)) {
case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
goto done;
case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
method= "direct";
break;
case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
method = "manual";
str_list = connman_service_get_proxy_servers(default_service);
if (str_list == NULL)
goto done;
connman_dbus_dict_append_array(&dict, "Servers",
DBUS_TYPE_STRING, append_string_list,
str_list);
g_strfreev(str_list);
str_list = connman_service_get_proxy_excludes(default_service);
if (str_list == NULL)
break;
connman_dbus_dict_append_array(&dict, "Excludes",
DBUS_TYPE_STRING, append_string_list,
str_list);
g_strfreev(str_list);
break;
case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
method = "auto";
str = connman_service_get_proxy_url(default_service);
if (str == NULL) {
str = connman_service_get_proxy_autoconfig(
default_service);
if (str == NULL)
goto done;
}
connman_dbus_dict_append_basic(&dict, "URL",
DBUS_TYPE_STRING, &str);
break;
}
connman_dbus_dict_append_basic(&dict, "Method",
DBUS_TYPE_STRING, &method);
interface = connman_service_get_interface(default_service);
if (interface != NULL) {
connman_dbus_dict_append_basic(&dict, "Interface",
DBUS_TYPE_STRING, &interface);
g_free(interface);
}
str = connman_service_get_domainname(default_service);
if (str != NULL)
connman_dbus_dict_append_array(&dict, "Domains",
DBUS_TYPE_STRING, append_string, &str);
str_list = connman_service_get_nameservers(default_service);
if (str_list != NULL)
connman_dbus_dict_append_array(&dict, "Nameservers",
DBUS_TYPE_STRING, append_string_list,
str_list);
connman_dbus_dict_close(&iter, &dict);
result = dbus_connection_send_with_reply(connection, msg,
&call, DBUS_TIMEOUT);
if (result == FALSE || call == NULL)
goto done;
dbus_pending_call_set_notify(call, create_config_reply, NULL, NULL);
dbus_pending_call_unref(call);
done:
dbus_message_unref(msg);
}
static void setup_tun_interface(unsigned int flags, unsigned change,
void *data)
{
struct connman_private_network *pn = data;
unsigned char prefixlen;
DBusMessageIter array, dict;
int err;
DBG("index %d flags %d change %d", pn->index, flags, change);
if (flags & IFF_UP)
return;
prefixlen =
__connman_ipconfig_netmask_prefix_len(PRIVATE_NETWORK_NETMASK);
if ((__connman_inet_modify_address(RTM_NEWADDR,
NLM_F_REPLACE | NLM_F_ACK, pn->index, AF_INET,
pn->server_ip, pn->peer_ip,
prefixlen, NULL)) < 0) {
DBG("address setting failed");
return;
}
connman_inet_ifup(pn->index);
err = enable_nat(default_interface);
if (err < 0) {
connman_error("failed to enable NAT on %s", default_interface);
goto error;
}
dbus_message_iter_init_append(pn->reply, &array);
dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
&pn->path);
connman_dbus_dict_open(&array, &dict);
connman_dbus_dict_append_basic(&dict, "ServerIPv4",
DBUS_TYPE_STRING, &pn->server_ip);
connman_dbus_dict_append_basic(&dict, "PeerIPv4",
DBUS_TYPE_STRING, &pn->peer_ip);
connman_dbus_dict_append_basic(&dict, "PrimaryDNS",
DBUS_TYPE_STRING, &pn->primary_dns);
connman_dbus_dict_append_basic(&dict, "SecondaryDNS",
DBUS_TYPE_STRING, &pn->secondary_dns);
connman_dbus_dict_close(&array, &dict);
dbus_message_iter_append_basic(&array, DBUS_TYPE_UNIX_FD, &pn->fd);
g_dbus_send_message(connection, pn->reply);
return;
error:
pn->reply = __connman_error_failed(pn->msg, -err);
g_dbus_send_message(connection, pn->reply);
g_hash_table_remove(pn_hash, pn->path);
}
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;
}
static int create_configuration(DBusMessage *msg, connection_ready_cb callback)
{
DBusMessage *new_msg = NULL;
DBusPendingCall *call;
DBusMessageIter iter, array, new_iter, new_dict;
const char *type = NULL, *name = NULL;
const char *host = NULL, *domain = NULL;
char *ident, *me = NULL;
int err = 0;
dbus_bool_t result;
struct connection_data *data;
struct config_create_data *user_data = NULL;
GSList *networks = NULL;
/*
* We copy the old message data into new message. We cannot
* just use the old message as is because the user route
* information is not in the same format in vpnd.
*/
new_msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
dbus_message_iter_init_append(new_msg, &new_iter);
connman_dbus_dict_open(&new_iter, &new_dict);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array);
while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
void *item_value;
const char *key;
int value_type;
dbus_message_iter_recurse(&array, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &value);
value_type = dbus_message_iter_get_arg_type(&value);
item_value = NULL;
switch (value_type) {
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic(&value, &item_value);
if (g_str_equal(key, "Type") == TRUE) {
type = (const char *)item_value;
} else if (g_str_equal(key, "Name") == TRUE) {
name = (const char *)item_value;
} else if (g_str_equal(key, "Host") == TRUE) {
host = (const char *)item_value;
} else if (g_str_equal(key, "VPN.Domain") == TRUE) {
domain = (const char *)item_value;
}
DBG("%s %s", key, (char *)item_value);
if (item_value != NULL)
connman_dbus_dict_append_basic(&new_dict, key,
value_type, &item_value);
break;
case DBUS_TYPE_ARRAY:
if (g_str_equal(key, "Networks") == TRUE) {
networks = get_user_networks(&value);
connman_dbus_dict_append_array(&new_dict,
"UserRoutes",
DBUS_TYPE_DICT_ENTRY,
append_routes,
networks);
}
break;
}
dbus_message_iter_next(&array);
}
connman_dbus_dict_close(&new_iter, &new_dict);
DBG("VPN type %s name %s host %s domain %s networks %p",
type, name, host, domain, networks);
if (host == NULL || domain == NULL) {
err = -EINVAL;
goto done;
}
if (type == NULL || name == NULL) {
err = -EOPNOTSUPP;
goto done;
}
ident = g_strdup_printf("%s_%s", host, domain);
set_dbus_ident(ident);
DBG("ident %s", ident);
data = g_hash_table_lookup(vpn_connections, ident);
if (data != NULL) {
if (data->call != NULL || data->cb_data != NULL) {
DBG("create configuration call already pending");
err = -EINPROGRESS;
goto done;
}
} else {
char *path = g_strdup_printf("%s/connection/%s", VPN_PATH,
ident);
data = create_connection_data(path);
g_free(path);
if (data == NULL) {
err = -ENOMEM;
goto done;
}
g_hash_table_insert(vpn_connections, g_strdup(ident), data);
}
/*
* User called net.connman.Manager.ConnectProvider if we are here.
* So use the data from original message in the new msg.
*/
me = g_strdup(dbus_message_get_destination(msg));
dbus_message_set_interface(new_msg, VPN_MANAGER_INTERFACE);
dbus_message_set_path(new_msg, "/");
dbus_message_set_destination(new_msg, VPN_SERVICE);
dbus_message_set_sender(new_msg, me);
dbus_message_set_member(new_msg, "Create");
user_data = g_try_new0(struct config_create_data, 1);
if (user_data == NULL) {
err = -ENOMEM;
goto done;
}
user_data->callback = callback;
user_data->message = dbus_message_ref(msg);
user_data->path = NULL;
DBG("cb %p msg %p", user_data, msg);
result = dbus_connection_send_with_reply(connection, new_msg,
&call, DBUS_TIMEOUT);
if (result == FALSE || call == NULL) {
err = -EIO;
goto done;
}
dbus_pending_call_set_notify(call, configuration_create_reply,
user_data, NULL);
data->call = call;
done:
if (new_msg != NULL)
dbus_message_unref(new_msg);
if (networks != NULL)
g_slist_free_full(networks, destroy_route);
g_free(me);
return err;
}
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;
}
static void setup_tun_interface(unsigned int flags, unsigned change,
void *data)
{
struct connman_private_network *pn = data;
unsigned char prefixlen;
DBusMessageIter array, dict;
const char *server_ip;
const char *peer_ip;
const char *subnet_mask;
int err;
DBG("index %d flags %d change %d", pn->index, flags, change);
if (flags & IFF_UP)
return;
subnet_mask = __connman_ippool_get_subnet_mask(pn->pool);
server_ip = __connman_ippool_get_start_ip(pn->pool);
peer_ip = __connman_ippool_get_end_ip(pn->pool);
prefixlen = connman_ipaddress_calc_netmask_len(subnet_mask);
if ((__connman_inet_modify_address(RTM_NEWADDR,
NLM_F_REPLACE | NLM_F_ACK, pn->index, AF_INET,
server_ip, peer_ip, prefixlen, NULL)) < 0) {
DBG("address setting failed");
return;
}
connman_inet_ifup(pn->index);
err = __connman_nat_enable(BRIDGE_NAME, server_ip, prefixlen);
if (err < 0) {
connman_error("failed to enable NAT");
goto error;
}
dbus_message_iter_init_append(pn->reply, &array);
dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
&pn->path);
connman_dbus_dict_open(&array, &dict);
connman_dbus_dict_append_basic(&dict, "ServerIPv4",
DBUS_TYPE_STRING, &server_ip);
connman_dbus_dict_append_basic(&dict, "PeerIPv4",
DBUS_TYPE_STRING, &peer_ip);
if (pn->primary_dns)
connman_dbus_dict_append_basic(&dict, "PrimaryDNS",
DBUS_TYPE_STRING, &pn->primary_dns);
if (pn->secondary_dns)
connman_dbus_dict_append_basic(&dict, "SecondaryDNS",
DBUS_TYPE_STRING, &pn->secondary_dns);
connman_dbus_dict_close(&array, &dict);
dbus_message_iter_append_basic(&array, DBUS_TYPE_UNIX_FD, &pn->fd);
g_dbus_send_message(connection, pn->reply);
return;
error:
pn->reply = __connman_error_failed(pn->msg, -err);
g_dbus_send_message(connection, pn->reply);
g_hash_table_remove(pn_hash, pn->path);
}
