Rename D-Bus helper for basic dictionary types

diff --git a/include/dbus.h b/include/dbus.h
index 5d12be7..db681b9 100644 (file)
--- a/include/dbus.h
+++ b/include/dbus.h
@@ -80,7 +80,7 @@ static inline void connman_dbus_dict_close(DBusMessageIter *iter,
        dbus_message_iter_close_container(iter, dict);
 }
 
-static inline void connman_dbus_dict_append_variant(DBusMessageIter *dict,
+static inline void connman_dbus_dict_append_basic(DBusMessageIter *dict,
                                        const char *key, int type, void *val)
 {
        DBusMessageIter entry;

diff --git a/plugins/supplicant.c b/plugins/supplicant.c
index f8d34af..74ba5e3 100644 (file)
--- a/plugins/supplicant.c
+++ b/plugins/supplicant.c
@@ -375,7 +375,7 @@ static int add_interface(struct supplicant_task *task)
 
        connman_dbus_dict_open(&array, &dict);
 
-       connman_dbus_dict_append_variant(&dict, "driver",
+       connman_dbus_dict_append_basic(&dict, "driver",
                                                DBUS_TYPE_STRING, &driver);
 
        connman_dbus_dict_close(&array, &dict);
@@ -783,25 +783,25 @@ static int set_network(struct supplicant_task *task,
 
        connman_dbus_dict_open(&array, &dict);
 
-       connman_dbus_dict_append_variant(&dict, "scan_ssid",
+       connman_dbus_dict_append_basic(&dict, "scan_ssid",
                                         DBUS_TYPE_UINT32, &scan_ssid);
 
        if (network)
                connman_dbus_dict_append_fixed_array(&dict, "ssid",
                                                DBUS_TYPE_BYTE, &network, len);
        else if (address)
-               connman_dbus_dict_append_variant(&dict, "bssid",
+               connman_dbus_dict_append_basic(&dict, "bssid",
                                                DBUS_TYPE_STRING, &address);
 
        if (g_ascii_strcasecmp(security, "psk") == 0 ||
                                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",
+               connman_dbus_dict_append_basic(&dict, "key_mgmt",
                                                DBUS_TYPE_STRING, &key_mgmt);
 
                if (passphrase && strlen(passphrase) > 0)
-                       connman_dbus_dict_append_variant(&dict, "psk",
+                       connman_dbus_dict_append_basic(&dict, "psk",
                                                DBUS_TYPE_STRING, &passphrase);
        } else if (g_ascii_strcasecmp(security, "wep") == 0) {
                const char *key_mgmt = "NONE";
@@ -811,10 +811,10 @@ static int set_network(struct supplicant_task *task,
                if (task->mac80211 == TRUE)
                        auth_alg = "OPEN SHARED";
 
-               connman_dbus_dict_append_variant(&dict, "auth_alg",
+               connman_dbus_dict_append_basic(&dict, "auth_alg",
                                                DBUS_TYPE_STRING, &auth_alg);
 
-               connman_dbus_dict_append_variant(&dict, "key_mgmt",
+               connman_dbus_dict_append_basic(&dict, "key_mgmt",
                                                DBUS_TYPE_STRING, &key_mgmt);
 
                if (passphrase) {
@@ -836,16 +836,16 @@ static int set_network(struct supplicant_task *task,
                                                        &key, size / 2);
                                free(key);
                        } else
-                               connman_dbus_dict_append_variant(&dict,
+                               connman_dbus_dict_append_basic(&dict,
                                                "wep_key0", DBUS_TYPE_STRING,
                                                                &passphrase);
 
-                       connman_dbus_dict_append_variant(&dict, "wep_tx_keyidx",
+                       connman_dbus_dict_append_basic(&dict, "wep_tx_keyidx",
                                                DBUS_TYPE_STRING, &key_index);
                }
        } else {
                const char *key_mgmt = "NONE";
-               connman_dbus_dict_append_variant(&dict, "key_mgmt",
+               connman_dbus_dict_append_basic(&dict, "key_mgmt",
                                                DBUS_TYPE_STRING, &key_mgmt);
        }
 

diff --git a/src/device.c b/src/device.c
index 05e27ab..63aa915 100644 (file)
--- a/src/device.c
+++ b/src/device.c
@@ -309,27 +309,27 @@ static DBusMessage *get_properties(DBusConnection *conn,
        connman_dbus_dict_open(&array, &dict);
 
        if (device->name != NULL)
-               connman_dbus_dict_append_variant(&dict, "Name",
+               connman_dbus_dict_append_basic(&dict, "Name",
                                        DBUS_TYPE_STRING, &device->name);
 
        str = type2string(device->type);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Type",
+               connman_dbus_dict_append_basic(&dict, "Type",
                                                DBUS_TYPE_STRING, &str);
 
        if (device->address != NULL)
-               connman_dbus_dict_append_variant(&dict, "Address",
+               connman_dbus_dict_append_basic(&dict, "Address",
                                        DBUS_TYPE_STRING, &device->address);
 
        if (device->interface != NULL)
-               connman_dbus_dict_append_variant(&dict, "Interface",
+               connman_dbus_dict_append_basic(&dict, "Interface",
                                        DBUS_TYPE_STRING, &device->interface);
 
-       connman_dbus_dict_append_variant(&dict, "Powered",
+       connman_dbus_dict_append_basic(&dict, "Powered",
                                        DBUS_TYPE_BOOLEAN, &device->powered);
 
        if (device->driver && device->driver->scan)
-               connman_dbus_dict_append_variant(&dict, "Scanning",
+               connman_dbus_dict_append_basic(&dict, "Scanning",
                                        DBUS_TYPE_BOOLEAN, &device->scanning);
 
        switch (device->mode) {
@@ -338,7 +338,7 @@ static DBusMessage *get_properties(DBusConnection *conn,
        case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
        case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
                if (device->scan_interval > 0)
-                       connman_dbus_dict_append_variant(&dict, "ScanInterval",
+                       connman_dbus_dict_append_basic(&dict, "ScanInterval",
                                DBUS_TYPE_UINT16, &device->scan_interval);
 
                dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,

diff --git a/src/element.c b/src/element.c
index 0931f93..01f8671 100644 (file)
--- a/src/element.c
+++ b/src/element.c
@@ -1118,31 +1118,31 @@ int __connman_element_append_ipv4(struct connman_element *element,
                        CONNMAN_PROPERTY_ID_IPV4_TIMESERVER, &timeserver);
 
        if (method != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Method",
+               connman_dbus_dict_append_basic(dict, "IPv4.Method",
                                                DBUS_TYPE_STRING, &method);
 
        if (address != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Address",
+               connman_dbus_dict_append_basic(dict, "IPv4.Address",
                                                DBUS_TYPE_STRING, &address);
 
        if (netmask != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Netmask",
+               connman_dbus_dict_append_basic(dict, "IPv4.Netmask",
                                                DBUS_TYPE_STRING, &netmask);
 
        if (gateway != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Gateway",
+               connman_dbus_dict_append_basic(dict, "IPv4.Gateway",
                                                DBUS_TYPE_STRING, &gateway);
 
        if (broadcast != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Broadcast",
+               connman_dbus_dict_append_basic(dict, "IPv4.Broadcast",
                                                DBUS_TYPE_STRING, &broadcast);
 
        if (nameserver != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Nameserver",
+               connman_dbus_dict_append_basic(dict, "IPv4.Nameserver",
                                                DBUS_TYPE_STRING, &nameserver);
 
        if (timeserver != NULL)
-               connman_dbus_dict_append_variant(dict, "IPv4.Timeserver",
+               connman_dbus_dict_append_basic(dict, "IPv4.Timeserver",
                                                DBUS_TYPE_STRING, &timeserver);
 
        return 0;

diff --git a/src/ipconfig.c b/src/ipconfig.c
index 9b5ec7e..43d41da 100644 (file)
--- a/src/ipconfig.c
+++ b/src/ipconfig.c
@@ -879,19 +879,19 @@ enum connman_ipconfig_method __connman_ipconfig_string2method(const char *method
                return CONNMAN_IPCONFIG_METHOD_UNKNOWN;
 }
 
-static void append_variant(DBusMessageIter *iter, const char *prefix,
+static void append_basic(DBusMessageIter *iter, const char *prefix,
                                        const char *key, int type, void *val)
 {
        char *str;
 
        if (prefix == NULL) {
-               connman_dbus_dict_append_variant(iter, key, type, val);
+               connman_dbus_dict_append_basic(iter, key, type, val);
                return;
        }
 
        str = g_strdup_printf("%s%s", prefix, key);
        if (str != NULL)
-               connman_dbus_dict_append_variant(iter, str, type, val);
+               connman_dbus_dict_append_basic(iter, str, type, val);
 
        g_free(str);
 }
@@ -905,7 +905,7 @@ void __connman_ipconfig_append_ipv4(struct connman_ipconfig *ipconfig,
        if (str == NULL)
                return;
 
-       append_variant(iter, prefix, "Method", DBUS_TYPE_STRING, &str);
+       append_basic(iter, prefix, "Method", DBUS_TYPE_STRING, &str);
 }
 
 int __connman_ipconfig_set_ipv4(struct connman_ipconfig *ipconfig,

diff --git a/src/manager.c b/src/manager.c
index b7e761c..d512b24 100644 (file)
--- a/src/manager.c
+++ b/src/manager.c
@@ -51,7 +51,7 @@ static DBusMessage *get_properties(DBusConnection *conn,
 
        str = __connman_profile_active_path();
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "ActiveProfile",
+               connman_dbus_dict_append_basic(&dict, "ActiveProfile",
                                                DBUS_TYPE_OBJECT_PATH, &str);
 
        connman_dbus_dict_append_variable_array(&dict, "Profiles",
@@ -69,11 +69,11 @@ static DBusMessage *get_properties(DBusConnection *conn,
        else
                str = "offline";
 
-       connman_dbus_dict_append_variant(&dict, "State",
+       connman_dbus_dict_append_basic(&dict, "State",
                                                DBUS_TYPE_STRING, &str);
 
        offlinemode = __connman_profile_get_offlinemode();
-       connman_dbus_dict_append_variant(&dict, "OfflineMode",
+       connman_dbus_dict_append_basic(&dict, "OfflineMode",
                                        DBUS_TYPE_BOOLEAN, &offlinemode);
 
        connman_dbus_dict_append_variable_array(&dict, "AvailableTechnologies",
@@ -85,7 +85,7 @@ static DBusMessage *get_properties(DBusConnection *conn,
 
        str = __connman_service_default();
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "DefaultTechnology",
+               connman_dbus_dict_append_basic(&dict, "DefaultTechnology",
                                                DBUS_TYPE_STRING, &str);
 
        connman_dbus_dict_append_variable_array(&dict, "AvailableDebugs",

diff --git a/src/network.c b/src/network.c
index 231db87..138783b 100644 (file)
--- a/src/network.c
+++ b/src/network.c
@@ -116,27 +116,27 @@ static DBusMessage *get_properties(DBusConnection *conn,
        if (network->device) {
                const char *path = connman_device_get_path(network->device);
                if (path != NULL)
-                       connman_dbus_dict_append_variant(&dict, "Device",
+                       connman_dbus_dict_append_basic(&dict, "Device",
                                                DBUS_TYPE_OBJECT_PATH, &path);
        }
 
        if (network->address != NULL)
-               connman_dbus_dict_append_variant(&dict, "Address",
+               connman_dbus_dict_append_basic(&dict, "Address",
                                        DBUS_TYPE_STRING, &network->address);
 
        if (network->name != NULL)
-               connman_dbus_dict_append_variant(&dict, "Name",
+               connman_dbus_dict_append_basic(&dict, "Name",
                                        DBUS_TYPE_STRING, &network->name);
 
-       connman_dbus_dict_append_variant(&dict, "Connected",
+       connman_dbus_dict_append_basic(&dict, "Connected",
                                DBUS_TYPE_BOOLEAN, &network->connected);
 
        if (network->strength > 0)
-               connman_dbus_dict_append_variant(&dict, "Strength",
+               connman_dbus_dict_append_basic(&dict, "Strength",
                                        DBUS_TYPE_BYTE, &network->strength);
 
        if (network->frequency > 0)
-               connman_dbus_dict_append_variant(&dict, "Frequency",
+               connman_dbus_dict_append_basic(&dict, "Frequency",
                                        DBUS_TYPE_UINT16, &network->frequency);
 
        if (network->wifi.ssid != NULL && network->wifi.ssid_len > 0)
@@ -145,21 +145,21 @@ static DBusMessage *get_properties(DBusConnection *conn,
                                                network->wifi.ssid_len);
 
        if (network->wifi.mode != NULL)
-               connman_dbus_dict_append_variant(&dict, "WiFi.Mode",
+               connman_dbus_dict_append_basic(&dict, "WiFi.Mode",
                                DBUS_TYPE_STRING, &network->wifi.mode);
 
        if (network->wifi.channel > 0)
-               connman_dbus_dict_append_variant(&dict, "WiFi.Channel",
+               connman_dbus_dict_append_basic(&dict, "WiFi.Channel",
                                DBUS_TYPE_UINT16, &network->wifi.channel);
 
        if (network->wifi.security != NULL)
-               connman_dbus_dict_append_variant(&dict, "WiFi.Security",
+               connman_dbus_dict_append_basic(&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",
+               connman_dbus_dict_append_basic(&dict, "WiFi.Passphrase",
                                DBUS_TYPE_STRING, &network->wifi.passphrase);
 
        connman_dbus_dict_close(&array, &dict);

diff --git a/src/profile.c b/src/profile.c
index 66597b4..fe9ddb8 100644 (file)
--- a/src/profile.c
+++ b/src/profile.c
@@ -262,10 +262,10 @@ static DBusMessage *get_properties(DBusConnection *conn,
        connman_dbus_dict_open(&array, &dict);
 
        if (profile->name != NULL)
-               connman_dbus_dict_append_variant(&dict, "Name",
+               connman_dbus_dict_append_basic(&dict, "Name",
                                        DBUS_TYPE_STRING, &profile->name);
 
-       connman_dbus_dict_append_variant(&dict, "OfflineMode",
+       connman_dbus_dict_append_basic(&dict, "OfflineMode",
                                DBUS_TYPE_BOOLEAN, &profile->offlinemode);
 
        connman_dbus_dict_append_variable_array(&dict, "Services",

diff --git a/src/provider.c b/src/provider.c
index ec3cf3b..7a00372 100644 (file)
--- a/src/provider.c
+++ b/src/provider.c
@@ -423,26 +423,26 @@ static DBusMessage *get_properties(DBusConnection *conn,
        connman_dbus_dict_open(&array, &dict);
 
        if (provider->name != NULL)
-               connman_dbus_dict_append_variant(&dict, "Name",
+               connman_dbus_dict_append_basic(&dict, "Name",
                                        DBUS_TYPE_STRING, &provider->name);
 
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Type",
+               connman_dbus_dict_append_basic(&dict, "Type",
                                                 DBUS_TYPE_STRING,
                                                 &provider->type);
 
        str = state2string(provider->state);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "State",
+               connman_dbus_dict_append_basic(&dict, "State",
                                                 DBUS_TYPE_STRING, &str);
 
        str = error2string(provider->error);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Error",
+               connman_dbus_dict_append_basic(&dict, "Error",
                                                 DBUS_TYPE_STRING, &str);
 
        required = TRUE;
-       connman_dbus_dict_append_variant(&dict, "PassphraseRequired",
+       connman_dbus_dict_append_basic(&dict, "PassphraseRequired",
                                         DBUS_TYPE_BOOLEAN, &required);
 
        connman_dbus_dict_close(&array, &dict);

diff --git a/src/service.c b/src/service.c
index 3b760b2..3c68aab 100644 (file)
--- a/src/service.c
+++ b/src/service.c
@@ -387,7 +387,7 @@ static void append_settings(DBusMessageIter *iter, void *user_data)
 {
        const char *str = "dhcp";
 
-       connman_dbus_dict_append_variant(iter, "Method",
+       connman_dbus_dict_append_basic(iter, "Method",
                                                DBUS_TYPE_STRING, &str);
 }
 
@@ -419,45 +419,45 @@ static DBusMessage *get_properties(DBusConnection *conn,
 
        str = __connman_service_type2string(service->type);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Type",
+               connman_dbus_dict_append_basic(&dict, "Type",
                                                DBUS_TYPE_STRING, &str);
 
        str = mode2string(service->mode);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Mode",
+               connman_dbus_dict_append_basic(&dict, "Mode",
                                                DBUS_TYPE_STRING, &str);
 
        str = security2string(service->security);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Security",
+               connman_dbus_dict_append_basic(&dict, "Security",
                                                DBUS_TYPE_STRING, &str);
 
        str = state2string(service->state);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "State",
+               connman_dbus_dict_append_basic(&dict, "State",
                                                DBUS_TYPE_STRING, &str);
 
        str = error2string(service->error);
        if (str != NULL)
-               connman_dbus_dict_append_variant(&dict, "Error",
+               connman_dbus_dict_append_basic(&dict, "Error",
                                                DBUS_TYPE_STRING, &str);
 
        if (service->strength > 0)
-               connman_dbus_dict_append_variant(&dict, "Strength",
+               connman_dbus_dict_append_basic(&dict, "Strength",
                                        DBUS_TYPE_BYTE, &service->strength);
 
-       connman_dbus_dict_append_variant(&dict, "Favorite",
+       connman_dbus_dict_append_basic(&dict, "Favorite",
                                        DBUS_TYPE_BOOLEAN, &service->favorite);
 
        if (service->favorite == TRUE)
-               connman_dbus_dict_append_variant(&dict, "AutoConnect",
+               connman_dbus_dict_append_basic(&dict, "AutoConnect",
                                DBUS_TYPE_BOOLEAN, &service->autoconnect);
        else
-               connman_dbus_dict_append_variant(&dict, "AutoConnect",
+               connman_dbus_dict_append_basic(&dict, "AutoConnect",
                                        DBUS_TYPE_BOOLEAN, &service->favorite);
 
        if (service->name != NULL)
-               connman_dbus_dict_append_variant(&dict, "Name",
+               connman_dbus_dict_append_basic(&dict, "Name",
                                        DBUS_TYPE_STRING, &service->name);
 
        switch (service->type) {
@@ -469,27 +469,27 @@ static DBusMessage *get_properties(DBusConnection *conn,
        case CONNMAN_SERVICE_TYPE_VPN:
                break;
        case CONNMAN_SERVICE_TYPE_CELLULAR:
-               connman_dbus_dict_append_variant(&dict, "Roaming",
+               connman_dbus_dict_append_basic(&dict, "Roaming",
                                        DBUS_TYPE_BOOLEAN, &service->roaming);
 
                if (service->mcc != NULL && service->mnc != NULL) {
-                       connman_dbus_dict_append_variant(&dict, "MCC",
+                       connman_dbus_dict_append_basic(&dict, "MCC",
                                        DBUS_TYPE_STRING, &service->mcc);
-                       connman_dbus_dict_append_variant(&dict, "MNC",
+                       connman_dbus_dict_append_basic(&dict, "MNC",
                                        DBUS_TYPE_STRING, &service->mnc);
                }
 
                if (service->apn != NULL) {
-                       connman_dbus_dict_append_variant(&dict, "APN",
+                       connman_dbus_dict_append_basic(&dict, "APN",
                                        DBUS_TYPE_STRING, &service->apn);
 
                        if (service->username != NULL)
-                               connman_dbus_dict_append_variant(&dict,
+                               connman_dbus_dict_append_basic(&dict,
                                        "Username", DBUS_TYPE_STRING,
                                                        &service->username);
 
                        if (service->password != NULL)
-                               connman_dbus_dict_append_variant(&dict,
+                               connman_dbus_dict_append_basic(&dict,
                                        "Password", DBUS_TYPE_STRING,
                                                        &service->password);
 
@@ -497,14 +497,14 @@ static DBusMessage *get_properties(DBusConnection *conn,
                } else
                        required = TRUE;
 
-               connman_dbus_dict_append_variant(&dict, "SetupRequired",
+               connman_dbus_dict_append_basic(&dict, "SetupRequired",
                                                DBUS_TYPE_BOOLEAN, &required);
                break;
        case CONNMAN_SERVICE_TYPE_WIFI:
                if (service->passphrase != NULL &&
                                __connman_security_check_privilege(msg,
                                        CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
-                       connman_dbus_dict_append_variant(&dict, "Passphrase",
+                       connman_dbus_dict_append_basic(&dict, "Passphrase",
                                DBUS_TYPE_STRING, &service->passphrase);
 
                required = FALSE;
@@ -523,7 +523,7 @@ static DBusMessage *get_properties(DBusConnection *conn,
                        break;
                }
 
-               connman_dbus_dict_append_variant(&dict, "PassphraseRequired",
+               connman_dbus_dict_append_basic(&dict, "PassphraseRequired",
                                                DBUS_TYPE_BOOLEAN, &required);
                break;
        }