flimflam: add support for multiple profiles

src/ipconfig.c

 /*
  *
  *  Connection Manager
  *
  *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  *
@@ skipping 858 matching lines @@
         ipconfig->element.type = etype;
         ipconfig->element.name = g_strdup((gchar *) name); /* XXX __DECONST */
         ipconfig->element.destruct = ipconfig_destruct;
         ipconfig->element.index = index;
 
         ipconfig->tag = tag;
         ipconfig->driver = ipconfig_driver_lookup(type);
 
         ipconfig_list = g_list_append(ipconfig_list, ipconfig);
 
-        __connman_storage_save_ipconfig(ipconfig);
+        __connman_profile_save_ipconfig(ipconfig);
 
         return ipconfig;
 }
 
 struct connman_ipconfig *connman_ipconfig_find(void * tag,
                                                enum connman_ipconfig_type type)
 {
         enum connman_element_type etype = ipconfig_type_to_element_type(type);
         GList *list;
 
@@ skipping 97 matching lines @@
  * @ipconfig: ipconfig instance
  * @parent: parent element
  *
  * Register the ipconfig instance in the element hierarchy as a child of parent.
  */
 int connman_ipconfig_register(struct connman_ipconfig *ipconfig,
     struct connman_element *parent)
 {
         _DBG_IPCONFIG("ipconfig %p parent %p", ipconfig, parent);
 
-        __connman_storage_load_ipconfig(ipconfig);
+        __connman_profile_load_ipconfig(ipconfig);
 
         return connman_element_register(&ipconfig->element, parent);
 }
 
 /**
  * connman_ipconfig_unregister:
  * @ipconfig: ipconfig instance
  *
  * Remove the ipconfig instance from the element hierarchy.
  */
 void connman_ipconfig_unregister(struct connman_ipconfig *ipconfig)
 {
         _DBG_IPCONFIG("ipconfig %p", ipconfig);
 
-        __connman_storage_save_ipconfig(ipconfig);
+        __connman_profile_save_ipconfig(ipconfig);
 
         connman_element_unregister(&ipconfig->element);
 }
 
 struct connman_device  *connman_ipconfig_get_device(struct connman_ipconfig *ipconfig)
 {
         struct connman_element *parent;
 
         parent = ipconfig->element.parent;
         CONNMAN_ASSERT(parent->type == CONNMAN_ELEMENT_TYPE_DEVICE);
@@ skipping 425 matching lines @@
 {
         connman_info("setdomains(%s)", str);
 
         g_strfreev(ipaddr->search_domains);
         /* list of domains is a ,-separated list */
         ipaddr->search_domains = g_strsplit(str, ",", 0);
         ipaddr->mask |= CONNMAN_IPCONFIG_SEARCH;
         ipaddr->smask |= CONNMAN_IPCONFIG_SEARCH;
 }
 
-static int ipconfig_storage_load(struct connman_ipconfig *ipconfig)
+static int ipconfig_storage_load(struct connman_ipconfig *ipconfig,
+    GKeyFile *keyfile)
 {
-        const char *ident = __connman_profile_active_ident();
-        GKeyFile *keyfile;
         gchar *key;
         struct connman_ipaddress *ipaddr = ipconfig->address;
         GError *error;
         char *str;
         gint val;
+        int err = 0;
 
         _DBG_IPCONFIG("ipconfig %p", ipconfig);
 
-        keyfile = __connman_storage_open(ident);
-        if (keyfile == NULL)
-                return 0;
-
         key = g_strdup_printf("ipconfig_%s", ipconfig->element.name);
         if (key == NULL) {
                 connman_error("%s: no memory for identifier", __func__);
+                err = -ENOMEM;
                 goto done;
         }
 
+        if (g_key_file_has_group(keyfile, key) == FALSE) {
+                err = -ESRCH;
+                goto done;
+        }
+
         /* NB: connman_ipconfig_create sets the type */
 
         error = NULL;
         val = g_key_file_get_integer(keyfile, key, "Prefixlen", &error);
         if (error == NULL) {
                 if (!(0 <= val && val <= MAX_PREFIXLEN)) {
                         connman_error("%s: %s", __func__, error->message);
                         goto done;
                 }
                 ipaddr->prefixlen = (unsigned char) val;
@@ skipping 21 matching lines @@
         }
         str = g_key_file_get_string(keyfile, key, "NameServers", NULL);
         if (str != NULL)
                 setdns(ipaddr, str);
         str = g_key_file_get_string(keyfile, key, "SearchDomains", NULL);
         if (str != NULL)
                 setdomains(ipaddr, str);
         /* TODO(sleffler) do consistency checking */
 done:
         g_free(key);
-        __connman_storage_close(ident, keyfile, FALSE);
-        return 0;
+
+        return err;
 }
 
 struct ipconfig_paths {
         const char const **names;
         int maxnames;
         int ix;
 };
 static void enumerate_ipconfig(struct connman_ipconfig *ipconfig, void *arg)
 {
         struct ipconfig_paths *paths = arg;
@@ skipping 31 matching lines @@
 static void set_integer(GKeyFile *keyfile, gchar *key,
     const struct connman_ipaddress *ipaddr, int mask,
     const char *name, int value)
 {
         if (ipaddr->smask & mask)
                 g_key_file_set_integer(keyfile, key, name, value);
         else
                 g_key_file_remove_key(keyfile, key, name, NULL);
 }
 
-static int ipconfig_storage_save(const struct connman_ipconfig *ipconfig)
+static int ipconfig_storage_save(const struct connman_ipconfig *ipconfig,
+    GKeyFile *keyfile)
 {
-        const char *ident = __connman_profile_active_ident();
-        GKeyFile *keyfile;
         gchar *key;
         const struct connman_ipaddress *ipaddr =
             connman_ipconfig_get_ipaddress(ipconfig);
 
         _DBG_IPCONFIG("ipconfig %p", ipconfig);
 
-        keyfile = __connman_storage_open(ident);
-        if (keyfile == NULL)
-                return 0;
-
         key = g_strdup_printf("ipconfig_%s", ipconfig->element.name);
         if (key == NULL) {
                 connman_error("%s: no memory for identifier", __func__);
                 goto done;
         }
 
         /* TODO(sleffler) wrong type */
         g_key_file_set_string(keyfile, key, "Method",
             method2str(ipconfig->element.type));
 
@@ skipping 21 matching lines @@
         }
         if (ipaddr->smask & CONNMAN_IPCONFIG_SEARCH) {
                 gchar *domains = g_strjoinv(",", ipaddr->search_domains);
                 g_key_file_set_string(keyfile, key, "SearchDomains", domains);
                 g_free(domains);
         } else {
                 g_key_file_remove_key(keyfile, key, "SearchDomains", NULL);
         }
 done:
         g_free(key);
-        __connman_storage_close(ident, keyfile, TRUE);
         return 0;
 }
 
 static int ipconfig_storage_remove(const struct connman_ipconfig *ipconfig)
 {
-        const char *ident = __connman_profile_active_ident();
+        const struct connman_storage_ident *ident =
+            __connman_profile_active_ident();
         GKeyFile *keyfile;
         gchar *group;
 
-        _DBG_IPCONFIG("ipconfig %p", ipconfig);
+        _DBG_IPCONFIG("ipconfig %p ident %p", ipconfig, ident);
+
+        if (ident == NULL)
+                return -EINVAL;
 
         keyfile = __connman_storage_open(ident);
         if (keyfile == NULL)
                 return 0;
 
         group = g_strdup_printf("ipconfig_%s", ipconfig->element.name);
         if (group == NULL) {
                 connman_error("%s: no memory for group", __func__);
                 goto done;
         }
@@ skipping 207 matching lines @@
         } else if (g_str_equal(key, "SearchDomains") == TRUE) {
                 if (type != DBUS_TYPE_STRING)
                         return __connman_error_invalid_arguments(msg);
                 if (!ipconfig_isstatic(ipconfig))
                         return __connman_error_not_supported(msg);
                 dbus_message_iter_get_basic(&value, &str);
                 setdomains(ipaddr, str);
         } else
                 return __connman_error_invalid_property(msg);
 
-        __connman_storage_save_ipconfig(ipconfig);
+        __connman_profile_save_ipconfig(ipconfig);
 
         connman_element_update(&ipconfig->element);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *clear_property(DBusConnection *conn, DBusMessage *msg,
     void *data)
 {
         struct connman_ipconfig *ipconfig = data;
@@ skipping 26 matching lines @@
                 mask = CONNMAN_IPCONFIG_DOMAIN;
         else if (g_str_equal(name, "NameServers") == TRUE)
                 mask = CONNMAN_IPCONFIG_DNS;
         else
                 return __connman_error_invalid_property(msg);
 
         ipaddr->smask &= ~mask;
         /* TODO(sleffler) should we leave current state alone? */
         /* NB: no way to record dynamic state (e.g. DHCP dns config) */
         ipaddress_clear(ipaddr, mask);
-        __connman_storage_save_ipconfig(ipconfig);
+        __connman_profile_save_ipconfig(ipconfig);
 
         connman_element_update(&ipconfig->element);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *remove_ipconfig(DBusConnection *conn, DBusMessage *msg,
     void *data)
 {
         struct connman_ipconfig *ipconfig = data;
         struct connman_device *device;
 
         _DBG_IPCONFIG("conn %p", conn);
 
         if (__connman_security_check_privilege(msg,
                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
                 return __connman_error_permission_denied(msg);
 
         device = connman_ipconfig_get_device(ipconfig);
         /* TODO(sleffler) expand storage api? */
         /* NB: must be done before in-memory state is reclaimed */
         ipconfig_storage_remove(ipconfig);
         __connman_device_remove_ipconfig(device, ipconfig);
-        __connman_storage_save_device(device);
+        __connman_profile_save_device(device);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *move_ipconfig(struct connman_ipconfig *ipconfig,
     DBusMessage *msg, connman_bool_t before)
 {
         struct connman_ipconfig *target;
         struct connman_device *device;
         const char *path;
 
         _DBG_IPCONFIG("ipconfig %p %s", ipconfig, before ? "before" : "after");
 
         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
                                                         DBUS_TYPE_INVALID);
 
         target = ipconfig_find(path);
         if (target == NULL || target == ipconfig)
                 return __connman_error_invalid_ipconfig(msg);
 
         _DBG_IPCONFIG("target %p", target);
 
         device = connman_ipconfig_get_device(ipconfig);
         ipconfig_move(ipconfig, target, before ? 0 : 1);
-        __connman_storage_save_device(device);
+        __connman_profile_save_device(device);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *move_before(DBusConnection *conn, DBusMessage *msg,
     void *user_data)
 {
         struct connman_ipconfig *ipconfig = user_data;
 
         return move_ipconfig(ipconfig, msg, TRUE);
@@ skipping 182 matching lines @@
 {
         GSList *list;
 
         for (list = driver_list; list != NULL; list = list->next) {
                 const struct connman_ipconfig_driver *driver = list->data;
                 if (driver->type == type)
                         return driver;
         }
         return NULL;
 }