flimflam: add "psk" security as a way to specify either "wpa" or "rsn"

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 161 matching lines @@
  * If securities are assigned the same priority we fall back to
  * other attributes (e.g. signal strength) to prioritize.
  */
 static int security_priority[CONNMAN_SERVICE_SECURITY_MAX] = {
         [CONNMAN_SERVICE_SECURITY_UNKNOWN]      = 3,
         [CONNMAN_SERVICE_SECURITY_NONE]         = 3,
         [CONNMAN_SERVICE_SECURITY_WEP]          = 2,
         [CONNMAN_SERVICE_SECURITY_WPA]          = 1,
         [CONNMAN_SERVICE_SECURITY_RSN]          = 1,
         [CONNMAN_SERVICE_SECURITY_802_1X]       = 0,
+        [CONNMAN_SERVICE_SECURITY_PSK]          = 1,
 };
 
 static const char *__statename(enum connman_service_state state)
 {
     static const char *statenames[] = {
         [CONNMAN_SERVICE_STATE_UNKNOWN]     = "UNKNOWN",
         [CONNMAN_SERVICE_STATE_IDLE]        = "IDLE",
         [CONNMAN_SERVICE_STATE_CARRIER]     = "CARRIER",
         [CONNMAN_SERVICE_STATE_ASSOCIATION] = "ASSOCIATION",
         [CONNMAN_SERVICE_STATE_CONFIGURATION] = "CONFIGURATION",
@@ skipping 268 matching lines @@
         case CONNMAN_SERVICE_SECURITY_NONE:
                 return "none";
         case CONNMAN_SERVICE_SECURITY_WEP:
                 return "wep";
         case CONNMAN_SERVICE_SECURITY_WPA:
                 return "wpa";
         case CONNMAN_SERVICE_SECURITY_RSN:
                 return "rsn";
         case CONNMAN_SERVICE_SECURITY_802_1X:
                 return "802_1x";
+        case CONNMAN_SERVICE_SECURITY_PSK:
+                return "psk";
         default:
                 break;
         }
 
         return NULL;
 }
 
 const char *connman_service_get_state(const struct connman_service *service)
 {
         switch (service->state) {
@@ skipping 219 matching lines @@
 /*
  * Return TRUE if a passphrase is required to use the service.
  */
 static connman_bool_t is_passphrase_required(
         const struct connman_service *service)
 {
         switch (service->security) {
         case CONNMAN_SERVICE_SECURITY_WEP:
         case CONNMAN_SERVICE_SECURITY_WPA:
         case CONNMAN_SERVICE_SECURITY_RSN:
+        case CONNMAN_SERVICE_SECURITY_PSK:
                 if (service->passphrase == NULL)
                         return TRUE;            /* must have a passphrase */
                 if (service->favorite == TRUE)
                         return FALSE;           /* successfully used before */
                 /* if passphrase was never used, assume it is correct */
                 return is_timeset(&service->last_attempt);
 
         case CONNMAN_SERVICE_SECURITY_802_1X:
                 /*
                  * Passphrases are not mandatory for 802.1x - private
@@ skipping 772 matching lines @@
 
                 dbus_message_iter_get_basic(&value, &passphrase);
 
                 if (service->security == CONNMAN_SERVICE_SECURITY_WEP &&
                     __connman_service_parse_wep_key(passphrase,
                         &service->wifi.wep_key_idx,
                         &service->wifi.wep_key_len,
                         service->wifi.wep_key_matter) == FALSE)
                         return __connman_error_invalid_passphrase(msg);
 
-                if ((service->security == CONNMAN_SERVICE_SECURITY_WPA ||
-                     service->security == CONNMAN_SERVICE_SECURITY_RSN) &&
+
+                if ((service->security == CONNMAN_SERVICE_SECURITY_PSK ||
+                    service->security == CONNMAN_SERVICE_SECURITY_RSN ||
+                    service->security == CONNMAN_SERVICE_SECURITY_WPA) &&
                     __connman_service_validate_passphrase(passphrase) == FALSE)
                         return __connman_error_invalid_passphrase(msg);
 
                 g_free(service->passphrase);
                 service->passphrase = g_strdup(passphrase);
 
                 /*
                  * NB: Reset last attempt since this new
                  * passphrase has never been tried.
                  */
@@ skipping 1691 matching lines @@
         case CONNMAN_SERVICE_TYPE_VPN:
                 break;
         case CONNMAN_SERVICE_TYPE_WIFI:
                 switch (service->security) {
                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
                 case CONNMAN_SERVICE_SECURITY_NONE:
                         break;
                 case CONNMAN_SERVICE_SECURITY_WEP:
                 case CONNMAN_SERVICE_SECURITY_WPA:
                 case CONNMAN_SERVICE_SECURITY_RSN:
+                case CONNMAN_SERVICE_SECURITY_PSK:
                         if (service->passphrase == NULL) {
                                 _DBG_SERVICE("service %p missing passphrase",
                                     service);
                                 return -ENOKEY;
                         }
                         /* TODO(sleffler) validate wep key matter? */
                         break;
                 case CONNMAN_SERVICE_SECURITY_802_1X:
                         if (is_connectable(service) == FALSE)
                                 return -ENOKEY;
@@ skipping 177 matching lines @@
                 g_free(*service_property);
                 /* TODO(sleffler) hack until entd uses ClearProperty */
                 if (value[0] != '\0')
                         *service_property = g_strdup(value);
                 else
                         *service_property = NULL;
                 *modified = TRUE;
         }
 }
 
+static inline gboolean ispsk(const char *security)
+{
+        return (g_strcmp0(security, "wpa") == 0 ||
+                g_strcmp0(security, "rsn") == 0 ||
+                g_strcmp0(security, "psk") == 0);
+}
+
 /**
  * __connman_get_wifi_service_int:
  *
  * Obtain a pointer to a service with the SSID and security type
  * specified in the DBus message, creating one (backed by a
  * hidden-SSID network) if necessary.
  * If a service is created, set its HiddenSSID property to HiddenSSID in
  * DBus message, if present.  If not present, set HiddenSSID = TRUE if
  * set_hidden_ssid == TRUE.
  */
@@ skipping 148 matching lines @@
         }
 
         ssid_len = strlen(ssid);
         if (ssid_len < 1 || ssid_len > MAX_SSID_LENGTH) {
                 connman_error("%s: invalid ssid, len %d", __func__, ssid_len);
                 return __connman_error_invalid_network_name(msg);
         }
 
         if (g_strcmp0(security, "none") != 0 &&
             g_strcmp0(security, "wep") != 0 &&
-            g_strcmp0(security, "wpa") != 0 &&
-            g_strcmp0(security, "rsn") != 0 &&
-            g_strcmp0(security, "802_1x") != 0) {
+            g_strcmp0(security, "802_1x") != 0 &&
+            !ispsk(security)) {
                 connman_error("%s: invalid security %s", __func__, security);
                 return __connman_error_invalid_arguments(msg);
         }
 
         wep_key_idx = -1;
         if (g_strcmp0(security, "wep") == 0 && passphrase != NULL) {
                 connman_uint8_t u8_idx;
                 /* validate any wep key */
                 if (__connman_service_parse_wep_key(passphrase, &u8_idx,
                     &wep_key_len, wep_key_matter) == FALSE)
                         return __connman_error_invalid_passphrase(msg);
                 wep_key_idx = u8_idx;
         }
 
-        if ((g_strcmp0(security, "wpa") == 0 ||
-             g_strcmp0(security, "rsn") == 0) && passphrase != NULL &&
+        if (ispsk(security) && passphrase != NULL &&
             __connman_service_validate_passphrase(passphrase) == FALSE)
                 return __connman_error_invalid_passphrase(msg);
 
         device = __connman_element_find_device(CONNMAN_DEVICE_TYPE_WIFI);
         if (device == NULL) {
                 connman_error("%s: no wifi device", __func__);
                 return __connman_error_invalid_arguments(msg);
         }
 
         ident = __connman_device_get_ident(device);
         if (ident == NULL) {
                 connman_error("%s: no device identifier", __func__);
                 return __connman_error_invalid_arguments(msg);
         }
 
-        group = connman_wifi_build_group_name((unsigned char *) ssid,
-                                                ssid_len, mode, security);
+        group = connman_wifi_build_group_name((unsigned char *) ssid, ssid_len,
+                                              mode, security);
         if (group == NULL) {
                 connman_error("%s: cannot build group name", __func__);
                 return __connman_error_invalid_arguments(msg);
         }
 
         name = g_strdup_printf("%s_%s_%s", type_str, ident, group);
 
         service = __connman_service_lookup(name);
         modified = FALSE;
         created = FALSE;
@@ skipping 524 matching lines @@
 }
 
 static enum connman_service_mode convert_wifi_security(const char *security)
 {
         if (security == NULL)
                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
         else if (g_str_equal(security, "none") == TRUE)
                 return CONNMAN_SERVICE_SECURITY_NONE;
         else if (g_str_equal(security, "wep") == TRUE)
                 return CONNMAN_SERVICE_SECURITY_WEP;
+        else if (g_str_equal(security, "psk") == TRUE)
+                return CONNMAN_SERVICE_SECURITY_PSK;
         else if (g_str_equal(security, "wpa") == TRUE)
                 return CONNMAN_SERVICE_SECURITY_WPA;
         else if (g_str_equal(security, "rsn") == TRUE)
                 return CONNMAN_SERVICE_SECURITY_RSN;
         else if (g_str_equal(security, "802_1x") == TRUE)
                 return CONNMAN_SERVICE_SECURITY_802_1X;
         else
                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
 }
 
@@ skipping 326 matching lines @@
 {
         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);
+        } else if (service->security == CONNMAN_SERVICE_SECURITY_RSN) {
+                group = g_strdup(service->identifier);
+                g_strlcpy(group + strlen(group) - 3, "rsn", 4);
+        }
+        return group;
+}
+
 static int service_load(struct connman_service *service)
 {
         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;
 
@@ skipping 16 matching lines @@
         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;
+                }
+        }
+
         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,
-                                service->identifier, "WiFi.HiddenSSID", NULL);
+                                group, "WiFi.HiddenSSID", NULL);
 
                 if (service->name == NULL) {
                         service->name = g_key_file_get_string(keyfile,
-                                        service->identifier, "Name", NULL);
+                                        group, "Name", NULL);
 
                         if (service->network != NULL && service->name != NULL)
                                 connman_network_set_name(service->network,
                                                 service->name);
                 }
 
                 if (service->network &&
                                 connman_network_get_blob(service->network,
                                         "WiFi.SSID", &ssid_len) == NULL) {
                         gchar *hex_ssid;
 
                         hex_ssid = g_key_file_get_string(keyfile,
-                                                        service->identifier,
-                                                                "SSID", NULL);
+                                                        group, "SSID", NULL);
 
                         if (hex_ssid != NULL) {
                                 struct blob *ssid;
 
                                 err = blob_new_from_hex(&ssid, hex_ssid);
                                 g_free(hex_ssid);
                                 if (err < 0) {
                                         goto done;
                                 }
 
                                 connman_network_set_blob(service->network,
                                         "WiFi.SSID", ssid->data, ssid->len);
 
                                 blob_free(ssid);
                         }
                 }
                 /* fall through */
 
         case CONNMAN_SERVICE_TYPE_WIMAX:
         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
                 str = g_key_file_get_string(keyfile,
-                                            service->identifier,
-                                            "Failure", NULL);
+                                            group, "Failure", NULL);
                 if (str != NULL) {
                         service->error = string2error(str);
                         state_change(service,
                                      CONNMAN_SERVICE_STATE_FAILURE,
                                      FALSE);
                 }
                 /* fall through */
 
         case CONNMAN_SERVICE_TYPE_CELLULAR:
                 service->favorite = g_key_file_get_boolean(keyfile,
-                                service->identifier, "Favorite", NULL);
+                                group, "Favorite", NULL);
 
                 autoconnect = g_key_file_get_boolean(keyfile,
-                                service->identifier, "AutoConnect", &error);
+                                group, "AutoConnect", &error);
                 if (error == NULL)
                         service->autoconnect = autoconnect;
                 g_clear_error(&error);
                 break;
         default:
                 break;
         }
 
         str = g_key_file_get_string(keyfile,
-                                service->identifier, "Modified", NULL);
+                                group, "Modified", NULL);
         if (str != NULL) {
                 g_time_val_from_iso8601(str, &service->modified);
                 g_free(str);
         }
 
         str = g_key_file_get_string(keyfile,
-                                service->identifier, "LastAttempt", NULL);
+                                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,
-            service->identifier, "Passphrase");
+            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,
                             service->wifi.wep_key_matter);
                         break;
                 case CONNMAN_SERVICE_SECURITY_WPA:
                 case CONNMAN_SERVICE_SECURITY_RSN:
+                case CONNMAN_SERVICE_SECURITY_PSK:
                         valid_pass = __connman_service_validate_passphrase(str);
                         break;
                 default:
                         break;
                 }
                 if (valid_pass == TRUE)
                         service->passphrase = str;
                 else
                         g_free(str);
         }
@@ skipping 21 matching lines @@
         populate_service_from_keyfile(keyfile, service,
                  kEAPCACertID, &service->eap.cert_id);
         populate_service_from_keyfile(keyfile, service,
                  kEAPPIN, &service->eap.pin);
         populate_service_from_keyfile(keyfile, service,
                  kEAPPassword, &service->eap.password);
         populate_service_from_keyfile(keyfile, service,
                  kEAPKeyMgmt, &service->eap.key_mgmt);
 
         str = g_key_file_get_string(keyfile,
-                                service->identifier, "ProxyConfig", NULL);
+                                group, "ProxyConfig", NULL);
         if (str != NULL) {
                 g_free(service->proxy_config);
                 service->proxy_config = str;
         }
 
         pri = g_key_file_get_integer(keyfile,
-                                service->identifier, "Priority", &error);
+                                group, "Priority", &error);
         if (error == NULL)
                 service->pri = pri;
 
         apn = &service->cellular.apn;
         g_free(apn->apn);
         g_free(apn->username);
         g_free(apn->password);
         g_free(apn->network_id);
         apn->apn = g_key_file_get_string(keyfile,
-                                service->identifier, "Cellular.APN.apn", NULL);
+                                group, "Cellular.APN.apn", NULL);
         if (apn->apn != NULL) {
                 apn->username = g_key_file_get_string(keyfile,
-                                              service->identifier,
+                                              group,
                                               "Cellular.APN.username", NULL);
                 apn->password = g_key_file_get_string(keyfile,
-                                              service->identifier,
+                                              group,
                                               "Cellular.APN.password", NULL);
                 apn->network_id = g_key_file_get_string(keyfile,
-                                              service->identifier,
+                                              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);
@@ skipping 227 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);
 }