flimflam: add support for multiple profiles

src/service.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 78 matching lines @@
                 char *private_key_passwd;
                 char *key_id;
                 char *ca_cert; /* formerly authpath */
                 char *ca_cert_id;
                 connman_bool_t use_system_cas;
                 char *pin;
                 char *password;
                 char *key_mgmt;
         } eap;
 
-        char *profile;
+        const struct connman_storage_ident *profile;
         char *proxy_config;
 
         /* TODO(sleffler) overlay storage */
         struct {
                 char *operator_name;
                 char *operator_code;
                 char *olp_url;
                 char *usage_url;
                 enum connman_network_activation_state activation_state;
                 enum connman_network_cellular_technology network_technology;
@@ skipping 99 matching lines @@
 static const char* kEAPPrivateKey = "EAP.PrivateKey";
 static const char* kEAPPrivateKeyPassword = "EAP.PrivateKeyPassword";
 static const char* kEAPKeyID = "EAP.KeyID";
 static const char* kEAPCACert = "EAP.CACert";
 static const char* kEAPCACertID = "EAP.CACertID";
 static const char* kEAPUseSystemCAs = "EAP.UseSystemCAs";
 static const char* kEAPPIN = "EAP.PIN";
 static const char* kEAPPassword = "EAP.Password";
 static const char* kEAPKeyMgmt = "EAP.KeyMgmt";
 
+static void service_clear_passphrase(struct connman_service *service);
 static void service_modified(struct connman_service *service);
+static void service_clear_eap(struct connman_service *service);
 static void __service_resort(struct connman_service *service);
+static void set_reconnect_state(struct connman_service *service,
+        connman_bool_t onoff);
 
 static connman_bool_t is_timeset(const GTimeVal *tv)
 {
         return !(tv->tv_sec == 0 && tv->tv_usec == 0);
 }
 
 static void append_path(gpointer value, gpointer user_data)
 {
         struct connman_service *service = value;
         DBusMessageIter *iter = user_data;
@@ skipping 154 matching lines @@
 {
         struct find_data data = { .path = path, .service = NULL };
 
         _DBG_SERVICE("path %s", path);
 
         g_sequence_foreach(service_list, compare_path, &data);
 
         return data.service;
 }
 
+static void invalidate_profile(gpointer value, gpointer user_data)
+{
+        struct connman_service *service = value;
+        const struct connman_storage_ident *profile = user_data;
+
+        if (service->profile == profile) {
+                /*
+                 * Invalidate profile-related data and force a re-load
+                 * the next time the service is to be used (so it can
+                 * come from the active profile).
+                 */
+                service->profile = NULL;
+
+                /*
+                 * network_disconnect may drop the last reference to the
+                 * service and cause it to be freed, so take a reference
+                 * temporarily until we are done with it.
+                 */
+                connman_service_ref(service);
+                /* TODO(sleffler) skip wired ethernet, open auth? */
+                __connman_service_disconnect(service);
+                service_clear_passphrase(service);
+                service_clear_eap(service);
+                connman_service_unref(service);
+        }
+}
+
+void __connman_service_invalidate_profile(const struct connman_storage_ident *ident)
+{
+        _DBG_SERVICE("ident %s/%s", ident->user, ident->ident);
+
+        g_sequence_foreach(service_list, invalidate_profile, (gpointer) ident);
+}
+
 static const char *identifier(struct connman_service *service)
 {
         return service ? service->identifier : "<nil>";
 }
 
 static const char *type2string(enum connman_service_type type)
 {
         switch (type) {
         case CONNMAN_SERVICE_TYPE_UNKNOWN:
                 break;
@@ skipping 349 matching lines @@
 }
 
 static void hidden_ssid_changed(struct connman_service *service)
 {
         if (service->path != NULL)
                 connman_dbus_send_property_changed_variant(service->path,
                     CONNMAN_SERVICE_INTERFACE, "WiFi.HiddenSSID",
                     DBUS_TYPE_BOOLEAN, &service->wifi.hidden_ssid);
 }
 
-/**
- * connman_service_append_hidden_ssids:
- * @hidden_ssids: pointer to a list of hidden SSIDs
- *
- * Append the list of SSIDs whose services whose WiFi.HiddenSSID property is
- * TRUE.  These SSIDs should be directly probed whenever performing a WiFi
- * network scan.
- *
- * Return -EINVAL if profile could not be parsed cleanly
- */
-int connman_service_append_hidden_ssids(GSList **hidden_ssids)
-{
-        const char *ident = __connman_profile_active_ident();
-        GKeyFile *keyfile;
-        gchar **keys;
-        int ret = 0;
-
-        _DBG_SERVICE("ident %s", ident);
-
-        keyfile = __connman_storage_open(ident);
-        if (keyfile == NULL)
-                return -EINVAL;
-
-        keys = g_key_file_get_groups(keyfile, NULL);
-        if (keys == NULL) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        for (; *keys != NULL; keys++) {
-                gchar *key = *keys;
-                gchar *hex_ssid;
-                struct blob *ssid;
-
-                if (g_ascii_strncasecmp(key, "wifi_", 5) != 0)
-                        continue;
-
-                if (!g_key_file_get_boolean(keyfile, key, "WiFi.HiddenSSID",
-                                NULL))
-                        continue;
-
-                hex_ssid = g_key_file_get_string(keyfile, key, "SSID", NULL);
-                if (hex_ssid == NULL)
-                        continue;
-
-                _DBG_SERVICE("service %s", key);
-
-                ret = blob_new_from_hex(&ssid, hex_ssid);
-                g_free(hex_ssid);
-                if (ret < 0)
-                        goto done;
-
-                _DBG_SERVICE("ssid %.*s", ssid->len, ssid->data);
-                *hidden_ssids = g_slist_prepend(*hidden_ssids, ssid);
-        }
-
-done:
-        g_key_file_free(keyfile);
-
-        return ret;
-}
-
 static connman_bool_t is_connectable(const struct connman_service *service)
 {
 
         if (service->security == CONNMAN_SERVICE_SECURITY_802_1X) {
                 /* Identity is required for EAP. */
                 if (service->eap.identity == NULL) {
                         _DBG_SERVICE("NOT CONNECTABLE: identity is NULL");
                         return FALSE;
                 }
 
@@ skipping 616 matching lines @@
 
         if (service->network != NULL)
                 prepare_network_string(service, networkname,
                                        *storage);
 
         if (service->path != NULL)
                 connman_dbus_send_property_changed_variant(service->path,
                         CONNMAN_SERVICE_INTERFACE, servicename,
                         DBUS_TYPE_STRING, storage);
 
-        __connman_storage_save_service(service);
+        service_modified(service);
 
         return NULL;
 }
 
 static void free_apn(struct connman_service *service)
 {
         struct connman_network_apn *apn = &service->cellular.apn;
 
         g_free(apn->apn);
         apn->apn = NULL;
@@ skipping 75 matching lines @@
                                 g_strdup(service->cellular.operator_code);
                 apn->username = g_strdup(username);
                 apn->password = g_strdup(password);
                 /*
                  * Clear the last-good-apn, otherwise the one
                  * the user just set won't be used.
                  */
                 __connman_service_save_last_good_apn(service, NULL);
         }
 
-        __connman_storage_save_service(service);
+        __connman_profile_save_service(service);
         connman_dbus_property_changed_string_dict(service->path,
                                   CONNMAN_SERVICE_INTERFACE,
                                   "Cellular.APN", append_apn, apn);
         return NULL;
 }
 
 static DBusMessage *set_property(DBusConnection *conn,
                                  DBusMessage *msg, void *user_data)
 {
         struct connman_service *service = user_data;
@@ skipping 28 matching lines @@
 
                 dbus_message_iter_get_basic(&value, &hidden_ssid);
 
                 if (service->wifi.hidden_ssid == hidden_ssid)
                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 
                 service->wifi.hidden_ssid = hidden_ssid;
 
                 hidden_ssid_changed(service);
 
-                __connman_storage_save_service(service);
-
+                service_modified(service);
         } else if (g_str_equal(name, "Passphrase") == TRUE) {
                 const char *passphrase;
 
                 if (type != DBUS_TYPE_STRING)
                         return __connman_error_invalid_arguments(msg);
 
                 if (__connman_security_check_privilege(msg,
                                         CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
                         return __connman_error_permission_denied(msg);
 
@@ skipping 21 matching lines @@
                  * passphrase has never been tried.
                  */
                 service->last_attempt.tv_sec = 0;
                 service->last_attempt.tv_usec = 0;
 
                 passphrase_required_changed(service);
 
                 if (service->network != NULL)
                         prepare_network_passphrase(service);
 
-                __connman_storage_save_service(service);
+                service_modified(service);
         } else if (g_str_equal(name, kEAPIdentity) == TRUE) {
                 returnmsg = set_eap_string(service, msg, type, &value,
                         &service->eap.identity,
                         kEAPIdentity, CONNMAN_WIFI_EAP_IDENTITY);
                 if (returnmsg != NULL)
                         return returnmsg;
         } else if (g_str_equal(name, kEAPEAP) == TRUE) {
                 returnmsg = set_eap_string(service, msg, type, &value,
                         &service->eap.eap,
                         kEAPEAP, CONNMAN_WIFI_EAP_EAP);
@@ skipping 66 matching lines @@
                 service->eap.use_system_cas = use_system_cas;
 
                 connman_network_set_uint8(service->network,
                         CONNMAN_WIFI_EAP_USESYSTEMCAS,
                         service->eap.use_system_cas);
 
                 connman_dbus_send_property_changed_variant(service->path,
                         CONNMAN_SERVICE_INTERFACE, kEAPUseSystemCAs,
                         DBUS_TYPE_BOOLEAN, &service->eap.use_system_cas);
 
-                __connman_storage_save_service(service);
+                __connman_profile_save_service(service);
         } else if (g_str_equal(name, kEAPPIN) == TRUE) {
                 returnmsg = set_eap_string(service, msg, type, &value,
                         &service->eap.pin,
                         kEAPPIN, CONNMAN_WIFI_EAP_PIN);
                 if (returnmsg != NULL)
                         return returnmsg;
         } else if (g_str_equal(name, kEAPPassword) == TRUE) {
                 returnmsg = set_eap_string(service, msg, type, &value,
                         &service->eap.password,
                         kEAPPassword, CONNMAN_WIFI_EAP_PASSWORD);
@@ skipping 16 matching lines @@
 
                 dbus_message_iter_get_basic(&value, &autoconnect);
 
                 if (service->autoconnect == autoconnect)
                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 
                 service->autoconnect = autoconnect;
 
                 autoconnect_changed(service);
 
-                __connman_storage_save_service(service);
+                service_modified(service);
         } else if (g_str_equal(name, "ProxyConfig") == TRUE) {
                 const char *proxy_config;
 
                 if (type != DBUS_TYPE_STRING)
                         return __connman_error_invalid_arguments(msg);
 
                 dbus_message_iter_get_basic(&value, &proxy_config);
 
                 g_free(service->proxy_config);
                 service->proxy_config = g_strdup(proxy_config);
 
                 proxy_configuration_changed(service);
 
-                __connman_storage_save_service(service);
+                service_modified(service);
         } else if (g_str_has_prefix(name, "Priority") == TRUE) {
                 int pri;
 
                 if (type != DBUS_TYPE_INT32)
                         return __connman_error_invalid_arguments(msg);
 
                 dbus_message_iter_get_basic(&value, &pri);
 
                 if (!(CONNMAN_SERVICE_PRI_MIN <= pri &&
                     pri <= CONNMAN_SERVICE_PRI_MAX)) {
                         _DBG_SERVICE("service priority %d out of range", pri);
                         return __connman_error_invalid_arguments(msg);
                 }
 
                 if (service->pri != pri) {
                         service->pri = pri;
                         __service_resort(service);
 
                         service_priority_changed(service);
 
-                        __connman_storage_save_service(service);
+                        service_modified(service);
                 }
         } else if (g_str_equal(name, "Cellular.APN") == TRUE) {
                 returnmsg = set_apn_from_property(service, msg, type, &value);
                 if (returnmsg != NULL)
                         return returnmsg;
         } else
                 return __connman_error_invalid_property(msg);
 
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static void state_change(struct connman_service *service,
     enum connman_service_state state, int notify)
 {
         _DBG_SERVICE("service state change (%p) %s -> %s", service,
                 __statename(service->state), __statename(state));
         service->state = state;
         g_get_current_time(&service->last_state[state]);
         if (notify == TRUE)
                 __connman_notifier_service_state_changed(service);
 }
 
 static void set_idle(struct connman_service *service)
 {
         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
         state_change(service, CONNMAN_SERVICE_STATE_IDLE, TRUE);
 }
 
-static void __connman_service_clear_passphrase(struct connman_service *service)
+static void service_clear_passphrase(struct connman_service *service)
 {
         g_free(service->passphrase);
         service->passphrase = NULL;
 
         memset(&service->wifi, 0, sizeof(service->wifi));
+}
+
+static void __connman_service_clear_passphrase(struct connman_service *service)
+{
+        service_clear_passphrase(service);
 
         passphrase_required_changed(service);
 }
 
 static void service_modified(struct connman_service *service)
 {
         g_get_current_time(&service->modified);
-        __connman_storage_save_service(service);
+
+        service->profile = __connman_profile_active_ident();
+        __connman_profile_save_service(service);
 }
 
-void __connman_service_reset(struct connman_service *service)
+static void service_clear_eap(struct connman_service *service)
 {
-        connman_service_set_favorite(service, FALSE);
-        __connman_service_clear_passphrase(service);
-
         g_free(service->eap.identity);
         service->eap.identity = NULL;
 
         g_free(service->eap.eap);
         service->eap.eap = NULL;
 
         g_free(service->eap.inner_eap);
         service->eap.inner_eap = NULL;
 
         g_free(service->eap.anonymous_identity);
@@ skipping 20 matching lines @@
         g_free(service->eap.ca_cert_id);
         service->eap.ca_cert_id = NULL;
 
         service->eap.use_system_cas = TRUE;
 
         g_free(service->eap.pin);
         service->eap.pin = NULL;
 
         g_free(service->eap.password);
         service->eap.password = NULL;
+}
+
+void __connman_service_reset(struct connman_service *service)
+{
+        connman_service_set_favorite(service, FALSE);
+        __connman_service_clear_passphrase(service);
+        service_clear_eap(service);
 
         service_modified(service);
 }
 
 static DBusMessage *clear_property(DBusConnection *conn,
                                         DBusMessage *msg, void *user_data)
 {
         struct connman_service *service = user_data;
         const char *name;
 
@@ skipping 347 matching lines @@
 /*
  * Attempt autoconnect on the device associated with the specified
  * service.  Note this is deferred to the main event loop.
  */
 void connman_service_auto_connect(struct connman_service *service)
 {
         struct connman_device *device = connman_service_get_device(service);
         __connman_service_device_auto_connect(device);
 }
 
+static gboolean auto_connect_any(gpointer data)
+{
+        _DBG_SERVICE("");
+
+        if (__connman_connection_is_online() == FALSE)
+                __auto_connect(NULL, NULL);
+        return FALSE;
+}
+
+/*
+ * Attempt autoconnect on any device, but only if offline.
+ */
+void __connman_service_auto_connect_any(void)
+{
+        g_idle_add(auto_connect_any, NULL);
+}
+
 /**
  * __connman_service_set_activation_state:
  * @service: service structure
  * @activation state: control interface
  * @err: if the activation failed a reason for the failure
  *
  * Set the activation state of the network
  */
 void __connman_service_set_activation_state(struct connman_service *service,
         enum connman_network_activation_state activation_state,
@@ skipping 512 matching lines @@
                 g_dbus_unregister_interface(connection, path,
                                                 CONNMAN_SERVICE_INTERFACE);
                 g_free(path);
         }
 
         if (service->network != NULL)
                 connman_network_unref(service->network);
         if (service->provider != NULL)
                 connman_provider_unref(service->provider);
 
-        g_free(service->profile);
         g_free(service->name);
         g_free(service->passphrase);
         g_free(service->eap.identity);
         g_free(service->eap.eap);
         g_free(service->eap.inner_eap);
         g_free(service->eap.anonymous_identity);
         g_free(service->eap.client_cert);
         g_free(service->eap.cert_id);
         g_free(service->eap.private_key);
         g_free(service->eap.private_key_passwd);
@@ skipping 1069 matching lines @@
 
         /* NB: Set HiddenSSID = FALSE when creating service not in scan list */
         reply = __connman_get_wifi_service_int(msg, &service, &created, FALSE);
         if (reply != NULL)
                 return reply;
         else if (service == NULL)
                 return __connman_error_internal_error(msg);
 
         _DBG_SERVICE("service %p created %d", service, created);
 
-        __connman_storage_save_service(service);
+        service_modified(service);
 
         /*
          * If __connman_get_wifi_service_int created the network object
          * because the service didn't already exist, then we need to
          * get rid of it and the associated service. Removing the network
          * from the device will do this; this will be the only reference
          * to the network and when it's reclaimed the service will also
          * go away because the network layer calls up into the service
          * layer to clear the (unreferenced) pointer.
          */
@@ skipping 26 matching lines @@
         }
 
         service = connman_service_create();
         if (service == NULL)
                 return NULL;
 
         _DBG_SERVICE("service %p", service);
 
         service->identifier = g_strdup(identifier);
 
-        service->profile = g_strdup(__connman_profile_active_ident());
+        service->profile = __connman_profile_active_ident();
 
-        __connman_storage_load_service(service);
+        __connman_profile_load_service(service);
 
         iter = g_sequence_insert_sorted(service_list, service,
                                                 service_compare, NULL);
 
         g_hash_table_insert(service_hash, service->identifier, iter);
 
         return service;
 }
 
 static int service_register(struct connman_service *service)
 {
         const char *path = __connman_profile_active_path();
 
         _DBG_SERVICE("service %p", service);
 
         if (service->path != NULL)
                 return -EALREADY;
 
         service->path = g_strdup_printf("%s/%s", path, service->identifier);
 
         _DBG_SERVICE("path %s", service->path);
 
         g_dbus_register_interface(connection, service->path,
                                         CONNMAN_SERVICE_INTERFACE,
                                         service_methods, service_signals,
                                                         NULL, service, NULL);
 
-        __connman_storage_load_service(service);
+        __connman_profile_load_service(service);
 
         __service_resort(service);
 
         __connman_profile_changed(TRUE);
 
         return 0;
 }
 
 /**
  * __connman_service_lookup_from_device:
@@ skipping 48 matching lines @@
                 __connman_profile_changed(TRUE);
                 return service;
         }
 
         service->type = __connman_device_get_service_type(device);
 
         service->autoconnect = FALSE;
 
         service->device = device;
 
-        __connman_storage_load_service(service);
+        __connman_profile_load_service(service);
 
         service_register(service);
 
         __connman_profile_changed(TRUE);
 
         if (service->favorite == TRUE)
                 connman_service_auto_connect(service);
 
         return service;
 }
@@ skipping 396 matching lines @@
         }
 
         str = connman_network_get_string(network, "WiFi.Mode");
         service->mode = convert_wifi_mode(str);
 
         str = connman_network_get_string(network, "WiFi.Security");
         service->security = convert_wifi_security(str);
 
         update_from_network(service, network, FALSE);
 
-        __connman_storage_load_service(service);
+        __connman_profile_load_service(service);
 
         service_register(service);
 
         __connman_profile_changed(TRUE);
 
         if (service->favorite == TRUE)
                 connman_service_auto_connect(service);
 
         return service;
 }
@@ skipping 187 matching lines @@
                 service->cellular.last_good_apn.apn = g_strdup(apn->apn);
                 service->cellular.last_good_apn.network_id = g_strdup(apn->network_id);
                 service->cellular.last_good_apn.username = g_strdup(apn->username);
                 service->cellular.last_good_apn.password = g_strdup(apn->password);
         } else {
                 service->cellular.last_good_apn.apn = NULL;
                 service->cellular.last_good_apn.network_id = NULL;
                 service->cellular.last_good_apn.username = NULL;
                 service->cellular.last_good_apn.password = NULL;
         }
-        __connman_storage_save_service(service);
+
+        __connman_profile_save_service(service);
 }
 
 static void populate_service_from_keyfile(GKeyFile *keyfile,
                                           struct connman_service *service,
                                           const char *key,
                                           char **storage)
 {
         char *str;
 
         str = g_key_file_get_string(keyfile, service->identifier, key, NULL);
         if (str != NULL) {
                 g_free(*storage);
                 *storage = str;
         }
 }
 
 /*
  * Construct old-style entries for wpa/rsn services.
  */
 static char *__old_security(GKeyFile *keyfile,
     const struct connman_service *service)
 {
         char *group = NULL;
 
         if (service->security == CONNMAN_SERVICE_SECURITY_WPA) {
                 group = g_strdup(service->identifier);
                 g_strlcpy(group + strlen(group) - 3, "wpa", 4);
+                if (g_key_file_has_group(keyfile, group) == FALSE) {
+                        g_free(group);
+                        group = NULL;
+                }
         } else if (service->security == CONNMAN_SERVICE_SECURITY_RSN) {
                 group = g_strdup(service->identifier);
                 g_strlcpy(group + strlen(group) - 3, "rsn", 4);
+                if (g_key_file_has_group(keyfile, group) == FALSE) {
+                        g_free(group);
+                        group = NULL;
+                }
         }
         return group;
 }
 
 static void load_apn(struct connman_service *service,
                      GKeyFile *keyfile,
                      const char *group,
                      struct connman_network_apn *apn,
                      const char *keytag)
 {
@@ skipping 20 matching lines @@
                 apn->password = NULL;
                 apn->network_id = NULL;
         }
 
         g_free(apn_key);
         g_free(username_key);
         g_free(password_key);
         g_free(network_id_key);
 }
 
-static int service_load(struct connman_service *service)
+static int service_load(struct connman_service *service, GKeyFile *keyfile)
 {
-        const char *ident = service->profile;
         const char *group = service->identifier;
-        GKeyFile *keyfile;
         GError *error = NULL;
-        gchar *pathname, *data = NULL;
-        gsize length;
         gchar *str;
         connman_bool_t autoconnect, use_system_cas;
         unsigned int ssid_len;
         struct connman_network_apn *apn;
         int err = 0, pri;
 
         _DBG_SERVICE("service %p", service);
 
-        if (ident == NULL)
-                return -EINVAL;
-
-        pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
-        if (pathname == NULL)
-                return -ENOMEM;
-
-        keyfile = g_key_file_new();
-
-        if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
-                g_free(pathname);
-                return -ENOENT;
-        }
-
-        g_free(pathname);
-
-        if (g_key_file_load_from_data(keyfile, data, length,
-                                                        0, NULL) == FALSE) {
-                g_free(data);
-                return -EILSEQ;
-        }
-
-        g_free(data);
-
-        /*
-         * Handle upgrade of old-style entries for wpa/rsn services.
-         */
-        if (g_key_file_has_group(keyfile, group) == FALSE &&
-            g_str_has_suffix(group, "_psk") == TRUE) {
-                char *old_group = __old_security(keyfile, service);
-                if (old_group != NULL) {
-                        _DBG_SERVICE("check old entry %s", old_group);
-                        group = old_group;
+        if (g_key_file_has_group(keyfile, group) == FALSE) {
+                char *old_group;
+                /*
+                 * Handle upgrade of old-style entries for wpa/rsn services.
+                 */
+                if (g_str_has_suffix(group, "_psk") == FALSE) {
+                        err = -ESRCH;
+                        goto done;
                 }
+                old_group = __old_security(keyfile, service);
+                if (old_group == NULL) {
+                        err = -ESRCH;
+                        goto done;
+                }
+                _DBG_SERVICE("check old entry %s", old_group);
+                group = old_group;
         }
 
         switch (service->type) {
         case CONNMAN_SERVICE_TYPE_UNKNOWN:
         case CONNMAN_SERVICE_TYPE_ETHERNET:
         case CONNMAN_SERVICE_TYPE_VPN:
                 break;
         case CONNMAN_SERVICE_TYPE_WIFI:
                 service->wifi.hidden_ssid = g_key_file_get_boolean(keyfile,
                                 group, "WiFi.HiddenSSID", NULL);
@@ skipping 65 matching lines @@
                 g_free(str);
         }
 
         str = g_key_file_get_string(keyfile,
                                 group, "LastAttempt", NULL);
         if (str != NULL) {
                 g_time_val_from_iso8601(str, &service->last_attempt);
                 g_free(str);
         }
 
-        str = __connman_storage_get_encrypted_value(keyfile, service->profile,
-            group, "Passphrase");
+        str = __connman_storage_get_encrypted_value(keyfile, group,
+            "Passphrase");
         if (str != NULL) {
                 connman_bool_t valid_pass = TRUE;
                 g_free(service->passphrase);
                 service->passphrase = NULL;
 
                 switch (service->security) {
                 case CONNMAN_SERVICE_SECURITY_WEP:
                         valid_pass = __connman_service_parse_wep_key(str,
                             &service->wifi.wep_key_idx,
                             &service->wifi.wep_key_len,
@@ skipping 57 matching lines @@
         pri = g_key_file_get_integer(keyfile,
                                 group, "Priority", &error);
         if (error == NULL)
                 service->pri = pri;
 
         apn = &service->cellular.apn;
         load_apn(service, keyfile, group, &service->cellular.apn, "APN");
         load_apn(service, keyfile, group, &service->cellular.last_good_apn,
                  "LastGoodAPN");
 done:
-        g_key_file_free(keyfile);
-
         if (group != service->identifier)
                 g_free((char *)group);
 
         return err;
 }
 
 static void save_property(GKeyFile *keyfile, struct connman_service *service,
                           const char *key, const char *value)
 {
         if (value != NULL && strlen(value) > 0)
@@ skipping 27 matching lines @@
                                       password_key, NULL);
                 g_key_file_remove_key(keyfile, service->identifier,
                                       network_id_key, NULL);
         }
         g_free(apn_key);
         g_free(username_key);
         g_free(password_key);
         g_free(network_id_key);
 }
 
-static int service_save(struct connman_service *service)
+static int service_save(struct connman_service *service, GKeyFile *keyfile)
 {
-        const char *ident = service->profile;
-        GKeyFile *keyfile;
-        gchar *pathname, *data = NULL;
-        gsize length;
         gchar *str;
-        int err = 0;
 
         _DBG_SERVICE("service %p", service);
 
-        if (ident == NULL)
-                return -EINVAL;
-
-        pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
-        if (pathname == NULL)
-                return -ENOMEM;
-
-        keyfile = g_key_file_new();
-
-        if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
-                goto update;
-
-        if (length > 0) {
-                if (g_key_file_load_from_data(keyfile, data, length,
-                                                        0, NULL) == FALSE)
-                        goto done;
-        }
-
-        g_free(data);
-
-update:
         if (service->name != NULL)
                 g_key_file_set_string(keyfile, service->identifier,
                                                 "Name", service->name);
 
         switch (service->type) {
         case CONNMAN_SERVICE_TYPE_UNKNOWN:
         case CONNMAN_SERVICE_TYPE_ETHERNET:
         case CONNMAN_SERVICE_TYPE_VPN:
                 break;
         case CONNMAN_SERVICE_TYPE_WIFI:
@@ skipping 49 matching lines @@
         if (is_timeset(&service->last_attempt)) {
                 str = g_time_val_to_iso8601(&service->last_attempt);
                 if (str != NULL) {
                         g_key_file_set_string(keyfile, service->identifier,
                                                         "LastAttempt", str);
                         g_free(str);
                 }
         }
 
         if (service->passphrase != NULL && strlen(service->passphrase) > 0) {
-                __connman_storage_set_encrypted_value(keyfile, service->profile,
+                __connman_storage_set_encrypted_value(keyfile, 
                     service->identifier, "Passphrase", service->passphrase);
         } else {
                 g_key_file_remove_key(keyfile, service->identifier,
                                                         "Passphrase", NULL);
         }
 
         save_property(keyfile, service, kEAPIdentity, service->eap.identity);
         save_property(keyfile, service, kEAPEAP, service->eap.eap);
         save_property(keyfile, service, kEAPInnerEAP, service->eap.inner_eap);
         save_property(keyfile, service, kEAPAnonymousIdentity,
@@ skipping 25 matching lines @@
                 g_key_file_set_integer(keyfile, service->identifier,
                                         "Priority", service->pri);
         else
                 g_key_file_remove_key(keyfile, service->identifier,
                                         "Priority", NULL);
 
         save_apn(service, keyfile, &service->cellular.apn, "APN");
         save_apn(service, keyfile, &service->cellular.last_good_apn,
                  "LastGoodAPN");
 
-        data = g_key_file_to_data(keyfile, &length, NULL);
-
-        if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
-                connman_error("Failed to store service information");
-
-done:
-        g_free(data);
-
-        g_key_file_free(keyfile);
-
-        g_free(pathname);
-
-        return err;
+        return 0;
 }
 
 static struct connman_storage service_storage = {
         .name           = "service",
         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
         .service_load   = service_load,
         .service_save   = service_save,
 };
 
 static struct connman_notifier service_notifier = {
@@ skipping 40 matching lines @@
         service_list = NULL;
 
         g_hash_table_destroy(service_hash);
         service_hash = NULL;
 
         connman_storage_unregister(&service_storage);
         connman_notifier_unregister(&service_notifier);
 
         dbus_connection_unref(connection);
 }