X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fservice.c;h=dd4f191921235d5bec35e157dac542eb4827057e;hb=0a6425147f6e3bd165c8302bdc3205fb958fd065;hp=966417f9bb1f66a23a9c9187cd415e10685a8686;hpb=7faed0b1146d8ac6f637420e360193f1796ad598;p=platform%2Fupstream%2Fconnman.git

diff --git a/src/service.c b/src/service.c
old mode 100644
new mode 100755
index 966417f..dd4f191
--- a/src/service.c
+++ b/src/service.c
@@ -41,6 +41,17 @@
 
 #if defined TIZEN_EXT
 #define WIFI_BSSID_STR_LEN	18
+#define MAX_WIFI_PROFILES	200
+#endif
+
+#if defined TIZEN_EXT
+#define FREQ_RANGE_24GHZ_CHANNEL_1   2412
+#define FREQ_RANGE_24GHZ_CHANNEL_14  2484
+#define FREQ_RANGE_5GHZ_CHANNEL_32   5160
+#define FREQ_RANGE_5GHZ_CHANNEL_165  5825
+
+#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
+#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
 #endif
 
 static DBusConnection *connection = NULL;
@@ -55,6 +66,44 @@ static bool services_dirty = false;
 
 #if defined TIZEN_EXT
 static bool auto_connect_mode = TRUE;
+
+struct saved_profiles {
+	GTimeVal modified;
+	gchar *profile_name;
+};
+
+#endif
+
+#if defined TIZEN_EXT
+enum connman_ins_preferred_freq {
+	CONNMAN_INS_PREFERRED_FREQ_UNKNOWN,
+	CONNMAN_INS_PREFERRED_FREQ_24GHZ,
+	CONNMAN_INS_PREFERRED_FREQ_5GHZ,
+};
+
+struct connman_ins_settings {
+	bool last_user_selection;
+	unsigned int last_user_selection_time;
+	unsigned int last_user_selection_score;
+	bool last_connected;
+	unsigned int last_connected_score;
+	enum connman_ins_preferred_freq preferred_freq;
+	unsigned int preferred_freq_score;
+	unsigned int security_priority[CONNMAN_SERVICE_SECURITY_MAX];
+	unsigned int security_priority_count;
+	unsigned int security_priority_score;
+	bool signal;
+	bool internet;
+	unsigned int internet_score;
+	int signal_level3_5ghz;
+	int signal_level3_24ghz;
+};
+
+static struct connman_ins_settings ins_settings;
+
+static unsigned char invalid_bssid[WIFI_BSSID_LEN_MAX] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
 #endif
 
 struct connman_stats {
@@ -161,9 +210,15 @@ struct connman_service {
 	int disconnect_reason;
 	int assoc_status_code;
 	/*
-	 * Only for EAP-FAST
+	 * Only for EAP-FAST and EAP-PEAP in EAPoL.
 	 */
 	char *phase1;
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	/*
+	 * Only for EAP-FAST
+	 */
+	char *pac_file;
+#endif
 	/*
 	 * Description: To indicate that disconnection triggered by user.
 	 */
@@ -177,6 +232,26 @@ struct connman_service {
 	char *c_sign_key;
 	char *net_access_key;
 #endif
+#if defined TIZEN_EXT
+	unsigned char last_connected_bssid[WIFI_BSSID_LEN_MAX];
+	bool is_internet_connection;
+	int assoc_reject_count;
+#if defined TIZEN_EXT_INS
+	int score_last_user_selection;
+	int score_last_connected;
+	int score_frequency;
+	int score_security_priority;
+	int score_internet_connection;
+	int score_strength;
+#endif
+	int ins_score;
+#endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	/*
+	 * To indicate use of EAP over Ethernet.
+	 */
+	bool use_eapol;
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
 };
 
 static bool allow_property_changed(struct connman_service *service);
@@ -193,6 +268,13 @@ struct find_data {
 };
 
 #if defined TIZEN_EXT
+struct assoc_reject_data {
+	char *bssid;
+	GSList *reject_time_list;
+};
+#endif
+
+#if defined TIZEN_EXT
 /*
  * Public APIs to use user_pdn_connection_refcount
  */
@@ -565,6 +647,383 @@ int __connman_service_load_modifiable(struct connman_service *service)
 	return 0;
 }
 
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+static void __connman_service_cleanup_8021x(struct connman_service *service)
+{
+	if (service == NULL)
+		return;
+
+	DBG("service %p ", service);
+
+	__connman_service_set_string(service, "EAP", NULL);
+	__connman_service_set_string(service, "Identity", NULL);
+	__connman_service_set_string(service, "Passphrase", NULL);
+	__connman_service_set_string(service, "AnonymousIdentity", NULL);
+	__connman_service_set_string(service, "CACertFile", NULL);
+	__connman_service_set_string(service, "ClientCertFile", NULL);
+	__connman_service_set_string(service, "PrivateKeyFile", NULL);
+	__connman_service_set_string(service, "PrivateKeyPassphrase", NULL);
+	__connman_service_set_string(service, "Phase1", NULL);
+	__connman_service_set_string(service, "Phase2", NULL);
+	__connman_service_set_string(service, "PacFile", NULL);
+}
+
+static int connman_service_set_eapol_property(struct connman_service *service,
+			DBusMessageIter *array)
+{
+	DBusMessageIter dict;
+	char *str = NULL;
+
+	__connman_service_cleanup_8021x(service);
+
+	if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+		return -EINVAL;
+
+	dbus_message_iter_recurse(array, &dict);
+
+	while(dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+		DBusMessageIter entry, value;
+		const char *key;
+		int type;
+
+		dbus_message_iter_recurse(&dict, &entry);
+
+		if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+			return -EINVAL;
+
+		dbus_message_iter_get_basic(&entry, &key);
+		dbus_message_iter_next(&entry);
+
+		if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+			return -EINVAL;
+
+		dbus_message_iter_recurse(&entry, &value);
+
+		type = dbus_message_iter_get_arg_type(&value);
+
+		if (g_str_equal(key, "UseEapol")) {
+			dbus_bool_t use_eapol;
+
+			if (type != DBUS_TYPE_BOOLEAN)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &use_eapol);
+			service->use_eapol = use_eapol;
+
+		} else if (g_str_equal(key, "EAP")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "EAP", str);
+
+		} else if (g_str_equal(key, "Identity")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "Identity", str);
+
+		} else if (g_str_equal(key, "AnonymousIdentity")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "AnonymousIdentity", str);
+
+		} else if (g_str_equal(key, "CACertFile")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "CACertFile", str);
+		} else if (g_str_equal(key, "ClientCertFile")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "ClientCertFile", str);
+		} else if (g_str_equal(key, "PrivateKeyFile")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "PrivateKeyFile", str);
+		} else if (g_str_equal(key, "PrivateKeyPassphrase")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "PrivateKeyPassphrase", str);
+		} else if (g_str_equal(key, "Phase2")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "Phase2", str);
+		} else if (g_str_equal(key, "Phase1")) {
+			int val;
+			char phase1[5] = {0,};
+
+			if (type != DBUS_TYPE_INT32)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &val);
+			sprintf(phase1, "%d", val);
+			__connman_service_set_string(service, "Phase1", phase1);
+		} else if (g_str_equal(key, "PacFile")) {
+			if (type != DBUS_TYPE_STRING)
+				return -EINVAL;
+
+			dbus_message_iter_get_basic(&value, &str);
+			__connman_service_set_string(service, "PacFile", str);
+		}
+
+		dbus_message_iter_next(&dict);
+	}
+
+	return 0;
+}
+#endif
+
+#if defined TIZEN_EXT
+static void save_assoc_reject(gpointer key, gpointer value, gpointer user_data)
+{
+	struct assoc_reject_data *assoc_rd = value;
+	GString *assoc_reject_str = user_data;
+	GSList *list;
+	char *val_str;
+
+	if (g_slist_length(assoc_rd->reject_time_list) < 1)
+		return;
+
+	for (list = assoc_rd->reject_time_list; list; list = list->next) {
+		time_t assoc_reject_time = GPOINTER_TO_INT(list->data);
+
+		val_str = g_strdup_printf("%s_%ld", assoc_rd->bssid, assoc_reject_time);
+
+		if (assoc_reject_str->len > 0)
+			g_string_append_printf(assoc_reject_str, " %s", val_str);
+		else
+			g_string_append(assoc_reject_str, val_str);
+
+		g_free(val_str);
+	}
+}
+
+static void count_assoc_reject(gpointer key, gpointer value, gpointer user_data)
+{
+	struct assoc_reject_data *assoc_data = value;
+	int *assoc_reject_count = user_data;
+
+	*assoc_reject_count += g_slist_length(assoc_data->reject_time_list);
+}
+
+static bool update_assoc_reject(struct connman_service *service)
+{
+	GHashTable *assoc_reject_table;
+	int assoc_reject_count;
+
+	if (!service->network)
+		return false;
+
+	assoc_reject_table = connman_network_get_assoc_reject_table(service->network);
+	if (assoc_reject_table) {
+		assoc_reject_count = 0;
+		g_hash_table_foreach(assoc_reject_table, count_assoc_reject, &assoc_reject_count);
+#if defined TIZEN_EXT_INS
+		DBG("assoc reject count [%d -> %d]",
+			service->assoc_reject_count, assoc_reject_count);
+#endif
+		if (service->assoc_reject_count != assoc_reject_count) {
+			service->assoc_reject_count = assoc_reject_count;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+static int service_ext_load(struct connman_service *service)
+{
+	GKeyFile *keyfile;
+	GHashTable *reject_table;
+	char **reject_list;
+	gsize reject_len;
+	struct assoc_reject_data *reject_data;
+	char **bssid_time;
+	char *bssid;
+	time_t reject_time;
+	time_t curr_time;
+	time_t ref_time;
+	struct tm* ref_timeinfo;
+	int i;
+	int err = 0;
+
+#if defined TIZEN_EXT
+	if (!simplified_log)
+#endif
+	DBG("service %p", service);
+
+	if (!service->network)
+		return -EINVAL;
+
+	if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+		return -EINVAL;
+
+	keyfile = connman_storage_load_service(service->identifier);
+	if (!keyfile)
+		return -EIO;
+
+	reject_table = connman_network_get_assoc_reject_table(service->network);
+
+	reject_list = g_key_file_get_string_list(keyfile,
+		service->identifier, "AssocReject", &reject_len, NULL);
+
+	if (!reject_list || reject_len == 0) {
+		g_strfreev(reject_list);
+		goto done;
+	}
+
+	/* Only events that occur within one hour are appened. */
+	curr_time = time(NULL);
+	ref_timeinfo = localtime(&curr_time);
+	ref_timeinfo->tm_hour -= 1;
+	ref_time = mktime(ref_timeinfo);
+
+	for (i = 0; reject_list[i]; i++) {
+		bssid_time = g_strsplit(reject_list[i], "_", 0);
+		if (!bssid_time) {
+			err = -ERANGE;
+			continue;
+		}
+
+		bssid = bssid_time[0];
+		reject_time = strtol(bssid_time[1], NULL, 10);
+
+		if (reject_time < ref_time) {
+			g_strfreev(bssid_time);
+			err = -ERANGE;
+			continue;
+		}
+
+		reject_data = g_hash_table_lookup(reject_table, bssid);
+		if (!reject_data) {
+			reject_data = g_try_new0(struct assoc_reject_data, 1);
+			if (!reject_data) {
+				g_strfreev(bssid_time);
+				err = -ERANGE;
+				continue;
+			}
+
+			reject_data->bssid = g_strdup(bssid);
+			g_hash_table_insert(reject_table, reject_data->bssid, reject_data);
+		}
+
+		reject_data->reject_time_list = g_slist_append(reject_data->reject_time_list,
+				GINT_TO_POINTER(reject_time));
+
+#if defined TIZEN_EXT_INS
+		DBG("assoc reject [%s_%ld]", bssid, reject_time);
+#endif
+
+		g_strfreev(bssid_time);
+	}
+
+	g_strfreev(reject_list);
+
+done:
+	g_key_file_free(keyfile);
+	return err;
+}
+
+static int service_ext_save(struct connman_service *service)
+{
+	GKeyFile *keyfile;
+	GHashTable *reject_table;
+	GString *reject_str;
+	char **reject_list;
+	guint reject_len;
+	int err = 0;
+
+	DBG("service %p", service);
+
+	if (!service->network)
+		return -EINVAL;
+
+	if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+		return -EINVAL;
+
+	keyfile = __connman_storage_open_service(service->identifier);
+	if (!keyfile)
+		return -EIO;
+
+	/* Last connected BSSID */
+	if (memcmp(service->last_connected_bssid, invalid_bssid, WIFI_BSSID_LEN_MAX)) {
+		char *identifier = service->identifier;
+		GString *bssid_str;
+		unsigned int i;
+
+		bssid_str = g_string_sized_new(MAC_ADDRESS_LENGTH);
+		if (!bssid_str) {
+			err = -ENOMEM;
+			goto next;
+		}
+
+		for (i = 0; i < WIFI_BSSID_LEN_MAX; i++) {
+			g_string_append_printf(bssid_str,
+					"%02x", service->last_connected_bssid[i]);
+			if (i < WIFI_BSSID_LEN_MAX - 1)
+				g_string_append(bssid_str, ":");
+		}
+
+		g_key_file_set_string(keyfile, identifier,
+					"LastConnectedBSSID", bssid_str->str);
+
+#if defined TIZEN_EXT_INS
+		DBG("last connected bssid[%s]", bssid_str->str);
+#endif
+
+		g_string_free(bssid_str, TRUE);
+	}
+
+next:
+
+	/* Assoc reject */
+	reject_table = connman_network_get_assoc_reject_table(service->network);
+	if (reject_table && g_hash_table_size(reject_table) > 0) {
+		reject_str = g_string_new(NULL);
+		if (!reject_str) {
+			err = -ENOMEM;
+			goto done;
+		}
+
+		g_hash_table_foreach(reject_table, save_assoc_reject, reject_str);
+
+		reject_list = g_strsplit_set(reject_str->str, " ", 0);
+		reject_len = g_strv_length(reject_list);
+
+		g_key_file_set_string_list(keyfile, service->identifier,
+			"AssocReject", (const gchar **)reject_list, reject_len);
+
+#if defined TIZEN_EXT_INS
+		DBG("assoc reject table [%d]", reject_len);
+#endif
+
+		g_strfreev(reject_list);
+		g_string_free(reject_str, TRUE);
+	} else {
+		g_key_file_remove_key(keyfile, service->identifier, "AssocReject", NULL);
+	}
+
+done:
+	__connman_storage_save_service(keyfile, service->identifier);
+
+	g_key_file_free(keyfile);
+	return err;
+}
+#endif
+
 static int service_load(struct connman_service *service)
 {
 	GKeyFile *keyfile;
@@ -574,7 +1033,15 @@ static int service_load(struct connman_service *service)
 	bool autoconnect;
 	unsigned int ssid_len;
 	int err = 0;
-
+#if defined TIZEN_EXT
+	bool internet_connection;
+#endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	bool use_eapol;
+#endif
+#if defined TIZEN_EXT
+	if (!simplified_log)
+#endif
 	DBG("service %p", service);
 
 	keyfile = connman_storage_load_service(service->identifier);
@@ -654,6 +1121,46 @@ static int service_load(struct connman_service *service)
 
 			g_free(hex_ssid);
 		}
+
+#if defined TIZEN_EXT
+		/* Last connected BSSID */
+		if (service->network) {
+			gchar *bssid_str;
+			unsigned char last_connected_bssid[WIFI_BSSID_LEN_MAX];
+			char **str_list;
+			unsigned int i;
+
+			bssid_str = g_key_file_get_string(keyfile,
+				service->identifier, "LastConnectedBSSID", NULL);
+
+			if (bssid_str) {
+				str_list = g_strsplit(bssid_str, ":", 0);
+
+				if (str_list) {
+					for (i = 0; i < WIFI_BSSID_LEN_MAX; i++)
+						last_connected_bssid[i] = strtol(str_list[i], NULL, 16);
+
+					memcpy(service->last_connected_bssid,
+						last_connected_bssid, WIFI_BSSID_LEN_MAX);
+
+					connman_network_set_last_connected_bssid(service->network,
+						last_connected_bssid);
+
+					g_strfreev(str_list);
+				}
+
+				g_free(bssid_str);
+			}
+		}
+
+		/* Internet connection */
+		internet_connection = g_key_file_get_boolean(keyfile,
+				service->identifier, "InternetConnection", &error);
+		if (!error)
+			service->is_internet_connection = internet_connection;
+
+		g_clear_error(&error);
+#endif
 		/* fall through */
 
 	case CONNMAN_SERVICE_TYPE_GADGET:
@@ -668,8 +1175,16 @@ static int service_load(struct connman_service *service)
 		autoconnect = g_key_file_get_boolean(keyfile,
 				service->identifier, "AutoConnect", &error);
 		if (!error)
-			service->autoconnect = autoconnect;
+			service->autoconnect = autoconnect;
+		g_clear_error(&error);
+
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+		use_eapol = g_key_file_get_boolean(keyfile,
+				service->identifier, "UseEapol", &error);
+		if (!error)
+			service->use_eapol = use_eapol;
 		g_clear_error(&error);
+#endif
 		break;
 	}
 
@@ -769,8 +1284,12 @@ static int service_load(struct connman_service *service)
 					service->identifier, "Hidden", NULL);
 
 #if defined TIZEN_EXT
-	if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
-			service->security == CONNMAN_SERVICE_SECURITY_8021X) {
+	if ((service->type == CONNMAN_SERVICE_TYPE_WIFI &&
+			service->security == CONNMAN_SERVICE_SECURITY_8021X)
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+	|| (service->type == CONNMAN_SERVICE_TYPE_ETHERNET && service->use_eapol)
+#endif
+	) {
 		str = g_key_file_get_string(keyfile,
 				service->identifier, "EAP", NULL);
 		if (str != NULL) {
@@ -792,6 +1311,14 @@ static int service_load(struct connman_service *service)
 			service->identity = str;
 		}
 
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+		str = g_key_file_get_string(keyfile,
+				service->identifier, "AnonymousIdentity", NULL);
+		if (str != NULL) {
+			g_free(service->anonymous_identity);
+			service->anonymous_identity = str;
+		}
+#endif
 		str = g_key_file_get_string(keyfile,
 				service->identifier, "CACertFile", NULL);
 		if (str != NULL) {
@@ -819,6 +1346,22 @@ static int service_load(struct connman_service *service)
 			g_free(service->private_key_passphrase);
 			service->private_key_passphrase = str;
 		}
+
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+		str = g_key_file_get_string(keyfile,
+				service->identifier, "Phase1", NULL);
+		if (str != NULL) {
+			g_free(service->phase1);
+			service->phase1 = str;
+		}
+
+		str = g_key_file_get_string(keyfile,
+				service->identifier, "PacFile", NULL);
+		if (str != NULL) {
+			g_free(service->pac_file);
+			service->pac_file = str;
+		}
+#endif
 	}
 #endif
 #if defined TIZEN_EXT
@@ -892,6 +1435,9 @@ static int service_save(struct connman_service *service)
 		if (service->network) {
 			const unsigned char *ssid;
 			unsigned int ssid_len = 0;
+#if defined TIZEN_EXT
+			GHashTable *assoc_reject_table;
+#endif
 
 			ssid = connman_network_get_blob(service->network,
 							"WiFi.SSID", &ssid_len);
@@ -920,6 +1466,74 @@ static int service_save(struct connman_service *service)
 			freq = connman_network_get_frequency(service->network);
 			g_key_file_set_integer(keyfile, service->identifier,
 						"Frequency", freq);
+
+#if defined TIZEN_EXT
+			/* Last connected BSSID */
+			if (memcmp(service->last_connected_bssid, invalid_bssid, WIFI_BSSID_LEN_MAX)) {
+				char *identifier = service->identifier;
+				GString *bssid_str;
+				unsigned int i;
+
+				bssid_str = g_string_sized_new(18);
+				if (!bssid_str) {
+					err = -ENOMEM;
+					goto done;
+				}
+
+				for (i = 0; i < WIFI_BSSID_LEN_MAX; i++) {
+					g_string_append_printf(bssid_str,
+							"%02x", service->last_connected_bssid[i]);
+					if (i < WIFI_BSSID_LEN_MAX - 1)
+						g_string_append(bssid_str, ":");
+				}
+
+				g_key_file_set_string(keyfile, identifier,
+							"LastConnectedBSSID", bssid_str->str);
+
+#if defined TIZEN_EXT_INS
+				DBG("last connected bssid[%s]", bssid_str->str);
+#endif
+
+				g_string_free(bssid_str, TRUE);
+			}
+
+			/* Assoc reject */
+			assoc_reject_table = connman_network_get_assoc_reject_table(service->network);
+			if (assoc_reject_table && g_hash_table_size(assoc_reject_table) > 0) {
+				GString *assoc_reject_str;
+				char **assoc_reject_list;
+				guint assoc_reject_len;
+
+				assoc_reject_str = g_string_new(NULL);
+				if (!assoc_reject_str) {
+					err = -ENOMEM;
+					goto done;
+				}
+
+				g_hash_table_foreach(assoc_reject_table, save_assoc_reject, assoc_reject_str);
+
+				assoc_reject_list = g_strsplit_set(assoc_reject_str->str, " ", 0);
+				assoc_reject_len = g_strv_length(assoc_reject_list);
+
+				g_key_file_set_string_list(keyfile, service->identifier,
+					"AssocReject", (const gchar **)assoc_reject_list, assoc_reject_len);
+
+#if defined TIZEN_EXT_INS
+				DBG("assoc reject table [%d]", assoc_reject_len);
+#endif
+
+				g_strfreev(assoc_reject_list);
+				g_string_free(assoc_reject_str, TRUE);
+			} else
+				g_key_file_remove_key(keyfile, service->identifier, "AssocReject", NULL);
+
+			/* Internet connection */
+			g_key_file_set_boolean(keyfile, service->identifier,
+					"InternetConnection", service->is_internet_connection);
+#if defined TIZEN_EXT_INS
+			DBG("internet connection [%s]", service->is_internet_connection ? "true" : "false");
+#endif
+#endif
 		}
 		/* fall through */
 
@@ -938,6 +1552,10 @@ static int service_save(struct connman_service *service)
 		if (service->favorite)
 			g_key_file_set_boolean(keyfile, service->identifier,
 					"AutoConnect", service->autoconnect);
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+		g_key_file_set_boolean(keyfile, service->identifier,
+				"UseEapol", service->use_eapol);
+#endif
 		break;
 	}
 
@@ -1068,8 +1686,12 @@ static int service_save(struct connman_service *service)
 				"Config.ident", service->config_entry);
 
 #if defined TIZEN_EXT
-	if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
-			service->security == CONNMAN_SERVICE_SECURITY_8021X) {
+	if ((service->type == CONNMAN_SERVICE_TYPE_WIFI &&
+			service->security == CONNMAN_SERVICE_SECURITY_8021X)
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+	|| (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
+#endif
+	) {
 		if (service->eap != NULL && strlen(service->eap) > 0)
 			g_key_file_set_string(keyfile, service->identifier,
 					"EAP", service->eap);
@@ -1090,6 +1712,14 @@ static int service_save(struct connman_service *service)
 		else
 			g_key_file_remove_key(keyfile, service->identifier,
 					"Identity", NULL);
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+		if (service->anonymous_identity != NULL && strlen(service->anonymous_identity) > 0)
+			g_key_file_set_string(keyfile, service->identifier,
+					"AnonymousIdentity", service->anonymous_identity);
+		else
+			g_key_file_remove_key(keyfile, service->identifier,
+					"AnonymousIdentity", NULL);
+#endif
 
 		if (service->ca_cert_file != NULL && strlen(service->ca_cert_file) > 0)
 			g_key_file_set_string(keyfile, service->identifier,
@@ -1118,7 +1748,22 @@ static int service_save(struct connman_service *service)
 		else
 			g_key_file_remove_key(keyfile, service->identifier,
 					"PrivateKeyPassphrase", NULL);
+#if defined TIZEN_EXT_EAP_ON_ETHERNET
+		if (service->phase1 != NULL && strlen(service->phase1) > 0)
+			g_key_file_set_string(keyfile, service->identifier,
+					"Phase1", service->phase1);
+		else
+			g_key_file_remove_key(keyfile, service->identifier,
+					"Phase1", NULL);
+		if (service->pac_file != NULL && strlen(service->pac_file) > 0)
+			g_key_file_set_string(keyfile, service->identifier,
+					"PacFile", service->pac_file);
+		else
+			g_key_file_remove_key(keyfile, service->identifier,
+					"PacFile", NULL);
+#endif
 	}
+
 	if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
 			service->security == CONNMAN_SERVICE_SECURITY_DPP) {
 		if (service->connector != NULL && strlen(service->connector) > 0)
@@ -1152,12 +1797,108 @@ done:
 	return err;
 }
 
+#if defined TIZEN_EXT
+static gint sort_entry(gconstpointer a, gconstpointer b, gpointer user_data)
+{
+	GTimeVal *aval = (GTimeVal *)a;
+	GTimeVal *bval = (GTimeVal *)b;
+
+	/* Note that the sort order is ascending */
+	if (aval->tv_sec > bval->tv_sec)
+		return 1;
+
+	if (aval->tv_sec < bval->tv_sec)
+		return -1;
+
+	return 0;
+}
+
+static void free_entry(gpointer data)
+{
+	struct saved_profiles *entry = data;
+	g_free(entry->profile_name);
+	g_free(entry);
+}
+
+static void __connman_manage_saved_profiles()
+{
+	GKeyFile *keyfile;
+	gchar **services = NULL;
+	GTimeVal modified;
+	int i, num_profiles = 0;
+	GSequenceIter *iter;
+	GSequence *profile_list;
+	struct saved_profiles *entry;
+
+	profile_list = g_sequence_new(free_entry);
+	if (!profile_list)
+		return;
+
+	services = connman_storage_get_services();
+
+	/* Check the count of saved profiles */
+	for (i = 0; services && services[i]; i++) {
+		if (strncmp(services[i], "wifi_", 5) != 0)
+			continue;
+
+		keyfile = connman_storage_load_service(services[i]);
+		if (!keyfile)
+			continue;
+
+		gchar *str = g_key_file_get_string(keyfile,
+				services[i], "Modified", NULL);
+		if (!str) {
+			g_key_file_free(keyfile);
+			continue;
+		}
+
+		g_time_val_from_iso8601(str, &modified);
+		g_free(str);
+
+		entry = g_try_new(struct saved_profiles, 1);
+		if (!entry) {
+			g_sequence_free(profile_list);
+			g_key_file_free(keyfile);
+			return;
+		}
+
+		entry->modified = modified;
+		entry->profile_name = g_strdup(services[i]);
+
+		g_sequence_insert_sorted(profile_list, entry,
+				sort_entry, NULL);
+
+		num_profiles++;
+	}
+	DBG("number of profiles: %d", num_profiles);
+
+	if (num_profiles > MAX_WIFI_PROFILES) {
+		iter = g_sequence_get_begin_iter(profile_list);
+
+		entry = g_sequence_get(iter);
+
+		if (__connman_storage_remove_service(entry->profile_name) == false)
+			DBG("Failed to remove service profile: %s", entry->profile_name);
+	}
+
+	g_sequence_free(profile_list);
+}
+#endif
+
 void __connman_service_save(struct connman_service *service)
 {
 	if (!service)
 		return;
 
 	service_save(service);
+#if defined TIZEN_EXT
+	/*
+	 * Description: Manage the wireless profiles saved in connman.
+	 * If the number of saved profiles is more than 200, remove the
+	 * profile that is not updated for longer duration.
+	 */
+	__connman_manage_saved_profiles();
+#endif
 }
 
 static enum connman_service_state combine_state(
@@ -2192,7 +2933,11 @@ bool __connman_service_index_is_default(int index)
 
 static void default_changed(void)
 {
+#if defined TIZEN_EXT
+	struct connman_service *service = connman_service_get_default_connection();
+#else
 	struct connman_service *service = connman_service_get_default();
+#endif
 
 	if (service == current_default)
 		return;
@@ -2224,6 +2969,31 @@ static void default_changed(void)
 	__connman_notifier_default_changed(service);
 }
 
+#if defined TIZEN_EXT
+static void append_struct(gpointer value, gpointer user_data);
+
+static void emit_state_changed_with_properties(struct connman_service *service)
+{
+	DBusMessage *signal;
+	DBusMessageIter iter;
+
+	if (!service)
+		return;
+
+	signal = dbus_message_new_signal(service->path, CONNMAN_SERVICE_INTERFACE,
+			"StateChangedProperties");
+	if (!signal)
+		return;
+
+	dbus_message_iter_init_append(signal, &iter);
+	append_struct(service, &iter);
+
+	g_dbus_send_message(connection, signal);
+
+	return;
+}
+#endif
+
 static void state_changed(struct connman_service *service)
 {
 	const char *str;
@@ -2237,25 +3007,47 @@ static void state_changed(struct connman_service *service)
 #if !defined TIZEN_EXT
 	if (!allow_property_changed(service))
 		return;
-
-#endif
-#if defined TIZEN_EXT
+#else
 	DBG(" %s, %s", str, service->path);
 #endif
+
 	connman_dbus_property_changed_basic(service->path,
 				CONNMAN_SERVICE_INTERFACE, "State",
 						DBUS_TYPE_STRING, &str);
+
+#if defined TIZEN_EXT
+	emit_state_changed_with_properties(service);
+#endif
 }
 
 #if defined TIZEN_EXT
 static void connect_reason_changed(struct connman_service *service)
 {
+	struct connman_device *device;
+
 	if (!service->path)
 		return;
 
 	if (!allow_property_changed(service))
 		return;
 
+	if (service->connect_reason == CONNMAN_SERVICE_CONNECT_REASON_USER) {
+		device = connman_network_get_device(service->network);
+		if (device) {
+			bool need_save = false;
+
+			need_save |= connman_device_set_last_user_selection_ident(device, service->identifier);
+			need_save |= connman_device_set_last_user_selection_time(device, time(NULL));
+
+			DBG("last user selection ident[%s] time[%ld]",
+				connman_device_get_last_user_selection_ident(device),
+				connman_device_get_last_user_selection_time(device));
+
+			if (need_save)
+				connman_device_save_last_user_selection(device);
+		}
+	}
+
 	connman_dbus_property_changed_basic(service->path,
 					    CONNMAN_SERVICE_INTERFACE,
 					    "ConnectReason",
@@ -2305,6 +3097,27 @@ static void strength_changed(struct connman_service *service)
 					DBUS_TYPE_BYTE, &service->strength);
 }
 
+#if defined TIZEN_EXT
+static bool update_last_connected_bssid(struct connman_service *service)
+{
+	const unsigned char *last_connected_bssid;
+
+	if (!service->network)
+		return false;
+
+	last_connected_bssid = connman_network_get_last_connected_bssid(service->network);
+	if (memcmp(last_connected_bssid, invalid_bssid, WIFI_BSSID_LEN_MAX) == 0)
+		return false;
+
+	if (memcmp(last_connected_bssid, service->last_connected_bssid, WIFI_BSSID_LEN_MAX) != 0) {
+		memcpy(service->last_connected_bssid, last_connected_bssid, WIFI_BSSID_LEN_MAX);
+		return true;
+	}
+
+	return false;
+}
+#endif
+
 static void favorite_changed(struct connman_service *service)
 {
 	dbus_bool_t favorite;
@@ -2439,6 +3252,57 @@ static void append_ethernet(DBusMessageIter *iter, void *user_data)
 									iter);
 }
 
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+static void append_eap_over_ethernet(DBusMessageIter *iter, void *user_data)
+{
+	struct connman_service *service = user_data;
+	dbus_bool_t val;
+
+	val = service->use_eapol;
+	connman_dbus_dict_append_basic(iter, "UseEapol",
+			DBUS_TYPE_BOOLEAN, &val);
+	if (service->use_eapol) {
+		if (service->eap)
+			connman_dbus_dict_append_basic(iter, "EAP",
+					DBUS_TYPE_STRING, &service->eap);
+
+		if (service->identity)
+			connman_dbus_dict_append_basic(iter, "Identity",
+					DBUS_TYPE_STRING, &service->identity);
+
+		if (service->anonymous_identity)
+			connman_dbus_dict_append_basic(iter, "AnonymousIdentity",
+					DBUS_TYPE_STRING, &service->anonymous_identity);
+
+		if (service->ca_cert_file)
+			connman_dbus_dict_append_basic(iter, "CACertFile",
+					DBUS_TYPE_STRING, &service->ca_cert_file);
+
+		if (service->client_cert_file)
+			connman_dbus_dict_append_basic(iter, "ClientCertFile",
+					DBUS_TYPE_STRING, &service->client_cert_file);
+
+		if (service->private_key_file)
+			connman_dbus_dict_append_basic(iter, "PrivateKeyFile",
+					DBUS_TYPE_STRING, &service->private_key_file);
+
+		if (service->phase2)
+			connman_dbus_dict_append_basic(iter, "Phase2",
+					DBUS_TYPE_STRING, &service->phase2);
+
+		if (service->phase1)
+			connman_dbus_dict_append_basic(iter, "Phase1",
+					DBUS_TYPE_STRING, &service->phase1);
+
+		if (service->pac_file)
+			connman_dbus_dict_append_basic(iter, "PacFile",
+					DBUS_TYPE_STRING, &service->pac_file);
+
+		/* Should we include passphrase? */
+	}
+}
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
+
 static void append_ipv4(DBusMessageIter *iter, void *user_data)
 {
 	struct connman_service *service = user_data;
@@ -3342,9 +4206,7 @@ static void append_wifi_ext_info(DBusMessageIter *dict,
 	country_code = connman_network_get_countrycode(network);
 	connection_mode = connman_network_get_connection_mode(network);
 
-	snprintf(bssid_str, WIFI_BSSID_STR_LEN, "%02x:%02x:%02x:%02x:%02x:%02x",
-				bssid[0], bssid[1], bssid[2],
-				bssid[3], bssid[4], bssid[5]);
+	snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid));
 
 	snprintf(country_code_str, (WIFI_COUNTRY_CODE_LEN + 1), "%c%c",
 		 country_code[0], country_code[1]);
@@ -3420,9 +4282,7 @@ static void append_bssid_info(DBusMessageIter *iter, void *user_data)
 		GSList *list;
 		for (list = bssid_list; list; list = list->next) {
 			bssids = (struct connman_bssids *)list->data;
-			g_snprintf(bssid_buf, MAC_ADDRESS_LENGTH, "%02x:%02x:%02x:%02x:%02x:%02x",
-					bssids->bssid[0], bssids->bssid[1], bssids->bssid[2],
-					bssids->bssid[3], bssids->bssid[4], bssids->bssid[5]);
+			g_snprintf(bssid_buf, MAC_ADDRESS_LENGTH, MACSTR, MAC2STR(bssids->bssid));
 
 			connman_dbus_dict_append_basic(iter, "BSSID",
 					DBUS_TYPE_STRING, &bssid_str);
@@ -3554,12 +4414,18 @@ static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
 		connman_dbus_dict_append_basic(dict, "AssocStatusCode",
 				DBUS_TYPE_INT32, &service->assoc_status_code);
 
+		val = service->hidden_service;
 		connman_dbus_dict_append_basic(dict, "Hidden",
-				DBUS_TYPE_BOOLEAN, &service->hidden_service);
+				DBUS_TYPE_BOOLEAN, &val);
 
 		break;
 #endif
 	case CONNMAN_SERVICE_TYPE_ETHERNET:
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+		connman_dbus_dict_append_dict(dict, "EapOverEthernet",
+						append_eap_over_ethernet, service);
+		/* fall through */
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
 	case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 	case CONNMAN_SERVICE_TYPE_GADGET:
 		connman_dbus_dict_append_dict(dict, "Ethernet",
@@ -3605,23 +4471,116 @@ static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
 
 	connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
 
-	connman_dbus_dict_append_dict(dict, "Proxy.Configuration",
-						append_proxyconfig, service);
+	connman_dbus_dict_append_dict(dict, "Proxy.Configuration",
+						append_proxyconfig, service);
+
+	val = service->mdns;
+	connman_dbus_dict_append_basic(dict, "mDNS", DBUS_TYPE_BOOLEAN,
+				&val);
+
+	val = service->mdns_config;
+	connman_dbus_dict_append_basic(dict, "mDNS.Configuration",
+				DBUS_TYPE_BOOLEAN, &val);
+
+	connman_dbus_dict_append_dict(dict, "Provider",
+						append_provider, service);
+
+	if (service->network)
+		connman_network_append_acddbus(dict, service->network);
+}
+
+#if defined TIZEN_EXT_INS
+static void append_ins_bssid_info(DBusMessageIter *iter, void *user_data)
+{
+	GSList *bssid_list = NULL;
+	struct connman_network *network = user_data;
+	struct connman_bssids *bssids;
+	char bssid_buf[MAC_ADDRESS_LENGTH] = {0,};
+	char *bssid_str = bssid_buf;
+
+	bssid_list = (GSList *)connman_network_get_bssid_list(network);
+	if(bssid_list) {
+		GSList *list;
+		for (list = bssid_list; list; list = list->next) {
+			bssids = (struct connman_bssids *)list->data;
+			g_snprintf(bssid_buf, MAC_ADDRESS_LENGTH, MACSTR, MAC2STR(bssids->bssid));
+
+			connman_dbus_dict_append_basic(iter, "BSSID",
+					DBUS_TYPE_STRING, &bssid_str);
+
+			connman_dbus_dict_append_basic(iter, "ScoreINS",
+					DBUS_TYPE_INT32, &bssids->ins_score);
+
+			connman_dbus_dict_append_basic(iter, "ScoreLastConnected",
+					DBUS_TYPE_INT32, &bssids->score_last_connected_bssid);
+
+			connman_dbus_dict_append_basic(iter, "ScoreAssocReject",
+					DBUS_TYPE_INT32, &bssids->score_assoc_reject);
+
+			connman_dbus_dict_append_basic(iter, "Frequency",
+					DBUS_TYPE_UINT16, &bssids->frequency);
+
+			connman_dbus_dict_append_basic(iter, "ScoreFrequency",
+					DBUS_TYPE_INT32, &bssids->score_frequency);
+
+			connman_dbus_dict_append_basic(iter, "Strength",
+					DBUS_TYPE_UINT16, &bssids->strength);
+
+			connman_dbus_dict_append_basic(iter, "ScoreStrength",
+					DBUS_TYPE_INT32, &bssids->score_strength);
+		}
+	}
+}
+
+static void append_ins_properties(DBusMessageIter *dict,
+					struct connman_service *service)
+{
+	const char *str;
+	unsigned int frequency = 0U;
+
+	if (service->name)
+		connman_dbus_dict_append_basic(dict, "Name",
+					DBUS_TYPE_STRING, &service->name);
+
+	connman_dbus_dict_append_basic(dict, "ScoreINS",
+				DBUS_TYPE_INT32, &service->ins_score);
+
+	connman_dbus_dict_append_basic(dict, "ScoreLastUserSelection",
+				DBUS_TYPE_INT32, &service->score_last_user_selection);
+
+	connman_dbus_dict_append_basic(dict, "ScoreLastConnected",
+				DBUS_TYPE_INT32, &service->score_last_connected);
+
+	str = security2string(service->security);
+	if (str)
+		connman_dbus_dict_append_basic(dict, "Security",
+				DBUS_TYPE_STRING, &str);
+
+	connman_dbus_dict_append_basic(dict, "ScoreSecurityPriority",
+				DBUS_TYPE_INT32, &service->score_security_priority);
+
+	connman_dbus_dict_append_basic(dict, "Strength",
+				DBUS_TYPE_BYTE, &service->strength);
+
+	connman_dbus_dict_append_basic(dict, "ScoreStrength",
+				DBUS_TYPE_INT32, &service->score_strength);
 
-	val = service->mdns;
-	connman_dbus_dict_append_basic(dict, "mDNS", DBUS_TYPE_BOOLEAN,
-				&val);
+	connman_dbus_dict_append_basic(dict, "ScoreInternetConnection",
+				DBUS_TYPE_INT32, &service->score_internet_connection);
 
-	val = service->mdns_config;
-	connman_dbus_dict_append_basic(dict, "mDNS.Configuration",
-				DBUS_TYPE_BOOLEAN, &val);
+	if (service->network) {
+		frequency = connman_network_get_frequency(service->network);
+		connman_dbus_dict_append_basic(dict, "Frequency",
+				DBUS_TYPE_UINT16, &frequency);
 
-	connman_dbus_dict_append_dict(dict, "Provider",
-						append_provider, service);
+		connman_dbus_dict_append_basic(dict, "ScoreFrequency",
+				DBUS_TYPE_INT32, &service->score_frequency);
 
-	if (service->network)
-		connman_network_append_acddbus(dict, service->network);
+		connman_dbus_dict_append_dict(dict, "BSSID.List",
+				append_ins_bssid_info, service->network);
+	}
 }
+#endif
 
 static void append_struct_service(DBusMessageIter *iter,
 		connman_dbus_append_cb_t function,
@@ -3665,6 +4624,34 @@ void __connman_service_list_struct(DBusMessageIter *iter)
 	g_list_foreach(service_list, append_struct, iter);
 }
 
+#if defined TIZEN_EXT_INS
+static void append_dict_ins_properties(DBusMessageIter *dict, void *user_data)
+{
+	struct connman_service *service = user_data;
+
+	append_ins_properties(dict, service);
+}
+
+static void append_ins_struct(gpointer value, gpointer user_data)
+{
+	struct connman_service *service = value;
+	DBusMessageIter *iter = user_data;
+
+	if (!service->path)
+		return;
+
+	if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+		return;
+
+	append_struct_service(iter, append_dict_ins_properties, service);
+}
+
+void __connman_ins_list_struct(DBusMessageIter *iter)
+{
+	g_list_foreach(service_list, append_ins_struct, iter);
+}
+#endif
+
 bool __connman_service_is_hidden(struct connman_service *service)
 {
 	return service->hidden;
@@ -3913,6 +4900,54 @@ const char *connman_service_get_proxy_url(struct connman_service *service)
 	return service->pac;
 }
 
+#if defined TIZEN_EXT
+void connman_service_set_internet_connection(struct connman_service *service,
+							bool internet_connection)
+{
+	if (!service)
+		return;
+
+	if (service->is_internet_connection != internet_connection) {
+		service->is_internet_connection = internet_connection;
+
+		g_get_current_time(&service->modified);
+		service_save(service);
+	}
+}
+
+bool connman_service_get_internet_connection(struct connman_service *service)
+{
+	if (!service)
+		return false;
+
+	return service->is_internet_connection;
+}
+
+DBusMessage *connman_service_get_defaut_info(DBusMessage *msg,
+							struct connman_service *service)
+{
+	DBusMessage *reply;
+	DBusMessageIter array, dict;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &array);
+
+	if (service)
+		dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
+								&service->path);
+
+	connman_dbus_dict_open(&array, &dict);
+	if (service)
+		append_properties(&dict, FALSE, service);
+	connman_dbus_dict_close(&array, &dict);
+
+	return reply;
+}
+#endif
+
 void __connman_service_set_proxy_autoconfig(struct connman_service *service,
 							const char *url)
 {
@@ -4324,6 +5359,18 @@ const char *__connman_service_get_passphrase(struct connman_service *service)
 	return service->passphrase;
 }
 
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+int __connman_service_get_use_eapol(struct connman_service *service)
+{
+	if (!service) {
+		DBG("Service is NULL");
+		return -1;
+	}
+
+	return service->use_eapol;
+}
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
+
 static DBusMessage *get_properties(DBusConnection *conn,
 					DBusMessage *msg, void *user_data)
 {
@@ -5029,6 +6076,14 @@ static DBusMessage *set_property(DBusConnection *conn,
 
 		__connman_service_set_passphrase(service, passphrase);
 #endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	} else if (g_str_equal(name, "EapOverEthernet")) {
+		int err = connman_service_set_eapol_property(service, &value);
+		if (err < 0)
+			return __connman_error_failed(msg, -err);
+
+		service_save(service);
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
 	} else
 		return __connman_error_invalid_property(msg);
 
@@ -5237,6 +6292,9 @@ static void preferred_tech_add_by_type(gpointer data, gpointer user_data)
 		tech_data->preferred_list =
 			g_list_append(tech_data->preferred_list, service);
 
+#if defined TIZEN_EXT
+		if (!simplified_log)
+#endif
 		DBG("type %d service %p %s", tech_data->type, service,
 				service->name);
 	}
@@ -5334,6 +6392,9 @@ static bool auto_connect_service(GList *services,
 	bool ignore[MAX_CONNMAN_SERVICE_TYPES] = { };
 	bool autoconnecting = false;
 	GList *list;
+#if defined TIZEN_EXT
+	GSList *wifi_ignore = NULL;
+#endif
 
 	DBG("preferred %d sessions %d reason %s", preferred, active_count,
 		reason2string(reason));
@@ -5349,6 +6410,13 @@ static bool auto_connect_service(GList *services,
 	for (list = services; list; list = list->next) {
 		service = list->data;
 
+#if defined TIZEN_EXT
+		if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
+			int index = connman_network_get_index(service->network);
+			if (g_slist_find(wifi_ignore, GINT_TO_POINTER(index)) != NULL)
+				continue;
+		} else
+#endif
 		if (ignore[service->type]) {
 			DBG("service %p type %s ignore", service,
 				__connman_service_type2string(service->type));
@@ -5372,9 +6440,18 @@ static bool auto_connect_service(GList *services,
 		if (service->pending ||
 				is_connecting(service->state) ||
 				is_connected(service->state)) {
+#if defined TIZEN_EXT
+			if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
+				int index = connman_network_get_index(service->network);
+				wifi_ignore = g_slist_prepend(wifi_ignore, GINT_TO_POINTER(index));
+
+				autoconnecting = true;
+				continue;
+			}
+#else
 			if (autoconnect_no_session_active(service))
 					return true;
-
+#endif
 			ignore[service->type] = true;
 			autoconnecting = true;
 
@@ -5391,6 +6468,7 @@ static bool auto_connect_service(GList *services,
 #if defined TIZEN_EXT
 			DBG("Service is not favorite, autoconnecting %d",
 					autoconnecting);
+			g_slist_free(wifi_ignore);
 #endif
 			return autoconnecting;
 		}
@@ -5406,7 +6484,9 @@ static bool auto_connect_service(GList *services,
 		if (is_ignore(service) || service->state !=
 				CONNMAN_SERVICE_STATE_IDLE)
 			continue;
-
+#if defined TIZEN_EXT
+		if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+#endif
 		if (autoconnect_already_connecting(service, autoconnecting)) {
 			DBG("service %p type %s has no users", service,
 				__connman_service_type2string(service->type));
@@ -5417,13 +6497,22 @@ static bool auto_connect_service(GList *services,
 			(preferred) ? "preferred" : reason2string(reason));
 
 		__connman_service_connect(service, reason);
-
+#if !defined TIZEN_EXT
 		if (autoconnect_no_session_active(service))
 			return true;
-
+#endif
+#if defined TIZEN_EXT
+		if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
+			int index = connman_network_get_index(service->network);
+			wifi_ignore = g_slist_prepend(wifi_ignore, GINT_TO_POINTER(index));
+			autoconnecting = true;
+		}
+#endif
 		ignore[service->type] = true;
 	}
-
+#if defined TIZEN_EXT
+	g_slist_free(wifi_ignore);
+#endif
 	return autoconnecting;
 }
 
@@ -6007,6 +7096,9 @@ static void service_append_added_foreach(gpointer data, gpointer user_data)
 		append_struct(service, iter);
 		g_hash_table_remove(services_notify->add, service->path);
 	} else {
+#if defined TIZEN_EXT
+		if (!simplified_log)
+#endif
 		DBG("changed %s", service->path);
 
 		append_struct_service(iter, NULL, service);
@@ -6215,6 +7307,9 @@ static DBusMessage *downgrade_service(DBusConnection *conn,
 
 static void service_schedule_added(struct connman_service *service)
 {
+#if defined TIZEN_EXT
+	if (!simplified_log)
+#endif
 	DBG("service %p", service);
 
 	g_hash_table_remove(services_notify->remove, service->path);
@@ -6283,6 +7378,10 @@ static const GDBusMethodTable service_methods[] = {
 static const GDBusSignalTable service_signals[] = {
 	{ GDBUS_SIGNAL("PropertyChanged",
 			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+#if defined TIZEN_EXT
+	{ GDBUS_SIGNAL("StateChangedProperties",
+			GDBUS_ARGS({ "properties", "a{sv}" })) },
+#endif
 	{ },
 };
 
@@ -6371,6 +7470,11 @@ static void service_free(gpointer user_data)
 	g_free(service->phase2);
 	g_free(service->config_file);
 	g_free(service->config_entry);
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	g_free(service->pac_file);
+	g_free(service->phase1);
+#endif
+
 #if defined TIZEN_EXT
 	g_free(service->connector);
 	g_free(service->c_sign_key);
@@ -6403,6 +7507,9 @@ static void stats_init(struct connman_service *service)
 
 static void service_initialize(struct connman_service *service)
 {
+#if defined TIZEN_EXT
+	if (!simplified_log)
+#endif
 	DBG("service %p", service);
 
 	service->refcount = 1;
@@ -6433,6 +7540,11 @@ static void service_initialize(struct connman_service *service)
 	service->wps = false;
 	service->wps_advertizing = false;
 #if defined TIZEN_EXT
+	memset(service->last_connected_bssid, 0, WIFI_BSSID_LEN_MAX);
+	service->is_internet_connection = false;
+	service->assoc_reject_count = 0;
+#endif
+#if defined TIZEN_EXT
 	service->disconnection_requested = false;
 	service->storage_reload = false;
 	/*
@@ -6441,6 +7553,9 @@ static void service_initialize(struct connman_service *service)
 	service->user_pdn_connection_refcount = 0;
 	__sync_synchronize();
 #endif
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	service->use_eapol = false;
+#endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
 }
 
 /**
@@ -6529,19 +7644,220 @@ void connman_service_unref_debug(struct connman_service *service,
 	g_hash_table_remove(service_hash, service->identifier);
 }
 
+#if defined TIZEN_EXT
+static int calculate_score_last_user_selection(struct connman_service *service)
+{
+	int score = 0;
+	struct connman_device *device;
+	const char *last_user_selection_ident;
+	time_t last_user_selection_time;
+	unsigned int frequency;
+	time_t curr_time;
+	time_t ref_time;
+	struct tm* ref_timeinfo;
+
+	device = connman_network_get_device(service->network);
+	if (!device)
+		return 0;
+
+	last_user_selection_time = connman_device_get_last_user_selection_time(device);
+	last_user_selection_ident = connman_device_get_last_user_selection_ident(device);
+	frequency = connman_network_get_frequency(service->network);
+
+	if (ins_settings.last_user_selection) {
+		if (g_strcmp0(last_user_selection_ident, service->identifier) == 0 &&
+			(((frequency >= FREQ_RANGE_24GHZ_CHANNEL_1 &&
+			frequency <= FREQ_RANGE_24GHZ_CHANNEL_14) &&
+			service->strength >= ins_settings.signal_level3_24ghz) ||
+			((frequency >= FREQ_RANGE_5GHZ_CHANNEL_32 &&
+			frequency <= FREQ_RANGE_5GHZ_CHANNEL_165) &&
+			service->strength >= ins_settings.signal_level3_5ghz))) {
+
+			/* Only events that occur within 8 hours are counted. */
+			curr_time = time(NULL);
+			ref_timeinfo = localtime(&curr_time);
+			ref_timeinfo->tm_hour -= 8;
+			ref_time = mktime(ref_timeinfo);
+
+			if (last_user_selection_time > ref_time) {
+				int time_diff = (curr_time - last_user_selection_time) / 60;
+				int denominator = ins_settings.last_user_selection_time - time_diff;
+				int numerator = ins_settings.last_user_selection_time /
+									ins_settings.last_user_selection_score;
+				int last_user_score = denominator / numerator;
+
+				score += (last_user_score > ins_settings.last_user_selection_score ?
+					ins_settings.last_user_selection_score : last_user_score);
+			}
+		}
+	}
+
+	return score;
+}
+
+static int calculate_score_last_connected(struct connman_service *service)
+{
+	int score = 0;
+	struct connman_device *device;
+	const char *last_connected_ident;
+	unsigned int frequency;
+
+	device = connman_network_get_device(service->network);
+	last_connected_ident = connman_device_get_last_connected_ident(device);
+	frequency = connman_network_get_frequency(service->network);
+
+	if (g_strcmp0(last_connected_ident, service->identifier) == 0 &&
+		(((frequency >= FREQ_RANGE_24GHZ_CHANNEL_1 &&
+		frequency <= FREQ_RANGE_24GHZ_CHANNEL_14) &&
+		service->strength >= ins_settings.signal_level3_24ghz) ||
+		((frequency >= FREQ_RANGE_5GHZ_CHANNEL_32 &&
+		frequency <= FREQ_RANGE_5GHZ_CHANNEL_165) &&
+		service->strength >= ins_settings.signal_level3_5ghz))) {
+		score += ins_settings.last_connected_score;
+	}
+
+	return score;
+}
+
+static int calculate_score_frequency(struct connman_service *service)
+{
+	int score = 0;
+	unsigned int frequency;
+
+	frequency = connman_network_get_frequency(service->network);
+
+	switch (ins_settings.preferred_freq) {
+	case CONNMAN_INS_PREFERRED_FREQ_24GHZ:
+		if ((frequency >= FREQ_RANGE_24GHZ_CHANNEL_14 &&
+			frequency <= FREQ_RANGE_24GHZ_CHANNEL_14) &&
+			(service->strength >= ins_settings.signal_level3_24ghz))
+			score += ins_settings.preferred_freq_score;
+
+		break;
+	case CONNMAN_INS_PREFERRED_FREQ_5GHZ:
+		if ((frequency >= FREQ_RANGE_5GHZ_CHANNEL_32 &&
+			frequency <= FREQ_RANGE_5GHZ_CHANNEL_165) &&
+			(service->strength >= ins_settings.signal_level3_5ghz))
+			score += ins_settings.preferred_freq_score;
+
+		break;
+	default:
+		break;
+	}
+
+	return score;
+}
+
+static int calculate_score_security_priority(struct connman_service *service)
+{
+	int score = 0;
+
+	if (ins_settings.security_priority_count)
+		score += ins_settings.security_priority[service->security];
+
+	return score;
+}
+
+static int calculate_score_internet_connection(struct connman_service *service)
+{
+	int score = 0;
+
+	if (ins_settings.internet) {
+		if (service->is_internet_connection)
+			score += ins_settings.internet_score;
+	}
+
+	return score;
+}
+
+static int calculate_score_strength(struct connman_service *service)
+{
+	int score = 0;
+
+	if (ins_settings.signal)
+		score += (((service->strength > 60) ? 60 : service->strength) - 35);
+
+	return score;
+}
+
+static int calculate_score(struct connman_service *service)
+{
+	int score_last_user_selection;
+	int score_last_connected;
+	int score_frequency;
+	int score_security_priority;
+	int score_internet_connection;
+	int score_strength;
+	int score = 0;
+
+	if (service->type != CONNMAN_SERVICE_TYPE_WIFI) {
+		score += calculate_score_internet_connection(service);
+		service->ins_score = score;
+		return score;
+	}
+
+	score_last_user_selection = calculate_score_last_user_selection(service);
+	score_last_connected = calculate_score_last_connected(service);
+	score_frequency = calculate_score_frequency(service);
+	score_security_priority = calculate_score_security_priority(service);
+	score_internet_connection = calculate_score_internet_connection(service);
+	score_strength = calculate_score_strength(service);
+
+	score = score_last_user_selection + score_last_connected +
+		score_frequency + score_security_priority +
+		score_internet_connection + score_strength;
+
+#if defined TIZEN_EXT_INS
+	service->score_last_user_selection = score_last_user_selection;
+	service->score_last_connected = score_last_connected;
+	service->score_frequency = score_frequency;
+	service->score_security_priority = score_security_priority;
+	service->score_internet_connection = score_internet_connection;
+	service->score_strength = score_strength;
+#endif
+
+	service->ins_score = score;
+	return score;
+}
+#endif
+
 static gint service_compare(gconstpointer a, gconstpointer b)
 {
 	struct connman_service *service_a = (void *) a;
 	struct connman_service *service_b = (void *) b;
 	enum connman_service_state state_a, state_b;
 	bool a_connected, b_connected;
+#if defined TIZEN_EXT
+	int score_a;
+	int score_b;
+#else
 	gint strength;
+#endif
 
 	state_a = service_a->state;
 	state_b = service_b->state;
 	a_connected = is_connected(state_a);
 	b_connected = is_connected(state_b);
 
+#if defined TIZEN_EXT
+	if ((a_connected && b_connected) &&
+			state_a == state_b &&
+			service_a->type == CONNMAN_SERVICE_TYPE_WIFI &&
+			service_b->type == CONNMAN_SERVICE_TYPE_WIFI) {
+		const char *default_interface =
+				connman_option_get_string("DefaultWifiInterface");
+		const char *ifname_a = connman_device_get_string(
+				connman_network_get_device(service_a->network), "Interface");
+		const char *ifname_b = connman_device_get_string(
+				connman_network_get_device(service_b->network), "Interface");
+
+		if (g_strcmp0(default_interface, ifname_a) == 0)
+			return -1;
+		else if (g_strcmp0(default_interface, ifname_b) == 0)
+			return 1;
+	}
+#endif
+
 	if (a_connected && b_connected) {
 		if (service_a->order > service_b->order)
 			return -1;
@@ -6624,17 +7940,44 @@ static gint service_compare(gconstpointer a, gconstpointer b)
 			return 1;
 	}
 
+#if defined TIZEN_EXT
+	score_a = calculate_score(service_a);
+	score_b = calculate_score(service_b);
+	if (score_b != score_a)
+		return score_b - score_a;
+#else
 	strength = (gint) service_b->strength - (gint) service_a->strength;
 	if (strength)
 		return strength;
+#endif
 
 	return g_strcmp0(service_a->name, service_b->name);
 }
 
+#if defined TIZEN_EXT_INS
+static void print_service_sort(gpointer data, gpointer user_data)
+{
+	struct connman_service *service = data;
+
+	if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
+		return;
+
+	DBG("name[%-20s] total[%2d] last_usr[%2d] last_conn[%2d] "
+		"freq[%2d] sec[%2d] internet[%2d] strength[%2d]",
+		service->name, service->ins_score, service->score_last_user_selection,
+		service->score_last_connected, service->score_frequency,
+		service->score_security_priority, service->score_internet_connection,
+		service->score_strength);
+}
+#endif
+
 static void service_list_sort(void)
 {
 	if (service_list && service_list->next) {
 		service_list = g_list_sort(service_list, service_compare);
+#if defined TIZEN_EXT_INS
+		g_list_foreach(service_list, print_service_sort, NULL);
+#endif
 		service_schedule_changed();
 	}
 }
@@ -6949,6 +8292,15 @@ void __connman_service_set_string(struct connman_service *service,
 		service->phase2 = g_strdup(value);
 	} else if (g_str_equal(key, "Passphrase"))
 		__connman_service_set_passphrase(service, value);
+#if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
+	else if (g_str_equal(key, "Phase1")) {
+		g_free(service->phase1);
+		service->phase1 = g_strdup(value);
+	} else if (g_str_equal(key, "PacFile")) {
+		g_free(service->pac_file);
+		service->pac_file = g_strdup(value);
+	}
+#endif
 #if defined TIZEN_EXT
 	 else if (g_str_equal(key, "Connector")) {
 		g_free(service->connector);
@@ -7435,6 +8787,14 @@ static int service_indicate_state(struct connman_service *service)
 		searchdomain_remove_all(service);
 
 	service->state = new_state;
+#if defined TIZEN_EXT
+	if (!is_connected(old_state) && is_connected(new_state))
+		connman_device_send_connected_signal(
+				connman_network_get_device(service->network), true);
+	else if (is_connected(old_state) && !is_connected(new_state))
+		connman_device_send_connected_signal(
+				connman_network_get_device(service->network), false);
+#endif
 	state_changed(service);
 
 	if (!is_connected(old_state) && is_connected(new_state))
@@ -7554,6 +8914,10 @@ static int service_indicate_state(struct connman_service *service)
 			single_connected_tech(service);
 #endif
 
+#if defined TIZEN_EXT
+		if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
+			connman_service_set_internet_connection(service, true);
+#endif
 		break;
 
 	case CONNMAN_SERVICE_STATE_DISCONNECT:
@@ -8655,7 +10019,9 @@ static struct connman_service *service_get(const char *identifier)
 	service = connman_service_create();
 	if (!service)
 		return NULL;
-
+#if defined TIZEN_EXT
+	if (!simplified_log)
+#endif
 	DBG("service %p", service);
 
 	service->identifier = g_strdup(identifier);
@@ -8670,6 +10036,9 @@ static struct connman_service *service_get(const char *identifier)
 
 static int service_register(struct connman_service *service)
 {
+#if defined TIZEN_EXT
+	if (!simplified_log)
+#endif
 	DBG("service %p", service);
 
 	if (service->path)
@@ -8681,9 +10050,13 @@ static int service_register(struct connman_service *service)
 	DBG("path %s", service->path);
 
 #if defined TIZEN_EXT
+	int ret;
 	service_load(service);
-	int ret = __connman_config_provision_service(service);
-	if (ret < 0)
+	ret = service_ext_load(service);
+	if (ret == -ERANGE)
+		service_ext_save(service);
+	ret = __connman_config_provision_service(service);
+	if (ret < 0 && !simplified_log)
 		DBG("Failed to provision service");
 #else
 	if (__connman_config_provision_service(service) < 0)
@@ -9299,7 +10672,8 @@ void __connman_service_notify_strength_changed(struct connman_network *network)
 		return;
 
 	service->strength = strength;
-	DBG("Strength %d", strength);
+	if (!simplified_log)
+		DBG("Strength %d", strength);
 	strength_changed(service);
 	service_list_sort();
 }
@@ -9313,6 +10687,9 @@ void __connman_service_update_from_network(struct connman_network *network)
 	bool roaming;
 	const char *name;
 	bool stats_enable;
+#if defined TIZEN_EXT
+	bool need_save = false;
+#endif
 
 	service = connman_service_lookup_from_network(network);
 	if (!service)
@@ -9369,6 +10746,16 @@ roaming:
 	roaming_changed(service);
 
 sorting:
+#if defined TIZEN_EXT
+	need_save |= update_last_connected_bssid(service);
+	need_save |= update_assoc_reject(service);
+	if (need_save) {
+		g_get_current_time(&service->modified);
+		service_ext_save(service);
+		need_sort = true;
+	}
+#endif
+
 	if (need_sort) {
 		service_list_sort();
 	}
@@ -9551,6 +10938,94 @@ static struct connman_agent_driver agent_driver = {
 	.context_unref	= agent_context_unref,
 };
 
+#if defined TIZEN_EXT
+static void ins_setting_init(void)
+{
+	int i;
+	const char *string;
+	char **string_list;
+	unsigned int string_count;
+
+	ins_settings.last_user_selection = connman_setting_get_bool("INSLastUserSelection");
+	ins_settings.last_user_selection_time = connman_setting_get_uint("INSLastUserSelectionTime");
+	ins_settings.last_connected = connman_setting_get_bool("INSLastConnected");
+
+	string = connman_option_get_string("INSPreferredFreq");
+	if (g_strcmp0(string, "5GHz") == 0)
+		ins_settings.preferred_freq = CONNMAN_INS_PREFERRED_FREQ_5GHZ;
+	else if (g_strcmp0(string, "2.4GHz") == 0)
+		ins_settings.preferred_freq = CONNMAN_INS_PREFERRED_FREQ_24GHZ;
+	else
+		ins_settings.preferred_freq = CONNMAN_INS_PREFERRED_FREQ_UNKNOWN;
+
+	ins_settings.security_priority_count = connman_setting_get_uint("INSSecurityPriorityCount");
+	ins_settings.security_priority_score = connman_setting_get_uint("INSSecurityPriorityScore");
+	string_count = ins_settings.security_priority_count;
+
+	memset(ins_settings.security_priority, 0, sizeof(ins_settings.security_priority));
+	string_list = connman_setting_get_string_list("INSSecurityPriority");
+	for (i = 0; string_list && string_list[i]; i++) {
+		unsigned int security_score = string_count * ins_settings.security_priority_score;
+
+		if (g_strcmp0(string_list[i], "WEP") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_WEP] = security_score;
+		else if (g_strcmp0(string_list[i], "PSK") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_PSK] = security_score;
+		else if (g_strcmp0(string_list[i], "8021X") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_8021X] = security_score;
+		else if (g_strcmp0(string_list[i], "WPA") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_WPA] = security_score;
+		else if (g_strcmp0(string_list[i], "RSN") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_RSN] = security_score;
+		else if (g_strcmp0(string_list[i], "SAE") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_SAE] = security_score;
+		else if (g_strcmp0(string_list[i], "OWE") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_OWE] = security_score;
+		else if (g_strcmp0(string_list[i], "DPP") == 0)
+			ins_settings.security_priority[CONNMAN_SERVICE_SECURITY_DPP] = security_score;
+
+		string_count--;
+	}
+
+	ins_settings.signal = connman_setting_get_bool("INSSignal");
+	ins_settings.internet = connman_setting_get_bool("INSInternet");
+
+	ins_settings.last_user_selection_score = connman_setting_get_uint("INSLastUserSelectionScore");
+	ins_settings.last_connected_score = connman_setting_get_uint("INSLastConnectedScore");
+	ins_settings.preferred_freq_score = connman_setting_get_uint("INSPreferredFreqScore");
+	ins_settings.internet_score = connman_setting_get_uint("INSInternetScore");
+
+	ins_settings.signal_level3_5ghz = connman_setting_get_int("INSSignalLevel3_5GHz");
+	ins_settings.signal_level3_24ghz = connman_setting_get_int("INSSignalLevel3_24GHz");
+
+	DBG("last_user_selection [%s]", ins_settings.last_user_selection ? "true" : "false");
+	DBG("last_user_selection_time [%d]", ins_settings.last_user_selection_time);
+	DBG("last_user_selection_score [%d]", ins_settings.last_user_selection_score);
+
+	DBG("last_connected [%s]", ins_settings.last_connected ? "true" : "false");
+	DBG("last_connected_score [%d]", ins_settings.last_connected_score);
+
+	DBG("preferred_freq [%s]", ins_settings.preferred_freq ? "true" : "false");
+	DBG("preferred_freq_score [%d]", ins_settings.preferred_freq_score);
+
+	DBG("security_priority_count [%d]", ins_settings.security_priority_count);
+	for (i = 0; i < CONNMAN_SERVICE_SECURITY_MAX; i++) {
+		if (ins_settings.security_priority[i])
+			DBG("security_priority %s [%d]", security2string(i),
+					ins_settings.security_priority[i]);
+	}
+	DBG("security_priority_score [%d]", ins_settings.security_priority_score);
+
+	DBG("signal [%s]", ins_settings.signal ? "true" : "false");
+
+	DBG("internet [%s]", ins_settings.internet ? "true" : "false");
+	DBG("internet_score [%d]", ins_settings.internet_score);
+
+	DBG("signal_level3_5ghz [%d]", ins_settings.signal_level3_5ghz);
+	DBG("signal_level3_24ghz [%d]", ins_settings.signal_level3_24ghz);
+}
+#endif
+
 int __connman_service_init(void)
 {
 	int err;
@@ -9578,6 +11053,10 @@ int __connman_service_init(void)
 
 	remove_unprovisioned_services();
 
+#if defined TIZEN_EXT
+	ins_setting_init();
+#endif
+
 	return 0;
 }