flimflam: add support for multiple profiles

src/device.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 232 matching lines @@
         if (ipconfig == NULL) {
                 connman_error("%s: failed to create %s ipconfig for %s",
                     __func__, type2string(type), device->name);
                 return NULL;
         }
         /* ipconfig's are children of the device */
         /* TODO(sleffler) check return value */
         connman_ipconfig_register(ipconfig, &device->element);
         device->configmask |= 1<<(ix-1);
 
-        __connman_storage_save_device(device);
+        __connman_profile_save_device(device);
 
         return ipconfig;
 }
 
 /**
  * set_connected
  * @device: connman device that is now (dis)connected
  * @connected: is device connected or disconnected
  *
  * Returns: %0 on success
@@ skipping 354 matching lines @@
                 int type, err;
 
                 type = dbus_message_iter_get_arg_type(&value);
                 if (type != DBUS_TYPE_BOOLEAN)
                         return __connman_error_invalid_arguments(msg);
 
                 dbus_message_iter_get_basic(&value, &powered);
 
                 device->powered_persistent = powered;
 
-                __connman_storage_save_device(device);
+                __connman_profile_save_device(device);
 
                 if (device->powered == powered)
                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 
                 if (device->pending != NULL)
                         return __connman_error_in_progress(msg);
 
                 err = set_powered(device, powered);
                 if (err < 0) {
                         if (err != -EINPROGRESS)
                                 return __connman_error_failed(msg, -err);
 
                         device->pending = dbus_message_ref(msg);
 
                         device->timeout = g_timeout_add_seconds(15,
                                                 powered_timeout, device);
 
                         return NULL;
                 }
         } else if (g_str_equal(name, "ScanInterval") == TRUE) {
                 connman_uint16_t interval;
 
                 if (!check_bgscan_parameter(device, &value, DBUS_TYPE_UINT16))
                         return __connman_error_invalid_arguments(msg);
                 dbus_message_iter_get_basic(&value, &interval);
 
                 if (device->scan_interval != interval) {
                         device->scan_interval = interval;
                         device->scan_parameters_nondefault = TRUE;
-                        __connman_storage_save_device(device);
+                        __connman_profile_save_device(device);
                         connman_element_update(&device->element);
 
                         if (device->scan_timeout != 0)
                                 bgscan_enable(device);
                 }
         } else if (g_str_equal(name, "BgscanMethod") == TRUE) {
                 const char *method;
 
                 if (!check_bgscan_parameter(device, &value, DBUS_TYPE_STRING))
                         return __connman_error_invalid_arguments(msg);
                 dbus_message_iter_get_basic(&value, &method);
 
                 if (g_strcmp0(method, device->scan_method) != 0) {
                         g_free(device->scan_method);
                         device->scan_method = g_strdup(method);
                         device->scan_parameters_nondefault = TRUE;
-                        __connman_storage_save_device(device);
+                        __connman_profile_save_device(device);
                         connman_element_update(&device->element);
                 }
         } else if (g_str_equal(name, "BgscanShortInterval") == TRUE) {
                 connman_uint16_t interval;
 
                 if (!check_bgscan_parameter(device, &value, DBUS_TYPE_UINT16))
                         return __connman_error_invalid_arguments(msg);
                 dbus_message_iter_get_basic(&value, &interval);
 
                 if (device->scan_short != interval) {
                         device->scan_short = interval;
                         device->scan_parameters_nondefault = TRUE;
-                        __connman_storage_save_device(device);
+                        __connman_profile_save_device(device);
                         connman_element_update(&device->element);
                 }
         } else if (g_str_equal(name, "BgscanSignalThreshold") == TRUE) {
                 int threshold;
 
                 if (!check_bgscan_parameter(device, &value, DBUS_TYPE_INT32))
                         return __connman_error_invalid_arguments(msg);
                 dbus_message_iter_get_basic(&value, &threshold);
 
                 if (device->signal_threshold != threshold) {
                         device->signal_threshold = threshold;
                         device->scan_parameters_nondefault = TRUE;
-                        __connman_storage_save_device(device);
+                        __connman_profile_save_device(device);
                         connman_element_update(&device->element);
                 }
         } else
                 return __connman_error_invalid_property(msg);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *propose_scan(DBusConnection *conn, DBusMessage *msg,
     void *data)
@@ skipping 804 matching lines @@
 
         return set_powered(device, TRUE);
 }
 
 int __connman_device_enable_persistent(struct connman_device *device)
 {
         _DBG_DEVICE("device %p", device);
 
         device->powered_persistent = TRUE;
 
-        __connman_storage_save_device(device);
+        __connman_profile_save_device(device);
 
         return __connman_device_enable(device);
 }
 
 int __connman_device_disable(struct connman_device *device)
 {
         _DBG_DEVICE("device %p", device);
 
         if (device->driver == NULL || device->driver->disable == NULL)
                 return -EOPNOTSUPP;
         if (device->powered == FALSE)
                 return -ENOLINK;
 
         return set_powered(device, FALSE);
 }
 
 int __connman_device_disable_persistent(struct connman_device *device)
 {
         _DBG_DEVICE("device %p", device);
 
         device->powered_persistent = FALSE;
 
-        __connman_storage_save_device(device);
+        __connman_profile_save_device(device);
 
         return __connman_device_disable(device);
 }
 
 int __connman_device_connect(struct connman_device *device)
 {
         _DBG_DEVICE("device %p", device);
 
         if (device->connected == TRUE)
                 return -EALREADY;
@@ skipping 478 matching lines @@
 /**
  * connman_device_register:
  * @device: device structure
  *
  * Register device with the system
  */
 int connman_device_register(struct connman_device *device)
 {
         _DBG_DEVICE("device %p", device);
 
-        __connman_storage_load_device(device);
+        __connman_profile_load_device(device);
 
         device->offlinemode = __connman_profile_get_offlinemode();
 
         return connman_element_register(&device->element, NULL);
 }
 
 /**
  * connman_device_unregister:
  * @device: device structure
  *
  * Unregister device with the system
  */
 void connman_device_unregister(struct connman_device *device)
 {
         _DBG_DEVICE("device %p", device);
 
-        __connman_storage_save_device(device);
+        __connman_profile_save_device(device);
 
         connman_element_unregister(&device->element);
 }
 
 /**
  * connman_device_get_data:
  * @device: device structure
  *
  * Get private device data pointer
  */
@@ skipping 110 matching lines @@
                 if (ipconfig == NULL) {
                         connman_error("%s: invalid ipconfig type %s (%d)",
                             __func__, str, type);
                         return FALSE;
                 }
                 device->configmask |= 1<<ix;
         }
         return TRUE;
 }
 
-static int device_load(struct connman_device *device)
+static int device_load(struct connman_device *device, GKeyFile *keyfile)
 {
-        const char *ident = __connman_profile_active_ident();
-        GKeyFile *keyfile;
         GError *error = NULL;
         gchar *identifier;
         gchar *method;
         connman_bool_t powered;
         int val;
         gchar **configs;
         gsize nconfigs;
+        int err = 0;
 
         _DBG_DEVICE("device %p", device);
 
-        keyfile = __connman_storage_open(ident);
-        if (keyfile == NULL)
-                return 0;
+        identifier = g_strdup_printf("device_%s", device->element.name);
+        if (identifier == NULL) {
+                err = -ENOMEM;
+                goto done;
+        }
 
-        identifier = g_strdup_printf("device_%s", device->element.name);
-        if (identifier == NULL)
+        if (g_key_file_has_group(keyfile, identifier) == FALSE) {
+                err = -ESRCH;
                 goto done;
+        }
 
         powered = g_key_file_get_boolean(keyfile, identifier,
                                                 "Powered", &error);
         if (error == NULL)
                 device->powered_persistent = powered;
         g_clear_error(&error);
 
         switch (device->mode) {
         case CONNMAN_DEVICE_MODE_UNKNOWN:
         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
@@ skipping 34 matching lines @@
 
         configs = g_key_file_get_string_list(keyfile, identifier, "IPConfigs",
             &nconfigs, &error);
         if (error == NULL && configs != NULL)
                 device_load_ipconfigs(device, nconfigs, configs);
         g_strfreev(configs);
         g_clear_error(&error);
 done:
         g_free(identifier);
 
-        __connman_storage_close(ident, keyfile, FALSE);
-
-        return 0;
+        return err;
 }
 
-static int device_save(struct connman_device *device)
+static int device_save(struct connman_device *device, GKeyFile *keyfile)
 {
-        const char *ident = __connman_profile_active_ident();
-        GKeyFile *keyfile;
         gchar *identifier;
         const char const *paths[32];
         int npaths;
         int i;
 
         _DBG_DEVICE("device %p", device);
 
-        keyfile = __connman_storage_open(ident);
-        if (keyfile == NULL)
-                return 0;
-
         identifier = g_strdup_printf("device_%s", device->element.name);
         if (identifier == NULL)
                 goto done;
 
         g_key_file_set_boolean(keyfile, identifier,
                                         "Powered", device->powered_persistent);
         switch (device->mode) {
         case CONNMAN_DEVICE_MODE_UNKNOWN:
         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
                 break;
@@ skipping 18 matching lines @@
         }
 
         __connman_ipconfig_get_keys(device, 32, paths, &npaths);
         g_key_file_set_string_list(keyfile, identifier, "IPConfigs",
             paths, npaths);
         for (i = 0; i < npaths; i++)
                 g_free((gpointer)paths[i]);
 done:
         g_free(identifier);
 
-        __connman_storage_close(ident, keyfile, TRUE);
-
         return 0;
 }
 
 static struct connman_storage device_storage = {
         .name           = "device",
         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
         .device_load    = device_load,
         .device_save    = device_save,
 };
 
 int __connman_device_init(void)
 {
         /* TODO(sleffler) check return values */
         connection = connman_dbus_get_connection();
         if (connman_storage_register(&device_storage) < 0)
                 connman_error("%s: failed to register storage", __func__);
         return connman_driver_register(&device_driver);
 }
 
 void __connman_device_cleanup(void)
 {
         connman_driver_unregister(&device_driver);
         connman_storage_unregister(&device_storage);
         dbus_connection_unref(connection);
 }