[network-manager-vpnc/lr/libnm: 9/10] fixup! service: port to libnm

[Lubomir Rintel <lkundrak src gnome org>]

commit 72563fe8bec907e022e4138cf2fb7605e80997a0
Author: Lubomir Rintel <lkundrak v3 sk>
Date:   Sun Aug 16 14:46:23 2015 +0200

    fixup! service: port to libnm
    
    port to gvariant.
    
    UNTESTED!

 src/nm-vpnc-service-vpnc-helper.c |  178 ++++++++++++++----------------------
 1 files changed, 69 insertions(+), 109 deletions(-)
---
diff --git a/src/nm-vpnc-service-vpnc-helper.c b/src/nm-vpnc-service-vpnc-helper.c
index f3d8788..381ae1c 100644
--- a/src/nm-vpnc-service-vpnc-helper.c
+++ b/src/nm-vpnc-service-vpnc-helper.c
@@ -70,8 +70,9 @@ helper_failed (DBusGConnection *connection, const char *reason)
 }
 
 static void
-send_ip4_config (DBusGConnection *connection, GHashTable *config)
+send_ip4_config (DBusGConnection *connection, GVariant *config)
 {
+#if 0
        DBusGProxy *proxy;
        GError *err = NULL;
 
@@ -92,12 +93,12 @@ send_ip4_config (DBusGConnection *connection, GHashTable *config)
        }
 
        g_object_unref (proxy);
+#endif
 }
 
-static GValue *
-str_to_gvalue (const char *str, gboolean try_convert)
+static GVariant *
+str_to_gvariant (const char *str, gboolean try_convert)
 {
-       GValue *val;
 
        /* Empty */
        if (!str || strlen (str) < 1)
@@ -112,43 +113,13 @@ str_to_gvalue (const char *str, gboolean try_convert)
                        return NULL;
        }
 
-       val = g_slice_new0 (GValue);
-       g_value_init (val, G_TYPE_STRING);
-       g_value_set_string (val, str);
-
-       return val;
-}
-
-static GValue *
-uint_to_gvalue (guint32 num)
-{
-       GValue *val;
-
-       if (num == 0)
-               return NULL;
-
-       val = g_slice_new0 (GValue);
-       g_value_init (val, G_TYPE_UINT);
-       g_value_set_uint (val, num);
-
-       return val;
+       return g_variant_new_string (str);
 }
 
-static GValue *
-bool_to_gvalue (gboolean b)
+static GVariant *
+addr4_to_gvariant (const char *str)
 {
-       GValue *val;
-
-       val = g_slice_new0 (GValue);
-       g_value_init (val, G_TYPE_BOOLEAN);
-       g_value_set_boolean (val, b);
-       return val;
-}
-
-static GValue *
-addr_to_gvalue (const char *str)
-{
-       struct in_addr temp_addr;
+        struct in_addr  temp_addr;
 
        /* Empty */
        if (!str || strlen (str) < 1)
@@ -157,16 +128,15 @@ addr_to_gvalue (const char *str)
        if (inet_pton (AF_INET, str, &temp_addr) <= 0)
                return NULL;
 
-       return uint_to_gvalue (temp_addr.s_addr);
+       return g_variant_new_uint32 (temp_addr.s_addr);
 }
 
-static GValue *
-addr_list_to_gvalue (const char *str)
+static GVariant *
+addr4_list_to_gvariant (const char *str)
 {
-       GValue *val;
+       GVariantBuilder builder;
        char **split;
        int i;
-       GArray *array;
 
        /* Empty */
        if (!str || strlen (str) < 1)
@@ -176,33 +146,29 @@ addr_list_to_gvalue (const char *str)
        if (g_strv_length (split) == 0)
                return NULL;
 
-       array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), g_strv_length (split));
+       g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
+
        for (i = 0; split[i]; i++) {
                struct in_addr addr;
 
                if (inet_pton (AF_INET, split[i], &addr) > 0) {
-                       g_array_append_val (array, addr.s_addr);
+                       g_variant_builder_add_value (&builder, g_variant_new_uint32 (addr.s_addr));
                } else {
                        g_strfreev (split);
-                       g_array_free (array, TRUE);
+                       g_variant_unref (g_variant_builder_end (&builder));
                        return NULL;
                }
        }
 
        g_strfreev (split);
 
-       val = g_slice_new0 (GValue);
-       g_value_init (val, DBUS_TYPE_G_UINT_ARRAY);
-       g_value_set_boxed (val, array);
-
-       return val;
+       return g_variant_builder_end (&builder);
 }
 
-static GValue *
-split_dns_list_to_gvalue (const char *str)
+static GVariant *
+split_dns_list_to_gvariant (const char *str)
 {
-       GValue *val;
-       char **split;
+       gchar **split;
 
        if (!str || strlen (str) < 1)
                return NULL;
@@ -211,18 +177,14 @@ split_dns_list_to_gvalue (const char *str)
        if (g_strv_length (split) == 0)
                return NULL;
 
-       val = g_slice_new0 (GValue);
-       g_value_init (val, G_TYPE_STRV);
-       g_value_take_boxed (val, split);
-
-       return val;
+       return g_variant_new_strv ((const gchar **) split, -1);
 }
 
-static GValue *
-get_routes (void)
+static GVariant *
+get_ip4_routes (void)
 {
-       GValue *value = NULL;
-       GPtrArray *routes;
+       GVariantBuilder builder;
+       GVariant *value;
        char *tmp;
        int num;
        int i;
@@ -237,10 +199,10 @@ get_routes (void)
        if (!num)
                return NULL;
 
-       routes = g_ptr_array_new ();
+       g_variant_builder_init (&builder, G_VARIANT_TYPE ("aau"));
 
        for (i = 0; i < num; i++) {
-               GArray *array;
+               GVariantBuilder array;
                char buf[BUFLEN];
                struct in_addr network;
                guint32 next_hop = 0; /* no next hop */
@@ -277,22 +239,20 @@ get_routes (void)
                        prefix = nm_utils_ip4_netmask_to_prefix (netmask.s_addr);
                }
 
-               array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 4);
-               g_array_append_val (array, network.s_addr);
-               g_array_append_val (array, prefix);
-               g_array_append_val (array, next_hop);
-               g_array_append_val (array, metric);
-               g_ptr_array_add (routes, array);
+               g_variant_builder_init (&array, G_VARIANT_TYPE ("au"));
+               g_variant_builder_add_value (&array, g_variant_new_uint32 (network.s_addr));
+               g_variant_builder_add_value (&array, g_variant_new_uint32 (prefix));
+               g_variant_builder_add_value (&array, g_variant_new_uint32 (next_hop));
+               g_variant_builder_add_value (&array, g_variant_new_uint32 (metric));
+               g_variant_builder_add_value (&builder, g_variant_builder_end (&array));
        }
 
-       if (routes->len > 0) {
-               value = g_new0 (GValue, 1);
-               g_value_init (value, DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UINT);
-               g_value_take_boxed (value, routes);
-       } else
-               g_ptr_array_free (routes, TRUE);
+       value = g_variant_builder_end (&builder);
+       if (i > 1)
+               return value;
 
-       return value;
+       g_variant_unref (value);
+       return NULL;
 }
 
 /*
@@ -313,8 +273,8 @@ main (int argc, char *argv[])
 {
        DBusGConnection *connection;
        char *tmp;
-       GHashTable *config;
-       GValue *val;
+       GVariantBuilder config;
+       GVariant *val;
        GError *err = NULL;
        struct in_addr temp_addr;
        long int mtu = 1412;
@@ -338,33 +298,33 @@ main (int argc, char *argv[])
                exit (1);
        }
 
-       config = g_hash_table_new (g_str_hash, g_str_equal);
+       g_variant_builder_init (&config, G_VARIANT_TYPE_VARDICT);
 
        /* Gateway */
-       val = addr_to_gvalue (getenv ("VPNGATEWAY"));
+       val = addr4_to_gvariant (getenv ("VPNGATEWAY"));
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_GATEWAY, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_GATEWAY, val);
        else
                helper_failed (connection, "VPN Gateway");
 
        /* Tunnel device */
-       val = str_to_gvalue (getenv ("TUNDEV"), FALSE);
+       val = str_to_gvariant (getenv ("TUNDEV"), FALSE);
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, val);
        else
                helper_failed (connection, "Tunnel Device");
 
        /* IP address */
-       val = addr_to_gvalue (getenv ("INTERNAL_IP4_ADDRESS"));
+       val = addr4_to_gvariant (getenv ("INTERNAL_IP4_ADDRESS"));
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, val);
        else
                helper_failed (connection, "IP4 Address");
 
        /* PTP address; for vpnc PTP address == internal IP4 address */
-       val = addr_to_gvalue (getenv ("INTERNAL_IP4_ADDRESS"));
+       val = addr4_to_gvariant (getenv ("INTERNAL_IP4_ADDRESS"));
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_PTP, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PTP, val);
        else
                helper_failed (connection, "IP4 PTP Address");
 
@@ -392,43 +352,43 @@ main (int argc, char *argv[])
                prefix = 32;
 
        if (prefix) {
-               val = uint_to_gvalue (prefix);
+               val = g_variant_new_uint32 (prefix);
                if (val)
-                       g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val);
+                       g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val);
        }
 
        /* DNS */
-       val = addr_list_to_gvalue (getenv ("INTERNAL_IP4_DNS"));
+       val = addr4_list_to_gvariant (getenv ("INTERNAL_IP4_DNS"));
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_DNS, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_DNS, val);
 
        /* WINS servers */
-       val = addr_list_to_gvalue (getenv ("INTERNAL_IP4_NBNS"));
+       val = addr4_list_to_gvariant (getenv ("INTERNAL_IP4_NBNS"));
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_NBNS, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_NBNS, val);
 
        /* Default domain */
-       val = str_to_gvalue (getenv ("CISCO_DEF_DOMAIN"), TRUE);
+       val = str_to_gvariant (getenv ("CISCO_DEF_DOMAIN"), TRUE);
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_DOMAIN, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_DOMAIN, val);
 
        /* Split DNS domains */
-       val = split_dns_list_to_gvalue (getenv ("CISCO_SPLIT_DNS"));
+       val = split_dns_list_to_gvariant (getenv ("CISCO_SPLIT_DNS"));
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_DOMAINS, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_DOMAINS, val);
 
        /* Routes */
-       val = get_routes ();
+       val = get_ip4_routes ();
        if (val) {
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_ROUTES, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_ROUTES, val);
                /* If routes-to-include were provided, that means no default route */
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_NEVER_DEFAULT,
-                                    bool_to_gvalue (TRUE));
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_NEVER_DEFAULT,
+                                    g_variant_new_boolean (TRUE));
        }
        /* Banner */
-       val = str_to_gvalue (getenv ("CISCO_BANNER"), TRUE);
+       val = str_to_gvariant (getenv ("CISCO_BANNER"), TRUE);
        if (val)
-               g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_BANNER, val);
+               g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_BANNER, val);
 
        /* MTU */
        tmp = getenv ("INTERNAL_IP4_MTU");
@@ -440,11 +400,11 @@ main (int argc, char *argv[])
                        mtu = 1412;
                }
        }
-       val = uint_to_gvalue ((guint32) mtu);
-       g_hash_table_insert (config, NM_VPN_PLUGIN_IP4_CONFIG_MTU, val);
+       val = g_variant_new_uint32 ((guint32) mtu);
+       g_variant_builder_add (&config, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_MTU, val);
 
        /* Send the config info to nm-vpnc-service */
-       send_ip4_config (connection, config);
+       send_ip4_config (connection, g_variant_builder_end (&config));
 
        exit (0);
 }