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 77 matching lines @@
                 char *private_key;
                 char *private_key_passwd;
                 char *key_id;
                 char *ca_cert; /* formerly authpath */
                 char *ca_cert_id;
                 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 97 matching lines @@
 static const char* kEAPCertID = "EAP.CertID";
 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* 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.
+                 */
+                set_reconnect_state(service, FALSE);
+                connman_service_ref(service);
+                __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 361 matching lines @@
  * @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();
+        const struct connman_storage_ident *ident =
+            __connman_profile_active_ident();
         GKeyFile *keyfile;
         gchar **keys;
         int ret = 0;
 
-        _DBG_SERVICE("ident %s", ident);
+        _DBG_SERVICE("ident %s:%s", ident->user, ident->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;
         }
@@ skipping 19 matching lines @@
                 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);
+        __connman_storage_close(ident, keyfile, FALSE);
 
         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) {
@@ skipping 598 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 DBusMessage *set_property(DBusConnection *conn,
                                         DBusMessage *msg, void *user_data)
 {
         struct connman_service *service = user_data;
         DBusMessageIter iter, value;
         DBusMessage *returnmsg;
@@ skipping 26 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 84 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
                 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 18 matching lines @@
         service->eap.ca_cert = NULL;
 
         g_free(service->eap.ca_cert_id);
         service->eap.ca_cert_id = NULL;
 
         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 887 matching lines @@
         if (apn != NULL) {
                 apn_info->apn = g_strdup(apn);
                 if (network_id != NULL)
                         apn_info->network_id = g_strdup(network_id);
                 if (username != NULL)
                         apn_info->username = g_strdup(username);
                 if (password != NULL)
                         apn_info->password = g_strdup(password);
         }
 
-        __connman_storage_save_service(service);
+        service_modified(service);
         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static GDBusMethodTable service_methods[] = {
         { "GetProperties", "",   "a{sv}", get_properties     },
         { "SetProperty",   "sv", "",      set_property       },
         { "ClearProperty", "s",  "",      clear_property     },
         { "Connect",       "",   "",      connect_service,   },
         { "Disconnect",    "",   "",      disconnect_service },
         { "Remove",        "",   "",      remove_service     },
@@ skipping 33 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 1047 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 381 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 181 matching lines @@
  * 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 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;
         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 70 matching lines @@
                                               "Cellular.APN.password", NULL);
                 apn->network_id = g_key_file_get_string(keyfile,
                                               group,
                                               "Cellular.APN.network_id", NULL);
         } else {
                 apn->username = NULL;
                 apn->password = NULL;
                 apn->network_id = NULL;
         }
 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)
                 g_key_file_set_string(keyfile, service->identifier, key, value);
         else
                 g_key_file_remove_key(keyfile, service->identifier, key, NULL);
 }
 
-static int service_save(struct connman_service *service)
+static int service_save(struct connman_service *service, GKeyFile *keyfile)
 {
-        const char *ident = service->profile;
         struct connman_network_apn *apn = &service->cellular.apn;
-        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 39 matching lines @@
                 g_key_file_remove_key(keyfile, service->identifier,
                                       "Cellular.APN.apn", NULL);
                 g_key_file_remove_key(keyfile, service->identifier,
                                       "Cellular.APN.username", NULL);
                 g_key_file_remove_key(keyfile, service->identifier,
                                       "Cellular.APN.password", NULL);
                 g_key_file_remove_key(keyfile, service->identifier,
                                       "Cellular.APN.network_id", NULL);
         }
 
-        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);
 }