X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fconfig.c;h=5363dc3eac699cfc1fadc89cfc5fb85edcc98bea;hb=c189a9ab8a085447b775c7fbeb0a8050751b7f84;hp=9dd0911549557f14cc2dc055c401e1e0349407b5;hpb=809fcb417e4b3781b31ddf22fe548f14d15fbb36;p=framework%2Fconnectivity%2Fconnman.git

diff --git a/src/config.c b/src/config.c
index 9dd0911..5363dc3 100644
--- a/src/config.c
+++ b/src/config.c
@@ -2,7 +2,7 @@
  *
  *  Connection Manager
  *
- *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2007-2012  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
@@ -23,6 +23,7 @@
 #include <config.h>
 #endif
 
+#include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
@@ -47,25 +48,34 @@ struct connman_config_service {
 	char *private_key_passphrase_type;
 	char *phase2;
 	char *passphrase;
+	GSList *service_identifiers;
+	char *config_ident; /* file prefix */
+	char *config_entry; /* entry name */
 };
 
 struct connman_config {
 	char *ident;
 	char *name;
 	char *description;
+	connman_bool_t protected;
 	GHashTable *service_table;
 };
 
 static GHashTable *config_table = NULL;
+static GSList *protected_services = NULL;
 
 static int inotify_wd = -1;
 
 static GIOChannel *inotify_channel = NULL;
 static uint inotify_watch = 0;
+static connman_bool_t cleanup = FALSE;
+
+#define INTERNAL_CONFIG_PREFIX           "__internal"
 
 /* Definition of possible strings in the .config files */
 #define CONFIG_KEY_NAME                "Name"
 #define CONFIG_KEY_DESC                "Description"
+#define CONFIG_KEY_PROT                "Protected"
 
 #define SERVICE_KEY_TYPE               "Type"
 #define SERVICE_KEY_NAME               "Name"
@@ -83,6 +93,7 @@ static uint inotify_watch = 0;
 static const char *config_possible_keys[] = {
 	CONFIG_KEY_NAME,
 	CONFIG_KEY_DESC,
+	CONFIG_KEY_PROT,
 	NULL,
 };
 
@@ -118,24 +129,53 @@ static void unregister_config(gpointer data)
 
 static void unregister_service(gpointer data)
 {
-	struct connman_config_service *service = data;
-
-	connman_info("Removing service configuration %s", service->ident);
-
-	g_free(service->ident);
-	g_free(service->type);
-	g_free(service->name);
-	g_free(service->ssid);
-	g_free(service->eap);
-	g_free(service->identity);
-	g_free(service->ca_cert_file);
-	g_free(service->client_cert_file);
-	g_free(service->private_key_file);
-	g_free(service->private_key_passphrase);
-	g_free(service->private_key_passphrase_type);
-	g_free(service->phase2);
-	g_free(service->passphrase);
-	g_free(service);
+	struct connman_config_service *config_service = data;
+	struct connman_service *service;
+	char *service_id;
+	GSList *list;
+
+	if (cleanup == TRUE)
+		goto free_only;
+
+	connman_info("Removing service configuration %s",
+						config_service->ident);
+
+	protected_services = g_slist_remove(protected_services,
+						config_service);
+
+	for (list = config_service->service_identifiers; list != NULL;
+							list = list->next) {
+		service_id = list->data;
+
+		service = __connman_service_lookup_from_ident(service_id);
+		if (service != NULL) {
+			__connman_service_set_immutable(service, FALSE);
+			__connman_service_remove(service);
+		}
+
+		if (__connman_storage_remove_service(service_id) == FALSE)
+			DBG("Could not remove all files for service %s",
+								service_id);
+	}
+
+free_only:
+	g_free(config_service->ident);
+	g_free(config_service->type);
+	g_free(config_service->name);
+	g_free(config_service->ssid);
+	g_free(config_service->eap);
+	g_free(config_service->identity);
+	g_free(config_service->ca_cert_file);
+	g_free(config_service->client_cert_file);
+	g_free(config_service->private_key_file);
+	g_free(config_service->private_key_passphrase);
+	g_free(config_service->private_key_passphrase_type);
+	g_free(config_service->phase2);
+	g_free(config_service->passphrase);
+	g_slist_free_full(config_service->service_identifiers, g_free);
+	g_free(config_service->config_ident);
+	g_free(config_service->config_entry);
+	g_free(config_service);
 }
 
 static void check_keys(GKeyFile *keyfile, const char *group,
@@ -165,12 +205,42 @@ static void check_keys(GKeyFile *keyfile, const char *group,
 	g_strfreev(avail_keys);
 }
 
+static connman_bool_t
+is_protected_service(struct connman_config_service *service)
+{
+	GSList *list;
+
+	DBG("ident %s", service->ident);
+
+	for (list = protected_services; list; list = list->next) {
+		struct connman_config_service *s = list->data;
+
+		if (g_strcmp0(s->type, service->type) != 0)
+			continue;
+
+		if (s->ssid == NULL || service->ssid == NULL)
+			continue;
+
+		if (s->ssid_len != service->ssid_len)
+			continue;
+
+		if (g_strcmp0(service->type, "wifi") == 0 &&
+			strncmp(s->ssid, service->ssid, s->ssid_len) == 0) {
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
 static int load_service(GKeyFile *keyfile, const char *group,
 						struct connman_config *config)
 {
 	struct connman_config_service *service;
 	const char *ident;
 	char *str, *hex_ssid;
+	gboolean service_created = FALSE;
+	int err;
 
 	/* Strip off "service_" prefix */
 	ident = group + 8;
@@ -188,6 +258,8 @@ static int load_service(GKeyFile *keyfile, const char *group,
 			return -ENOMEM;
 
 		service->ident = g_strdup(ident);
+
+		service_created = TRUE;
 	}
 
 	str = g_key_file_get_string(keyfile, group, SERVICE_KEY_TYPE, NULL);
@@ -211,12 +283,19 @@ static int load_service(GKeyFile *keyfile, const char *group,
 
 		ssid = g_try_malloc0(hex_ssid_len / 2);
 		if (ssid == NULL) {
+			err = -ENOMEM;
 			g_free(hex_ssid);
-			return -ENOMEM;
+			goto err;
 		}
 
 		for (i = 0; i < hex_ssid_len; i += 2) {
-			sscanf(hex_ssid + i, "%02x", &hex);
+			if (sscanf(hex_ssid + i, "%02x", &hex) <= 0) {
+				connman_warn("Invalid SSID %s", hex_ssid);
+				g_free(ssid);
+				g_free(hex_ssid);
+				err = -EILSEQ;
+				goto err;
+			}
 			ssid[j++] = hex;
 		}
 
@@ -231,8 +310,10 @@ static int load_service(GKeyFile *keyfile, const char *group,
 
 		ssid_len = strlen(service->name);
 		ssid = g_try_malloc0(ssid_len);
-		if (ssid == NULL)
-			return -ENOMEM;
+		if (ssid == NULL) {
+			err = -ENOMEM;
+			goto err;
+		}
 
 		memcpy(ssid, service->name, ssid_len);
 		g_free(service->ssid);
@@ -240,6 +321,12 @@ static int load_service(GKeyFile *keyfile, const char *group,
 		service->ssid_len = ssid_len;
 	}
 
+	if (is_protected_service(service) == TRUE) {
+		connman_error("Trying to provision a protected service");
+		err = -EACCES;
+		goto err;
+	}
+
 	str = g_key_file_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
 	if (str != NULL) {
 		g_free(service->eap);
@@ -297,24 +384,46 @@ static int load_service(GKeyFile *keyfile, const char *group,
 		service->passphrase = str;
 	}
 
-	g_hash_table_replace(config->service_table, service->ident, service);
+	service->config_ident = g_strdup(config->ident);
+	service->config_entry = g_strdup_printf("service_%s", service->ident);
+
+	if (service_created)
+		g_hash_table_insert(config->service_table, service->ident,
+					service);
+
+	if (config->protected == TRUE)
+		protected_services =
+			g_slist_append(protected_services, service);
 
 	connman_info("Adding service configuration %s", service->ident);
 
 	return 0;
+
+err:
+	if (service_created == TRUE) {
+		g_free(service->ident);
+		g_free(service->type);
+		g_free(service->name);
+		g_free(service->ssid);
+		g_free(service);
+	}
+
+	return err;
 }
 
 static int load_config(struct connman_config *config)
 {
 	GKeyFile *keyfile;
+	GError *error = NULL;
 	gsize length;
 	char **groups;
 	char *str;
+	gboolean protected, found = FALSE;
 	int i;
 
 	DBG("config %p", config);
 
-	keyfile = __connman_storage_open_config(config->ident);
+	keyfile = __connman_storage_load_config(config->ident);
 	if (keyfile == NULL)
 		return -EIO;
 
@@ -333,16 +442,30 @@ static int load_config(struct connman_config *config)
 		config->description = str;
 	}
 
+	protected = g_key_file_get_boolean(keyfile, "global",
+					CONFIG_KEY_PROT, &error);
+	if (error == NULL)
+		config->protected = protected;
+	else
+		config->protected = TRUE;
+
 	groups = g_key_file_get_groups(keyfile, &length);
 
 	for (i = 0; groups[i] != NULL; i++) {
-		if (g_str_has_prefix(groups[i], "service_") == TRUE)
-			load_service(keyfile, groups[i], config);
+		if (g_str_has_prefix(groups[i], "service_") == TRUE) {
+			if (load_service(keyfile, groups[i], config) == 0)
+				found = TRUE;
+		}
 	}
 
+	if (found == FALSE)
+		connman_warn("Config file %s/%s.config does not contain any "
+			"configuration that can be provisioned!",
+			STORAGEDIR, config->ident);
+
 	g_strfreev(groups);
 
-	__connman_storage_close_config(config->ident, keyfile, FALSE);
+	g_key_file_free(keyfile);
 
 	return 0;
 }
@@ -372,6 +495,20 @@ static struct connman_config *create_config(const char *ident)
 	return config;
 }
 
+static connman_bool_t validate_ident(const char *ident)
+{
+	unsigned int i;
+
+	if (ident == NULL)
+		return FALSE;
+
+	for (i = 0; i < strlen(ident); i++)
+		if (g_ascii_isprint(ident[i]) == FALSE)
+			return FALSE;
+
+	return TRUE;
+}
+
 static int read_configs(void)
 {
 	GDir *dir;
@@ -399,12 +536,14 @@ static int read_configs(void)
 
 			ident = g_string_free(str, FALSE);
 
-			if (connman_dbus_validate_ident(ident) == TRUE) {
+			if (validate_ident(ident) == TRUE) {
 				struct connman_config *config;
 
 				config = create_config(ident);
 				if (config != NULL)
 					load_config(config);
+			} else {
+				connman_error("Invalid config ident %s", ident);
 			}
 			g_free(ident);
 		}
@@ -421,20 +560,22 @@ static gboolean inotify_data(GIOChannel *channel, GIOCondition cond,
 	char buffer[256];
 	char *next_event;
 	gsize bytes_read;
-	GIOError err;
+	GIOStatus status;
 
 	if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 		inotify_watch = 0;
 		return FALSE;
 	}
 
-	err = g_io_channel_read(channel, buffer,
-					sizeof(buffer) - 1, &bytes_read);
-
-	if (err != G_IO_ERROR_NONE) {
-		if (err == G_IO_ERROR_AGAIN)
-			return TRUE;
+	status = g_io_channel_read_chars(channel, buffer,
+					sizeof(buffer) -1, &bytes_read, NULL);
 
+	switch (status) {
+	case G_IO_STATUS_NORMAL:
+		break;
+	case G_IO_STATUS_AGAIN:
+		return TRUE;
+	default:
 		connman_error("Reading from inotify channel failed");
 		inotify_watch = 0;
 		return FALSE;
@@ -475,8 +616,10 @@ static gboolean inotify_data(GIOChannel *channel, GIOCondition cond,
 
 		*ext = '\0';
 
-		if (connman_dbus_validate_ident(ident) == FALSE)
+		if (validate_ident(ident) == FALSE) {
+			connman_error("Invalid config ident %s", ident);
 			continue;
+		}
 
 		if (event->mask & IN_CREATE)
 			create_config(ident);
@@ -486,8 +629,20 @@ static gboolean inotify_data(GIOChannel *channel, GIOCondition cond,
 
 			config = g_hash_table_lookup(config_table, ident);
 			if (config != NULL) {
+				int ret;
+
 				g_hash_table_remove_all(config->service_table);
 				load_config(config);
+				ret = __connman_service_provision_changed(ident);
+				if (ret > 0) {
+					/*
+					 * Re-scan the config file for any
+					 * changes
+					 */
+					g_hash_table_remove_all(config->service_table);
+					load_config(config);
+					__connman_service_provision_changed(ident);
+				}
 			}
 		}
 
@@ -573,10 +728,14 @@ void __connman_config_cleanup(void)
 {
 	DBG("");
 
+	cleanup = TRUE;
+
 	remove_watch();
 
 	g_hash_table_destroy(config_table);
 	config_table = NULL;
+
+	cleanup = FALSE;
 }
 
 static char *config_pem_fsid(const char *pem_file)
@@ -604,7 +763,7 @@ static void provision_service(gpointer key, gpointer value, gpointer user_data)
 	struct connman_service *service = user_data;
 	struct connman_config_service *config = value;
 	struct connman_network *network;
-	const void *ssid;
+	const void *ssid, *service_id;
 	unsigned int ssid_len;
 
 	/* For now only WiFi service entries are supported */
@@ -629,8 +788,17 @@ static void provision_service(gpointer key, gpointer value, gpointer user_data)
 	if (memcmp(config->ssid, ssid, ssid_len) != 0)
 		return;
 
+	service_id = __connman_service_get_ident(service);
+	config->service_identifiers =
+		g_slist_prepend(config->service_identifiers,
+				g_strdup(service_id));
+
 	__connman_service_set_immutable(service, TRUE);
-	__connman_service_set_favorite(service, TRUE);
+
+	__connman_service_set_favorite_delayed(service, TRUE, TRUE);
+
+	__connman_service_set_config(service, config->config_ident,
+						config->config_entry);
 
 	if (config->eap != NULL)
 		__connman_service_set_string(service, "EAP", config->eap);
@@ -680,6 +848,10 @@ static void provision_service(gpointer key, gpointer value, gpointer user_data)
 
 	if (config->passphrase != NULL)
 		__connman_service_set_string(service, "Passphrase", config->passphrase);
+
+	__connman_service_mark_dirty();
+
+	__connman_service_save(service);
 }
 
 int __connman_config_provision_service(struct connman_service *service)
@@ -706,3 +878,63 @@ int __connman_config_provision_service(struct connman_service *service)
 
 	return 0;
 }
+
+int __connman_config_provision_service_ident(struct connman_service *service,
+			const char *ident, const char *file, const char *entry)
+{
+	enum connman_service_type type;
+	struct connman_config *config;
+	int ret = 0;
+
+	DBG("service %p", service);
+
+	/* For now only WiFi services are supported */
+	type = connman_service_get_type(service);
+	if (type != CONNMAN_SERVICE_TYPE_WIFI)
+		return -ENOSYS;
+
+	config = g_hash_table_lookup(config_table, ident);
+	if(config != NULL) {
+		GHashTableIter iter;
+		gpointer value, key;
+		gboolean found = FALSE;
+
+		g_hash_table_iter_init(&iter, config->service_table);
+
+		/*
+		 * Check if we need to remove individual service if it
+		 * is missing from config file.
+		 */
+		if (file != NULL && entry != NULL) {
+			while (g_hash_table_iter_next(&iter, &key,
+							&value) == TRUE) {
+				struct connman_config_service *config = value;
+
+				if (g_strcmp0(config->config_ident,
+								file) == 0 &&
+						g_strcmp0(config->config_entry,
+								entry) == 0) {
+					found = TRUE;
+					break;
+				}
+			}
+
+			DBG("found %d ident %s file %s entry %s", found, ident,
+								file, entry);
+
+			if (found == FALSE) {
+				/*
+				 * The entry+8 will skip "service_" prefix
+				 */
+				g_hash_table_remove(config->service_table,
+						entry + 8);
+				ret = 1;
+			}
+		}
+
+		g_hash_table_foreach(config->service_table,
+						provision_service, service);
+	}
+
+	return ret;
+}