X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fconnection.c;h=ce17c045f561481f7dd974b5a58459e45d4eaf93;hb=96ea65a49c3b90ad017d03dcff2b2fcb636b282a;hp=76147abc5e5ab0c2dbcbaf5a8796fe74ebc6b8b2;hpb=9241922dfe4b9ef55aaf09607560f349b7886d0b;p=platform%2Fcore%2Fapi%2Fconnection.git

diff --git a/src/connection.c b/src/connection.c
index 76147ab..ce17c04 100755
--- a/src/connection.c
+++ b/src/connection.c
@@ -23,7 +23,7 @@
 
 #include "net_connection_private.h"
 
-static __thread GSList *conn_handle_list = NULL;
+static GSList *conn_handle_list = NULL;
 static int tv_profile = -1; // Unknown
 
 //LCOV_EXCL_START
@@ -74,333 +74,124 @@ static bool __connection_check_handle_validity(connection_h connection)
 	return ret;
 }
 
-static connection_type_changed_cb
-__connection_get_type_changed_callback(connection_handle_s *local_handle)
+bool _connection_check_handle_validity(connection_h connection)
 {
-	return local_handle->type_changed_callback;
+	return __connection_check_handle_validity(connection);
 }
 
-static void *__connection_get_type_changed_userdata(
-							connection_handle_s *local_handle)
+static void __connection_set_type_changed_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	return local_handle->type_changed_user_data;
+	conn_handle->type_changed_user_data = user_data;
+	conn_handle->type_changed_callback = callback;
 }
 
-static void __connection_cb_type_change_cb(int type)
+static void __connection_set_ip_changed_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	GSList *list;
-	connection_h handle;
-	void *data;
-	connection_type_changed_cb callback;
-	int state;
-
-	if (_connection_is_created() != true) {
-		CONNECTION_LOG(CONNECTION_ERROR, "Application is not registered"
-				"If multi-threaded, thread integrity be broken.");
-		return;
-	}
-
-	state = __connection_convert_net_state(type);
-
-	for (list = conn_handle_list; list; list = list->next) {
-		handle = (connection_h)list->data;
-
-		callback = __connection_get_type_changed_callback(handle);
-		data = __connection_get_type_changed_userdata(handle);
-		if (callback)
-			callback(state, data);
-	}
+	conn_handle->ip_changed_user_data = user_data;
+	conn_handle->ip_changed_callback = callback;
 }
 
-static void __connection_cb_ethernet_cable_state_changed_cb(connection_ethernet_cable_state_e state)
+static void __connection_set_proxy_changed_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	CONNECTION_LOG(CONNECTION_INFO, "Ethernet Cable state Indication");
-
-	GSList *list;
-
-	for (list = conn_handle_list; list; list = list->next) {
-		connection_handle_s *local_handle = (connection_handle_s *)list->data;
-		if (local_handle->ethernet_cable_state_changed_callback)
-			local_handle->ethernet_cable_state_changed_callback(state,
-					local_handle->ethernet_cable_state_changed_user_data);
-	}
+	conn_handle->proxy_changed_user_data = user_data;
+	conn_handle->proxy_changed_callback = callback;
 }
 
-static int __connection_get_ethernet_cable_state_changed_callback_count(void)
+static void __connection_set_internet_state_changed_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	GSList *list;
-	int count = 0;
-
-	for (list = conn_handle_list; list; list = list->next) {
-		connection_handle_s *local_handle = (connection_handle_s *)list->data;
-		if (local_handle->ethernet_cable_state_changed_callback) count++;
-	}
-
-	return count;
+	conn_handle->internet_state_changed_user_data = user_data;
+	conn_handle->internet_state_changed_callback = callback;
 }
 
-static int __connection_set_type_changed_callback(connection_h connection,
-							void *callback, void *user_data)
+static void __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	static __thread gint refcount = 0;
-	connection_handle_s *local_handle;
-
-	local_handle = (connection_handle_s *)connection;
-
-	if (callback) {
-		if (refcount == 0)
-			_connection_libnet_set_type_changed_cb(
-							   __connection_cb_type_change_cb);
-
-		refcount++;
-		CONNECTION_LOG(CONNECTION_INFO, "Successfully registered(%d)",
-					   refcount);
-	} else {
-		if (refcount > 0 &&
-				__connection_get_type_changed_callback(local_handle) != NULL) {
-			if (--refcount == 0) {
-				_connection_libnet_set_type_changed_cb(NULL);
-				CONNECTION_LOG(CONNECTION_INFO,
-						"Successfully de-registered(%d)", refcount);
-			}
-		}
-	}
-
-	local_handle->type_changed_user_data = user_data;
-	local_handle->type_changed_callback = callback;
-
-	return CONNECTION_ERROR_NONE;
+	conn_handle->ethernet_cable_state_changed_callback = callback;
+	conn_handle->ethernet_cable_state_changed_user_data = user_data;
 }
 
-static connection_address_changed_cb
-__connection_get_ip_changed_callback(connection_handle_s *local_handle)
+static void __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	return local_handle->ip_changed_callback;
+	conn_handle->set_default_callback = callback;
+	conn_handle->set_default_user_data = user_data;
 }
 
-static void *__connection_get_ip_changed_userdata(
-							connection_handle_s *local_handle)
+static void __connection_open_profile_set_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	return local_handle->ip_changed_user_data;
+	conn_handle->opened_callback = callback;
+	conn_handle->opened_user_data = user_data;
 }
 
-static void __connection_cb_ip_change_cb(
-			 connection_address_family_e addr_family, char *ip_addr)
+static void __connection_close_profile_set_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	GSList *list;
-	connection_h handle;
-	char *ip4_addr = NULL;
-	char *ip6_addr = NULL;
-	void *data;
-	connection_address_changed_cb callback;
-
-	if (_connection_is_created() != true) {
-		CONNECTION_LOG(CONNECTION_ERROR, "Application is not registered"
-				"If multi-threaded, thread integrity be broken.");
-		return;
-	}
-
-	switch (addr_family) {
-	case CONNECTION_ADDRESS_FAMILY_IPV4:
-		ip4_addr = g_strdup(ip_addr);
-
-		ip6_addr = vconf_get_str(VCONFKEY_NETWORK_IP6);
-		if (ip6_addr == NULL)
-			CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
-						   "vconf_get_str(VCONFKEY_NETWORK_IP6) failed");
-		break;
-	case CONNECTION_ADDRESS_FAMILY_IPV6:
-		ip6_addr = g_strdup(ip_addr);
-
-		ip4_addr = vconf_get_str(VCONFKEY_NETWORK_IP);
-		if (ip4_addr == NULL)
-			CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
-						   "vconf_get_str(VCONFKEY_NETWORK_IP) failed");
-		break;
-	default:
-		CONNECTION_LOG(CONNECTION_ERROR, "Invalid Address Type");
-		return;
-	}
-
-	for (list = conn_handle_list; list; list = list->next) {
-		handle = (connection_h)list->data;
-
-		callback = __connection_get_ip_changed_callback(handle);
-		data = __connection_get_ip_changed_userdata(handle);
-
-		if (callback)
-			callback(ip4_addr, ip6_addr, data);
-	}
-
-	g_free(ip4_addr);
-	g_free(ip6_addr);
+	conn_handle->closed_callback = callback;
+	conn_handle->closed_user_data = user_data;
 }
 
-static int __connection_set_ip_changed_callback(connection_h connection,
-							void *callback, void *user_data)
+static void __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
+			void *callback, void *user_data)
 {
-	static __thread gint refcount = 0;
-	connection_handle_s *local_handle;
-
-	local_handle = (connection_handle_s *)connection;
-
-	if (callback) {
-		if (refcount == 0)
-			_connection_libnet_set_ip_changed_cb(
-							   __connection_cb_ip_change_cb);
-
-		refcount++;
-		CONNECTION_LOG(CONNECTION_INFO, "Successfully registered(%d)",
-					   refcount);
-	} else {
-		if (refcount > 0 &&
-				__connection_get_ip_changed_callback(local_handle) != NULL) {
-			if (--refcount == 0) {
-				_connection_libnet_set_ip_changed_cb(NULL);
-				CONNECTION_LOG(CONNECTION_INFO,
-							   "Successfully de-registered(%d)", refcount);
-			}
-		}
-	}
-
-	local_handle->ip_changed_user_data = user_data;
-	local_handle->ip_changed_callback = callback;
-
-	return CONNECTION_ERROR_NONE;
-}
-
-static connection_address_changed_cb
-__connection_get_proxy_changed_callback(connection_handle_s *local_handle)
-{
-	return local_handle->proxy_changed_callback;
-}
-
-static void *__connection_get_proxy_changed_userdata(
-							connection_handle_s *local_handle)
-{
-	return local_handle->proxy_changed_user_data;
-}
-
-static void __connection_cb_proxy_change_cb(char *proxy_addr)
-{
-	GSList *list;
-	connection_h handle;
-	void *data;
-	connection_address_changed_cb callback;
-
-	if (_connection_is_created() != true) {
-		CONNECTION_LOG(CONNECTION_ERROR, "Application is not registered"
-				"If multi-threaded, thread integrity be broken.");
-		return;
-	}
-
-	for (list = conn_handle_list; list; list = list->next) {
-		handle = (connection_h)list->data;
-
-		callback = __connection_get_proxy_changed_callback(handle);
-		data = __connection_get_proxy_changed_userdata(handle);
-		/* TODO: IPv6 should be supported */
-		if (callback)
-			callback(proxy_addr, NULL, data);
-	}
-}
-
-static int __connection_set_proxy_changed_callback(connection_h connection,
-							void *callback, void *user_data)
-{
-	static __thread gint refcount = 0;
-	connection_handle_s *local_handle;
-
-	local_handle = (connection_handle_s *)connection;
-
-	if (callback) {
-		if (refcount == 0)
-			_connection_libnet_set_proxy_changed_cb(
-				__connection_cb_proxy_change_cb);
-
-		refcount++;
-		CONNECTION_LOG(CONNECTION_INFO, "Successfully registered(%d)",
-					   refcount);
-	} else {
-		if (refcount > 0 &&
-				__connection_get_proxy_changed_callback(local_handle) != NULL) {
-			if (--refcount == 0) {
-				_connection_libnet_set_proxy_changed_cb(NULL);
-				CONNECTION_LOG(CONNECTION_INFO,
-						"Successfully de-registered(%d)", refcount);
-			}
-		}
-	}
-
-	local_handle->proxy_changed_user_data = user_data;
-	local_handle->proxy_changed_callback = callback;
-
-	return CONNECTION_ERROR_NONE;
-}
-
-static int __connection_set_ethernet_cable_state_changed_cb(connection_h connection,
-		connection_ethernet_cable_state_changed_cb callback, void *user_data)
-{
-	connection_handle_s *local_handle = (connection_handle_s *)connection;
-
-	if (callback) {
-		if (__connection_get_ethernet_cable_state_changed_callback_count() == 0)
-			_connection_libnet_set_ethernet_cable_state_changed_cb(
-					__connection_cb_ethernet_cable_state_changed_cb);
-
-	} else {
-		if (__connection_get_ethernet_cable_state_changed_callback_count() == 1 &&
-				  local_handle->ethernet_cable_state_changed_callback)
-			_connection_libnet_set_ethernet_cable_state_changed_cb(NULL);
-	}
-
-	local_handle->ethernet_cable_state_changed_callback = callback;
-	local_handle->ethernet_cable_state_changed_user_data = user_data;
-	return CONNECTION_ERROR_NONE;
+	conn_handle->reset_callback = callback;
+	conn_handle->reset_user_data = user_data;
 }
 //LCOV_EXCL_STOP
 
-static int __connection_get_handle_count(void)
-{
-	return ((int)g_slist_length(conn_handle_list));
-}
-
 /* Connection Manager ********************************************************/
 EXPORT_API int connection_create(connection_h *connection)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
+	int rv;
+
 	if (connection == NULL || __connection_check_handle_validity(*connection)) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	int rv = _connection_libnet_init();
+	*connection = g_try_malloc0(sizeof(connection_handle_s));
+	if (*connection != NULL) {
+		CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
+	} else {
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+	}
+
+	rv = _connection_libnet_init(*connection);
 	if (rv == NET_ERR_ACCESS_DENIED) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 	} else if (rv != NET_ERR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
-	*connection = g_try_malloc0(sizeof(connection_handle_s));
-	if (*connection != NULL)
-		CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
-	else
-		return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
-
 	conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_destroy(connection_h connection)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
@@ -409,36 +200,67 @@ EXPORT_API int connection_destroy(connection_h connection)
 	__connection_set_type_changed_callback(connection, NULL, NULL);
 	__connection_set_ip_changed_callback(connection, NULL, NULL);
 	__connection_set_proxy_changed_callback(connection, NULL, NULL);
+	__connection_set_internet_state_changed_callback(connection, NULL, NULL);
 	__connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 
 	conn_handle_list = g_slist_remove(conn_handle_list, connection);
+	_connection_libnet_deinit(connection, (conn_handle_list == NULL));
 
 	g_free(connection);
 	connection = NULL;
 
-	if (__connection_get_handle_count() == 0) {
-		_connection_libnet_deinit();
-		_connection_callback_cleanup();
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
+}
+
+//LCOV_EXCL_START
+EXPORT_API int connection_create_cs(int tid, connection_h *connection)
+{
+	int rv;
+
+	rv = connection_create(connection);
+	if (rv == CONNECTION_ERROR_NONE) {
+		CONN_LOCK;
+		_connection_set_cs_tid(tid, *connection);
+		CONN_UNLOCK;
 	}
 
-	return CONNECTION_ERROR_NONE;
+	return rv;
 }
 
+EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
+{
+	int rv;
+
+	CONN_LOCK;
+	_connection_unset_cs_tid(tid, connection);
+	CONN_UNLOCK;
+
+	rv = connection_destroy(connection);
+
+	return rv;
+}
+//LCOV_EXCL_STOP
+
 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
 {
 	int rv = 0;
 	int status = 0;
 
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (type == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
 	if (rv != VCONF_OK) {
 		CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
@@ -446,16 +268,20 @@ EXPORT_API int connection_get_type(connection_h connection, connection_type_e* t
 
 	*type = __connection_convert_net_state(status);
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_get_ip_address(connection_h connection,
 				connection_address_family_e address_family, char** ip_address)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
@@ -468,24 +294,30 @@ EXPORT_API int connection_get_ip_address(connection_h connection,
 		break;
 	default:
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	if (*ip_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_get_proxy(connection_h connection,
 				connection_address_family_e address_family, char** proxy)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
@@ -496,14 +328,17 @@ EXPORT_API int connection_get_proxy(connection_h connection,
 		break;
 	default:
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	if (*proxy == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -512,6 +347,8 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 	FILE *fp;
 	char buf[CONNECTION_MAC_INFO_LENGTH + 1];
 
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
 
 	if (type == CONNECTION_TYPE_WIFI)
@@ -521,6 +358,7 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 
 	if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
@@ -530,21 +368,24 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 			char *profileName;
 			system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
 			if (*profileName == 't' || *profileName == 'T')
-				tv_profile = 1;
+				tv_profile = 1; //LCOV_EXCL_LINE
 			else
 				tv_profile = 0;
 			free(profileName);
 		}
 		if (tv_profile == 1) {
+			//LCOV_EXCL_START
 			fp = fopen(WIFI_MAC_INFO_FILE, "r");
 			if (fp == NULL) {
-				CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
-				return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+				CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE);
+				CONN_UNLOCK;
+				return CONNECTION_ERROR_OUT_OF_MEMORY;
 			}
 
 			if (fgets(buf, sizeof(buf), fp) == NULL) {
-				CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
-				fclose(fp); //LCOV_EXCL_LINE
+				CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE);
+				fclose(fp);
+				CONN_UNLOCK;
 				return CONNECTION_ERROR_OPERATION_FAILED;
 			}
 
@@ -552,17 +393,20 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 
 			*mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
 			if (*mac_addr == NULL) {
-				CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed"); //LCOV_EXCL_LINE
-				fclose(fp); //LCOV_EXCL_LINE
-				return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+				CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
+				fclose(fp);
+				CONN_UNLOCK;
+				return CONNECTION_ERROR_OUT_OF_MEMORY;
 			}
 			g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
 			fclose(fp);
+			//LCOV_EXCL_STOP
 		} else {
 			*mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
 
 			if (*mac_addr == NULL) {
 				CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
+				CONN_UNLOCK; //LCOV_EXCL_LINE
 				return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 			}
 		}
@@ -572,12 +416,14 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 		fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
 		if (fp == NULL) {
 			CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
+			CONN_UNLOCK;
 			return CONNECTION_ERROR_OUT_OF_MEMORY;
 		}
 
 		if (fgets(buf, sizeof(buf), fp) == NULL) {
 			CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
 			fclose(fp);
+			CONN_UNLOCK;
 			return CONNECTION_ERROR_OPERATION_FAILED;
 		}
 
@@ -587,6 +433,7 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 		if (*mac_addr == NULL) {
 			CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
 			fclose(fp);
+			CONN_UNLOCK;
 			return CONNECTION_ERROR_OUT_OF_MEMORY;
 		}
 
@@ -597,6 +444,7 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 	//LCOV_EXCL_STOP
 	default:
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 	}
 
@@ -604,31 +452,38 @@ EXPORT_API int connection_get_mac_address(connection_h connection, connection_ty
 	if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
 			(strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
 		CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
 	}
 
 	CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 
 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	int rv = _connection_libnet_get_metered_state(is_metered);
+	int rv = _connection_libnet_get_metered_state(connection, is_metered);
 	if (rv != CONNECTION_ERROR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return rv; //LCOV_EXCL_LINE
 	}
 
 	CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -642,16 +497,20 @@ EXPORT_API int connection_get_cellular_state(connection_h connection, connection
 	int sim_id = 0;
 #endif
 
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 
 	if (state == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
 	if (rv != VCONF_OK) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
@@ -664,6 +523,7 @@ EXPORT_API int connection_get_cellular_state(connection_h connection, connection
 		if (rv != VCONF_OK) {
 			CONNECTION_LOG(CONNECTION_ERROR,
 					"Failed to get default subscriber id", sim_id);
+			CONN_UNLOCK;
 			return CONNECTION_ERROR_OPERATION_FAILED;
 		}
 
@@ -680,11 +540,13 @@ EXPORT_API int connection_get_cellular_state(connection_h connection, connection
 
 		default:
 			CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
+			CONN_UNLOCK;
 			return CONNECTION_ERROR_OPERATION_FAILED;
 		}
 #endif
 		if (rv != VCONF_OK) {
 			CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
+			CONN_UNLOCK; //LCOV_EXCL_LINE
 			return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 		}
 	}
@@ -696,297 +558,459 @@ EXPORT_API int connection_get_cellular_state(connection_h connection, connection
 			cellular_state == VCONFKEY_DNET_TRANSFER)
 		*state = CONNECTION_CELLULAR_STATE_CONNECTED;
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 
 	if (state == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	int rv = _connection_libnet_get_wifi_state(state);
+	int rv = _connection_libnet_get_wifi_state(connection, state);
 	if (rv != CONNECTION_ERROR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return rv; //LCOV_EXCL_LINE
 	}
 
 	CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 //LCOV_EXCL_START
 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 
 	if (state == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_get_ethernet_state(state);
+	int rv = _connection_libnet_get_ethernet_state(connection, state);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK;
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 
 	if (state == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_get_ethernet_cable_state(state);
+	int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK;
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
 			  connection_ethernet_cable_state_chaged_cb callback, void *user_data)
 {
 	DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
+
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 
 	if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
 			"connection_ethernet_cable_state_changed_cb");
 
-	return __connection_set_ethernet_cable_state_changed_cb(connection,
-			(connection_ethernet_cable_state_changed_cb)callback, user_data);
+	__connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
 {
 	DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
+
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_ethernet_cable_state_changed_cb(connection,
-							NULL, NULL);
+	__connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
 			  connection_ethernet_cable_state_changed_cb callback, void *user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 
 	if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_ethernet_cable_state_changed_cb(connection,
-							callback, user_data);
+	__connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_ethernet_cable_state_changed_cb(connection,
-							NULL, NULL);
+	__connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 //LCOV_EXCL_STOP
 
 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
 
 	if (state == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_get_bluetooth_state(state);
+	int rv = _connection_libnet_get_bluetooth_state(connection, state);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get bluetooth state[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
 					connection_type_changed_cb callback, void* user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_type_changed_callback(connection, callback, user_data);
+	__connection_set_type_changed_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_type_changed_callback(connection, NULL, NULL);
+	__connection_set_type_changed_callback(connection, NULL, NULL);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
 				connection_address_changed_cb callback, void* user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_ip_changed_callback(connection, callback, user_data);
+	__connection_set_ip_changed_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_ip_changed_callback(connection, NULL, NULL);
+	__connection_set_ip_changed_callback(connection, NULL, NULL);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
 				connection_address_changed_cb callback, void* user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_proxy_changed_callback(connection, callback, user_data);
+	__connection_set_proxy_changed_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
 {
+	CONN_LOCK;
+
+	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+	if (!(__connection_check_handle_validity(connection))) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
+		return CONNECTION_ERROR_INVALID_PARAMETER;
+	}
+
+	__connection_set_proxy_changed_callback(connection, NULL, NULL);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_set_internet_state_changed_cb(connection_h connection,
+		connection_internet_state_changed_cb callback, void *user_data)
+{
+	CONN_LOCK;
+
+	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
+
+	if (callback == NULL || !(__connection_check_handle_validity(connection))) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
+		return CONNECTION_ERROR_INVALID_PARAMETER;
+	}
+
+	__connection_set_internet_state_changed_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
+}
+
+EXPORT_API int connection_unset_internet_state_changed_cb(connection_h connection)
+{
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __connection_set_proxy_changed_callback(connection, NULL, NULL);
+	__connection_set_internet_state_changed_callback(connection, NULL, NULL);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
 {
 	int rv = 0;
-	net_profile_info_t *profile_info = profile;
+	connection_handle_s *conn_handle = (connection_handle_s *)connection;
+	net_profile_info_t *profile_info = (net_profile_info_t *)profile;
+
+	CONN_LOCK;
 
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
 	    !(_connection_libnet_check_profile_validity(profile))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 	}
 
 	if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
 			strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 	}
 
-	rv = net_add_profile(profile_info->ProfileInfo.Pdp.ServiceType,
-							(net_profile_info_t*)profile);
+	rv = net_add_profile(conn_handle->network_info_handle,
+				profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
 	if (rv == NET_ERR_ACCESS_DENIED) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 	} else if (rv != NET_ERR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
 {
 	int rv = 0;
-	net_profile_info_t *profile_info = profile;
+	connection_handle_s *conn_handle = (connection_handle_s *)connection;
+	net_profile_info_t *profile_info = (net_profile_info_t *)profile;
+
+	CONN_LOCK;
 
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
-			!(_connection_libnet_check_profile_validity(profile))) {
+		!(_connection_libnet_check_profile_validity(profile))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
+		profile_info->profile_type != NET_DEVICE_MESH &&
 	    profile_info->profile_type != NET_DEVICE_WIFI) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 	}
 
-	rv = net_delete_profile(profile_info->ProfileName);
+	rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
 	if (rv == NET_ERR_ACCESS_DENIED) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 	} else if (rv != NET_ERR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
 {
 	int rv = 0;
-	net_profile_info_t *profile_info = profile;
+	connection_handle_s *conn_handle = (connection_handle_s *)connection;
+	net_profile_info_t *profile_info = (net_profile_info_t *)profile;
+
+	CONN_LOCK;
 
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
 	    !(_connection_libnet_check_profile_validity(profile))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	rv = net_modify_profile(profile_info->ProfileName, (net_profile_info_t*)profile);
+	rv = net_modify_profile(conn_handle->network_info_handle,
+			profile_info->ProfileName, (net_profile_info_t*)profile);
 	if (rv == NET_ERR_ACCESS_DENIED) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 	} else if (rv != NET_ERR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_get_profile_iterator(connection_h connection,
 		connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
@@ -994,190 +1018,370 @@ EXPORT_API int connection_get_profile_iterator(connection_h connection,
 	     type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
 	     type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_get_profile_iterator(type, profile_iterator);
+	int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
 							connection_profile_h* profile)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
-	return _connection_libnet_get_iterator_next(profile_iterator, profile);
+	int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
+
+	CONN_UNLOCK;
+	return rv;
 }
 
 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
-	return _connection_libnet_iterator_has_next(profile_iterator);
+	int rv = _connection_libnet_iterator_has_next(profile_iterator);
+
+	CONN_UNLOCK;
+	return rv;
 }
 
 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
-	return _connection_libnet_destroy_iterator(profile_iterator);
+	int rv = _connection_libnet_destroy_iterator(profile_iterator);
+
+	CONN_UNLOCK;
+	return rv;
 }
 
 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_get_current_profile(profile);
+	int rv = _connection_libnet_get_current_profile(connection, profile);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_get_default_cellular_service_profile(
 		connection_h connection, connection_cellular_service_type_e type,
 		connection_profile_h *profile)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_get_cellular_service_profile(type, profile);
+	int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
 		connection_cellular_service_type_e type, connection_profile_h profile)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_set_cellular_service_profile_sync(type, profile);
+	int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
 		connection_cellular_service_type_e type, connection_profile_h profile,
 		connection_set_default_cb callback, void* user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 
+	int rv;
+
 	if (!(__connection_check_handle_validity(connection)) ||
 	    profile == NULL || callback == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_set_cellular_service_profile_async(type, profile, callback, user_data);
+	rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
+	if (rv == NET_ERR_ACCESS_DENIED) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+	} else if (rv != NET_ERR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+	}
+
+	__connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
 					connection_opened_cb callback, void* user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
 
+	int rv;
+
 	if (!(__connection_check_handle_validity(connection)) ||
 	    profile == NULL || callback == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_open_profile(profile, callback, user_data);
+	rv = _connection_libnet_open_profile(connection, profile);
+	if (rv == NET_ERR_ACCESS_DENIED) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+	} else if (rv != NET_ERR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+	}
+
+	__connection_open_profile_set_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
 					connection_closed_cb callback, void* user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
 
+	int rv;
+
 	if (!(__connection_check_handle_validity(connection)) ||
 	    profile == NULL || callback == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_close_profile(profile, callback, user_data);
+	rv = _connection_libnet_close_profile(connection, profile);
+	if (rv == NET_ERR_ACCESS_DENIED) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+	} else if (rv != NET_ERR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+	}
+
+	__connection_close_profile_set_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_reset_profile(connection_h connection,
 				connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 
+	int rv;
+
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	if (id < 0 || id > 1) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
 		return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 	}
 
-	return _connection_libnet_reset_profile(type, id, callback, user_data);
+	rv = _connection_libnet_reset_profile(connection, type, id);
+	if (rv == NET_ERR_ACCESS_DENIED) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+	} else if (rv != NET_ERR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+	}
+
+	__connection_reset_profile_set_callback(connection, callback, user_data);
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
 	    interface_name == NULL || host_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_add_route(interface_name, host_address);
+	int rv = _connection_libnet_add_route(connection, interface_name, host_address);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
 	    interface_name == NULL || host_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_remove_route(interface_name, host_address);
+	int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
 	    interface_name == NULL || host_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_add_route_ipv6(interface_name, host_address, gateway);
+	int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
 	    interface_name == NULL || host_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return _connection_libnet_remove_route_ipv6(interface_name, host_address, gateway);
+	int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_add_route_entry(connection_h connection,
 		connection_address_family_e address_family,	const char *interface_name,
 		const char *host_address, const char *gateway)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
@@ -1185,16 +1389,23 @@ EXPORT_API int connection_add_route_entry(connection_h connection,
 	     address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 	    interface_name == NULL || host_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
-		return _connection_libnet_add_route_entry(CONNECTION_ADDRESS_FAMILY_IPV4,
+	if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+		int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
 								interface_name, host_address, gateway);
-	else
-		return _connection_libnet_add_route_entry(CONNECTION_ADDRESS_FAMILY_IPV6,
+		CONN_UNLOCK;
+		return rv;
+	} else {
+		int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
 								interface_name, host_address, gateway);
+		CONN_UNLOCK;
+		return rv;
+	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -1202,6 +1413,8 @@ EXPORT_API int connection_remove_route_entry(connection_h connection,
 		connection_address_family_e address_family,	const char *interface_name,
 		const char *host_address, const char *gateway)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 
 	if (!(__connection_check_handle_validity(connection)) ||
@@ -1209,16 +1422,23 @@ EXPORT_API int connection_remove_route_entry(connection_h connection,
 	     address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 	    interface_name == NULL || host_address == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
-		return _connection_libnet_remove_route_entry(CONNECTION_ADDRESS_FAMILY_IPV4,
+	if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
+		int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
 								interface_name, host_address, gateway);
-	else
-		return _connection_libnet_remove_route_entry(CONNECTION_ADDRESS_FAMILY_IPV6,
+		CONN_UNLOCK;
+		return rv;
+	} else {
+		int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
 								interface_name, host_address, gateway);
+		CONN_UNLOCK;
+		return rv;
+	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -1310,7 +1530,7 @@ static int __get_cellular_statistic(connection_statistics_type_e statistics_type
 	return CONNECTION_ERROR_NONE;
 }
 
-static int __get_statistic(connection_type_e connection_type,
+static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
 		connection_statistics_type_e statistics_type, long long *llsize)
 {
 	int rv, stat_type;
@@ -1349,7 +1569,7 @@ static int __get_statistic(connection_type_e connection_type,
 			return CONNECTION_ERROR_INVALID_PARAMETER;
 		}
 
-		rv  = _connection_libnet_get_statistics(stat_type, &ull_size);
+		rv  = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
 		if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
 			return rv;
 		else if (rv != CONNECTION_ERROR_NONE) {
@@ -1366,8 +1586,8 @@ static int __get_statistic(connection_type_e connection_type,
 	return CONNECTION_ERROR_NONE;
 }
 
-static int __reset_statistic(connection_type_e connection_type,
-		connection_statistics_type_e statistics_type)
+static int __reset_statistic(connection_handle_s *conn_handle,
+			connection_type_e connection_type, connection_statistics_type_e statistics_type)
 {
 	int conn_type;
 	int stat_type;
@@ -1397,7 +1617,7 @@ static int __reset_statistic(connection_type_e connection_type,
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	rv = _connection_libnet_set_statistics(conn_type, stat_type);
+	rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
 	if (rv != CONNECTION_ERROR_NONE)
 		return rv;
 
@@ -1410,6 +1630,8 @@ EXPORT_API int connection_get_statistics(connection_h connection,
 				connection_type_e connection_type,
 				connection_statistics_type_e statistics_type, long long* size)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 
 	if (connection_type == CONNECTION_TYPE_CELLULAR)
@@ -1419,16 +1641,27 @@ EXPORT_API int connection_get_statistics(connection_h connection,
 
 	if (!(__connection_check_handle_validity(connection)) || size == NULL) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __get_statistic(connection_type, statistics_type, size);
+	int rv = __get_statistic(connection, connection_type, statistics_type, size);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK;
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_reset_statistics(connection_h connection,
 				connection_type_e connection_type,
 				connection_statistics_type_e statistics_type)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 
 	if (connection_type == CONNECTION_TYPE_CELLULAR)
@@ -1438,16 +1671,27 @@ EXPORT_API int connection_reset_statistics(connection_h connection,
 
 	if (!__connection_check_handle_validity(connection)) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	return __reset_statistic(connection_type, statistics_type);
+	int rv = __reset_statistic(connection, connection_type, statistics_type);
+	if (rv != CONNECTION_ERROR_NONE) {
+		CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
+		CONN_UNLOCK;
+		return rv; //LCOV_EXCL_LINE
+	}
+
+	CONN_UNLOCK;
+	return CONNECTION_ERROR_NONE;
 }
 
 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
 		connection_type_e connection_type, connection_ipv6_address_cb callback,
 		void *user_data)
 {
+	CONN_LOCK;
+
 	CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
 			TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 
@@ -1455,6 +1699,7 @@ EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
 
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
@@ -1479,13 +1724,15 @@ EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
 		break;
 	default:
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
 	if (rv != NET_ERR_NONE) {
-		CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address"
+		CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address" //LCOV_EXCL_LINE
 				" Failed = %d\n", rv);
-		return CONNECTION_ERROR_OPERATION_FAILED;
+		CONN_UNLOCK; //LCOV_EXCL_LINE
+		return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 	}
 
 	GSList *list;
@@ -1498,6 +1745,7 @@ EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
 	g_slist_free_full(ipv6_address_list, g_free);
 	ipv6_address_list = NULL;
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -1505,17 +1753,22 @@ EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
 {
 	int ret = 0;
 
+	CONN_LOCK;
+
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	ret = _connection_libnet_start_tcpdump();
+	ret = _connection_libnet_start_tcpdump(connection);
 	if (ret != CONNECTION_ERROR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret);
+		CONN_UNLOCK;
 		return ret;
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -1523,17 +1776,22 @@ EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
 {
 	int ret = 0;
 
+	CONN_LOCK;
+
 	if (!(__connection_check_handle_validity(connection))) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	ret = _connection_libnet_stop_tcpdump();
+	ret = _connection_libnet_stop_tcpdump(connection);
 	if (ret != CONNECTION_ERROR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret);
+		CONN_UNLOCK;
 		return ret;
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }
 
@@ -1541,16 +1799,21 @@ EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gbo
 {
 	int ret = 0;
 
+	CONN_LOCK;
+
 	if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
+		CONN_UNLOCK;
 		return CONNECTION_ERROR_INVALID_PARAMETER;
 	}
 
-	ret = _connection_libnet_get_tcpdump_state(tcpdump_state);
+	ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
 	if (ret != CONNECTION_ERROR_NONE) {
 		CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret);
+		CONN_UNLOCK;
 		return ret;
 	}
 
+	CONN_UNLOCK;
 	return CONNECTION_ERROR_NONE;
 }