dbus_bool_t connman_dbus_setting_changed_array(const char *owner,
const char *path, const char *key, int type,
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_array(&dict, key, type, function, user_data);
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;
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_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 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");
}
}
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 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 DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct connman_network *network = data;
DBusMessage *reply;
DBusMessageIter array, dict;
_DBG_NETWORK("conn %p", conn);
if (__connman_security_check_privilege(msg,
CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
return __connman_error_permission_denied(msg);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &array);
dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
if (network->device) {
const char *path = connman_device_get_path(network->device);
if (path != NULL)
connman_dbus_dict_append_variant(&dict, "Device",
DBUS_TYPE_OBJECT_PATH, &path);
}
if (network->address != NULL)
connman_dbus_dict_append_variant(&dict, "Address",
DBUS_TYPE_STRING, &network->address);
if (network->name != NULL)
connman_dbus_dict_append_variant(&dict, "Name",
DBUS_TYPE_STRING, &network->name);
connman_dbus_dict_append_variant(&dict, "Connected",
DBUS_TYPE_BOOLEAN, &network->connected);
if (network->strength > 0)
connman_dbus_dict_append_variant(&dict, "Strength",
DBUS_TYPE_BYTE, &network->strength);
if (network->frequency > 0)
connman_dbus_dict_append_variant(&dict, "Frequency",
DBUS_TYPE_UINT16, &network->frequency);
if (network->wifi.ssid != NULL && network->wifi.ssid_len > 0)
connman_dbus_dict_append_array(&dict, "WiFi.SSID",
DBUS_TYPE_BYTE, &network->wifi.ssid,
network->wifi.ssid_len);
if (network->wifi.mode != NULL)
connman_dbus_dict_append_variant(&dict, "WiFi.Mode",
DBUS_TYPE_STRING, &network->wifi.mode);
if (network->wifi.channel > 0)
connman_dbus_dict_append_variant(&dict, "WiFi.Channel",
DBUS_TYPE_UINT16, &network->wifi.channel);
if (network->wifi.security != NULL)
connman_dbus_dict_append_variant(&dict, "WiFi.Security",
DBUS_TYPE_STRING, &network->wifi.security);
if (network->wifi.passphrase != NULL &&
__connman_security_check_privilege(msg,
CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
connman_dbus_dict_append_variant(&dict, "WiFi.Passphrase",
DBUS_TYPE_STRING, &network->wifi.passphrase);
dbus_message_iter_close_container(&array, &dict);
return reply;
}
static int set_network(struct supplicant_task *task,
const unsigned char *network, int len,
const char *address, const char *security,
const char *passphrase)
{
DBusMessage *message, *reply;
DBusMessageIter array, dict;
DBusError error;
dbus_uint32_t scan_ssid = 1;
_DBG_SUPPLICANT("task %p", task);
if (task->netpath == NULL)
return -EINVAL;
message = dbus_message_new_method_call(SUPPLICANT_NAME, task->netpath,
SUPPLICANT_INTF ".Network", "set");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_iter_init_append(message, &array);
dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
connman_dbus_dict_append_variant(&dict, "scan_ssid",
DBUS_TYPE_UINT32, &scan_ssid);
connman_dbus_dict_append_array(&dict, "ssid",
DBUS_TYPE_BYTE, &network, len);
/* NB: do not set the bssid; this allows wpa_supplicant to roam */
if (g_ascii_strcasecmp(security, "wpa") == 0 ||
g_ascii_strcasecmp(security, "rsn") == 0) {
const char *key_mgmt = "WPA-PSK";
connman_dbus_dict_append_variant(&dict, "key_mgmt",
DBUS_TYPE_STRING, &key_mgmt);
if (passphrase && strlen(passphrase) > 0)
connman_dbus_dict_append_variant(&dict, "psk",
DBUS_TYPE_STRING, &passphrase);
} else if (g_ascii_strcasecmp(security, "wep") == 0) {
const char *key_mgmt = "NONE";
const char *auth_alg = "OPEN";
const char *key_index = "0";
if (task->mac80211 == TRUE)
auth_alg = "OPEN SHARED";
connman_dbus_dict_append_variant(&dict, "auth_alg",
DBUS_TYPE_STRING, &auth_alg);
connman_dbus_dict_append_variant(&dict, "key_mgmt",
DBUS_TYPE_STRING, &key_mgmt);
if (passphrase) {
int size = strlen(passphrase);
if (size == 10 || size == 26) {
unsigned char *key = malloc(13);
char tmp[3];
int i;
memset(tmp, 0, sizeof(tmp));
if (key == NULL)
size = 0;
for (i = 0; i < size / 2; i++) {
memcpy(tmp, passphrase + (i * 2), 2);
key[i] = (unsigned char) strtol(tmp,
NULL, 16);
}
connman_dbus_dict_append_array(&dict,
"wep_key0", DBUS_TYPE_BYTE,
&key, size / 2);
free(key);
} else
connman_dbus_dict_append_variant(&dict,
"wep_key0", DBUS_TYPE_STRING,
&passphrase);
connman_dbus_dict_append_variant(&dict, "wep_tx_keyidx",
DBUS_TYPE_STRING, &key_index);
}
} else {
const char *key_mgmt = "NONE";
connman_dbus_dict_append_variant(&dict, "key_mgmt",
DBUS_TYPE_STRING, &key_mgmt);
}
dbus_message_iter_close_container(&array, &dict);
dbus_error_init(&error);
reply = dbus_connection_send_with_reply_and_block(connection,
message, -1, &error);
if (reply == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Failed to set network options");
dbus_message_unref(message);
return -EIO;
}
dbus_message_unref(message);
dbus_message_unref(reply);
return 0;
}
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;
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 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);
}
