X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftechnology.c;h=440d7ebb8c7069c0cd6346aa35383d204e2a5557;hb=refs%2Fchanges%2F49%2F253449%2F1;hp=9e00a2934d93f3dbcf9f66d7d771ed6f9a8c6912;hpb=6aa4055ef0544ae85457c25c510fe3db04949c43;p=platform%2Fupstream%2Fconnman.git

diff --git a/src/technology.c b/src/technology.c
old mode 100755
new mode 100644
index 9e00a29..440d7eb
--- a/src/technology.c
+++ b/src/technology.c
@@ -25,6 +25,11 @@
 
 #include <errno.h>
 #include <string.h>
+#if defined TIZEN_EXT
+#include <stdio.h>
+#include <stdlib.h>
+#include <net/if.h>
+#endif
 
 #include <gdbus.h>
 
@@ -43,6 +48,19 @@ static GHashTable *rfkill_list;
 
 static bool global_offlinemode;
 
+#if defined TIZEN_EXT
+struct connman_scan_pending {
+	char *ifname;
+	connman_scan_type_e scan_type;
+	DBusMessage *msg;
+};
+
+struct connman_bssid_pending {
+	char *ifname;
+	unsigned char bssid[6];
+};
+#endif
+
 struct connman_rfkill {
 	unsigned int index;
 	enum connman_service_type type;
@@ -66,7 +84,6 @@ struct connman_technology {
 					      */
 	char *tethering_ident;
 	char *tethering_passphrase;
-	bool tethering_hidden;
 
 	bool enable_persistent; /* Save the tech state */
 
@@ -81,6 +98,12 @@ struct connman_technology {
 	bool softblocked;
 	bool hardblocked;
 	bool dbus_registered;
+#if defined TIZEN_EXT
+	char **enabled_devices;
+#endif
+#if defined TIZEN_EXT_WIFI_MESH
+	DBusMessage *mesh_dbus_msg;
+#endif
 };
 
 static GSList *driver_list = NULL;
@@ -101,7 +124,7 @@ static void rfkill_check(gpointer key, gpointer value, gpointer user_data)
 	struct connman_rfkill *rfkill = value;
 	enum connman_service_type type = GPOINTER_TO_INT(user_data);
 
-	/* Calling _technology_rfkill_add will update the tech. */
+	/* Calling _technology_add_rfkill will update the tech. */
 	if (rfkill->type == type)
 		__connman_technology_add_rfkill(rfkill->index, type,
 				rfkill->softblock, rfkill->hardblock);
@@ -151,6 +174,10 @@ static const char *get_name(enum connman_service_type type)
 		return "Cellular";
 	case CONNMAN_SERVICE_TYPE_P2P:
 		return "P2P";
+#if defined TIZEN_EXT_WIFI_MESH
+	case CONNMAN_SERVICE_TYPE_MESH:
+		return "Mesh";
+#endif
 	}
 
 	return NULL;
@@ -181,9 +208,6 @@ static void technology_save(struct connman_technology *technology)
 	g_key_file_set_boolean(keyfile, identifier, "Tethering",
 				technology->tethering_persistent);
 
-	g_key_file_set_boolean(keyfile, identifier, "Hidden",
-				technology->tethering_hidden);
-
 	if (technology->tethering_ident)
 		g_key_file_set_string(keyfile, identifier,
 					"Tethering.Identifier",
@@ -200,8 +224,6 @@ done:
 	__connman_storage_save_global(keyfile);
 
 	g_key_file_free(keyfile);
-
-	return;
 }
 
 static void tethering_changed(struct connman_technology *technology)
@@ -215,22 +237,27 @@ static void tethering_changed(struct connman_technology *technology)
 	technology_save(technology);
 }
 
-void connman_technology_tethering_notify(struct connman_technology *technology,
+int connman_technology_tethering_notify(struct connman_technology *technology,
 							bool enabled)
 {
+	int err;
+
 	DBG("technology %p enabled %u", technology, enabled);
 
 	if (technology->tethering == enabled)
-		return;
+		return -EALREADY;
 
-	technology->tethering = enabled;
+	if (enabled) {
+		err = __connman_tethering_set_enabled();
+		if (err < 0)
+			return err;
+	} else
+		__connman_tethering_set_disabled();
 
+	technology->tethering = enabled;
 	tethering_changed(technology);
 
-	if (enabled)
-		__connman_tethering_set_enabled();
-	else
-		__connman_tethering_set_disabled();
+	return 0;
 }
 
 static int set_tethering(struct connman_technology *technology,
@@ -240,11 +267,9 @@ static int set_tethering(struct connman_technology *technology,
 	int err;
 	const char *ident, *passphrase, *bridge;
 	GSList *tech_drivers;
-	bool hidden;
 
 	ident = technology->tethering_ident;
 	passphrase = technology->tethering_passphrase;
-	hidden = technology->tethering_hidden;
 
 	__sync_synchronize();
 	if (!technology->enabled)
@@ -254,7 +279,8 @@ static int set_tethering(struct connman_technology *technology,
 	if (!bridge)
 		return -EOPNOTSUPP;
 
-	if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && (!ident))
+	if (technology->type == CONNMAN_SERVICE_TYPE_WIFI &&
+	    (!ident || !passphrase))
 		return -EINVAL;
 
 	for (tech_drivers = technology->driver_list; tech_drivers;
@@ -265,15 +291,13 @@ static int set_tethering(struct connman_technology *technology,
 			continue;
 
 		err = driver->set_tethering(technology, ident, passphrase,
-				bridge, enabled, hidden);
+				bridge, enabled);
 
 		if (result == -EINPROGRESS)
 			continue;
 
-		if (err == -EINPROGRESS || err == 0) {
+		if (err == -EINPROGRESS || err == 0)
 			result = err;
-			continue;
-		}
 	}
 
 	return result;
@@ -349,6 +373,15 @@ static struct connman_technology *technology_find(enum connman_service_type type
 	return NULL;
 }
 
+enum connman_service_type connman_technology_get_type
+				(struct connman_technology *technology)
+{
+	if (!technology)
+		return CONNMAN_SERVICE_TYPE_UNKNOWN;
+
+	return technology->type;
+}
+
 bool connman_technology_get_wifi_tethering(const char **ssid,
 							const char **psk)
 {
@@ -372,6 +405,18 @@ bool connman_technology_get_wifi_tethering(const char **ssid,
 	return true;
 }
 
+#if defined TIZEN_EXT
+const char *connman_techonology_get_path(enum connman_service_type type)
+{
+	struct connman_technology *technology = technology_find(type);
+
+	if (!technology)
+		return NULL;
+
+	return technology->path;
+}
+#endif
+
 static void free_rfkill(gpointer data)
 {
 	struct connman_rfkill *rfkill = data;
@@ -403,6 +448,16 @@ static void technology_load(struct connman_technology *technology)
 	if (!identifier)
 		goto done;
 
+#ifdef TIZEN_EXT
+	gsize length;
+	technology->enabled_devices = g_key_file_get_string_list(keyfile,
+			identifier, "Enable.Devices", &length, NULL);
+	if (technology->enabled_devices && length == 0) {
+		g_strfreev(technology->enabled_devices);
+		technology->enabled_devices = NULL;
+	}
+#endif
+
 	enable = g_key_file_get_boolean(keyfile, identifier, "Enable", &error);
 	if (!error)
 		technology->enable_persistent = enable;
@@ -437,8 +492,6 @@ done:
 	g_free(identifier);
 
 	g_key_file_free(keyfile);
-
-	return;
 }
 
 bool __connman_technology_get_offlinemode(void)
@@ -449,19 +502,33 @@ bool __connman_technology_get_offlinemode(void)
 static void connman_technology_save_offlinemode(void)
 {
 	GKeyFile *keyfile;
+	GError *error = NULL;
+	bool offlinemode;
 
 	keyfile = __connman_storage_load_global();
-	if (!keyfile)
+
+	if (!keyfile) {
 		keyfile = g_key_file_new();
+		g_key_file_set_boolean(keyfile, "global",
+					"OfflineMode", global_offlinemode);
+
+		__connman_storage_save_global(keyfile);
+	}
+	else {
+		offlinemode = g_key_file_get_boolean(keyfile, "global",
+						"OfflineMode", &error);
 
-	g_key_file_set_boolean(keyfile, "global",
+		if (error || offlinemode != global_offlinemode) {
+			g_key_file_set_boolean(keyfile, "global",
 					"OfflineMode", global_offlinemode);
+			if (error)
+				g_clear_error(&error);
 
-	__connman_storage_save_global(keyfile);
+			__connman_storage_save_global(keyfile);
+		}
+	}
 
 	g_key_file_free(keyfile);
-
-	return;
 }
 
 static bool connman_technology_load_offlinemode(void)
@@ -487,6 +554,74 @@ static bool connman_technology_load_offlinemode(void)
 	return offlinemode;
 }
 
+#if defined TIZEN_EXT
+static void append_devices(DBusMessageIter *iter, void *user_data)
+{
+	GSList *list;
+	dbus_bool_t val;
+	struct connman_technology *technology = user_data;
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *device = list->data;
+
+		const char *str = connman_device_get_string(device, "Interface");
+		struct connman_network *network = connman_device_get_default_network(device);
+		struct connman_service *service = connman_service_lookup_from_network(network);
+
+		connman_dbus_dict_append_basic(iter, "Ifname",
+				DBUS_TYPE_STRING, &str);
+
+		val = connman_device_get_powered(device);
+		connman_dbus_dict_append_basic(iter, "Powered",
+				DBUS_TYPE_BOOLEAN, &val);
+
+		if (__connman_service_is_connected_state(service, CONNMAN_IPCONFIG_TYPE_IPV4) ||
+				__connman_service_is_connected_state(service, CONNMAN_IPCONFIG_TYPE_IPV6))
+			val = TRUE;
+		else
+			val = FALSE;
+
+		connman_dbus_dict_append_basic(iter, "Connected",
+				DBUS_TYPE_BOOLEAN, &val);
+
+		str = connman_device_get_string(device, "Address");
+		connman_dbus_dict_append_basic(iter, "MAC.Address",
+				DBUS_TYPE_STRING, &str);
+	}
+}
+
+void __connman_technology_append_interfaces(DBusMessageIter *array,
+				enum connman_service_type type, const char *ifname)
+{
+	GSList *list;
+	struct connman_technology *technology = NULL;
+
+	for (list = technology_list; list; list = list->next) {
+		struct connman_technology *local_tech = list->data;
+
+		if (local_tech->type != type)
+			continue;
+
+		technology = local_tech;
+		break;
+	}
+
+	if (!technology)
+		return;
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *device = list->data;
+		const char *str = connman_device_get_string(device, "Interface");
+
+		if (g_strcmp0(ifname, str) == 0)
+			continue;
+
+		dbus_message_iter_append_basic(array,
+				DBUS_TYPE_STRING, &str);
+	}
+}
+#endif
+
 static void append_properties(DBusMessageIter *iter,
 		struct connman_technology *technology)
 {
@@ -531,12 +666,11 @@ static void append_properties(DBusMessageIter *iter,
 		connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
 					DBUS_TYPE_STRING,
 					&technology->tethering_passphrase);
-
-	val = technology->tethering_hidden;
-	connman_dbus_dict_append_basic(&dict, "Hidden",
-					DBUS_TYPE_BOOLEAN,
-					&val);
-
+#if defined TIZEN_EXT
+	if (technology->type == CONNMAN_SERVICE_TYPE_WIFI)
+		connman_dbus_dict_append_dict(&dict, "Device.List",
+					append_devices, technology);
+#endif
 	connman_dbus_dict_close(iter, &dict);
 }
 
@@ -611,7 +745,7 @@ static gboolean technology_pending_reply(gpointer user_data)
 	struct connman_technology *technology = user_data;
 	DBusMessage *reply;
 
-	/* Power request timedout, send ETIMEDOUT. */
+	/* Power request timed out, send ETIMEDOUT. */
 	if (technology->pending_reply) {
 		reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
 		if (reply)
@@ -639,6 +773,11 @@ static int technology_affect_devices(struct connman_technology *technology,
 		return 0;
 	}
 
+#if defined TIZEN_EXT_WIFI_MESH
+	if (technology->type == CONNMAN_SERVICE_TYPE_MESH)
+		return 0;
+#endif
+
 	for (list = technology->device_list; list; list = list->next) {
 		struct connman_device *device = list->data;
 
@@ -673,6 +812,10 @@ static void powered_changed(struct connman_technology *technology)
 
 	__sync_synchronize();
 	enabled = technology->enabled;
+#if defined TIZEN_EXT
+	DBG("ConnMan, Powered : %s, %s",
+			enabled ? "TRUE" : "FALSE",technology->path);
+#endif
 	connman_dbus_property_changed_basic(technology->path,
 			CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
 			DBUS_TYPE_BOOLEAN, &enabled);
@@ -778,6 +921,8 @@ static int technology_disable(struct connman_technology *technology)
 
 	if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
 		technology->enable_persistent = false;
+		__connman_device_stop_scan(CONNMAN_SERVICE_TYPE_P2P);
+		__connman_peer_disconnect_all();
 		return technology_disabled(technology);
 	} else if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
 		struct connman_technology *p2p;
@@ -845,13 +990,103 @@ make_reply:
 	return reply;
 }
 
+#if defined TIZEN_EXT
+int set_connman_bssid(enum bssid_type mode, char *bssid, const char *ifname)
+{
+	static int bssid_len;
+	static const char *def_ifname = "default";
+	static GSList *bssid_list = NULL;
+	GSList *list;
+	const char *local_ifname = ifname;
+	bool found = false;
+	struct connman_bssid_pending *bssid_info;
+
+	DBG("mode: %d, ifname: %s", mode, ifname);
+
+	if (!ifname)
+		local_ifname = def_ifname;
+
+	for (list = bssid_list; list; list = list->next) {
+		bssid_info = list->data;
+
+		if (g_strcmp0(bssid_info->ifname, local_ifname) == 0) {
+			found = true;
+			break;
+		}
+	}
+
+	if (mode == CHECK_BSSID) {
+		if (found)
+			return 6;
+
+		return 0;
+	}
+
+	if (mode == GET_BSSID && bssid) {
+		if (found) {
+			memcpy(bssid, bssid_info->bssid, 6);
+			return 6;
+		}
+		return 0;
+	}
+
+	if (mode == RESET_BSSID) {
+		if (found) {
+			bssid_list = g_slist_remove(bssid_list, bssid_info);
+			g_free(bssid_info->ifname);
+			g_free(bssid_info);
+		}
+		return 0;
+	}
+
+	if (mode != SET_BSSID || !bssid) {
+		DBG("Invalid parameter");
+		return 0;
+	}
+
+	if (found) {
+		bssid_list = g_slist_remove(bssid_list, bssid_info);
+		g_free(bssid_info->ifname);
+		g_free(bssid_info);
+	}
+
+	bssid_info = g_try_malloc0(sizeof(struct connman_bssid_pending));
+	if (!bssid_info) {
+		DBG("Failed to allocate memory");
+		return 0;
+	}
+
+	unsigned char *bssid_data = bssid_info->bssid;
+
+	bssid_len = sscanf(bssid, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
+		&bssid_data[0], &bssid_data[1], &bssid_data[2],
+		&bssid_data[3], &bssid_data[4], &bssid_data[5]);
+	if (bssid_len != 6) {
+		DBG("Incorrect BSSID format. bssid_len = %d", bssid_len);
+		g_free(bssid_info);
+		return 0;
+	}
+
+	DBG("SET BSSID len: %d, BSSID: %02x:%02x:%02x:%02x:%02x:%02x ifname: %s",
+		bssid_len,
+		bssid_data[0], bssid_data[1], bssid_data[2],
+		bssid_data[3], bssid_data[4], bssid_data[5],
+		ifname);
+
+	bssid_info->ifname = g_strdup(ifname);
+	bssid_list = g_slist_prepend(bssid_list, bssid_info);
+
+	return bssid_len;
+}
+#endif
+
 static DBusMessage *set_property(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
 	struct connman_technology *technology = data;
 	DBusMessageIter iter, value;
 	const char *name;
-	int type;
+	int type, err;
 
 	DBG("conn %p", conn);
 
@@ -873,21 +1108,6 @@ static DBusMessage *set_property(DBusConnection *conn,
 
 	DBG("property %s", name);
 
-	if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && technology->connected) {
-		uid_t uid;
-		if (connman_dbus_get_connection_unix_user_sync(conn,
-						dbus_message_get_sender(msg),
-						&uid) < 0) {
-			DBG("Can not get unix user id!");
-			return __connman_error_permission_denied(msg);
-		}
-
-		if (!__connman_service_is_user_allowed(CONNMAN_SERVICE_TYPE_WIFI, uid)) {
-			DBG("Not allow this user to operate wifi technology now!");
-			return __connman_error_permission_denied(msg);
-		}
-	}
-
 	if (g_str_equal(name, "Tethering")) {
 		dbus_bool_t tethering;
 		int err;
@@ -948,50 +1168,22 @@ static DBusMessage *set_property(DBusConnection *conn,
 		if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
 			return __connman_error_not_supported(msg);
 
-		if (strlen(str) < 8 || strlen(str) > 63) {
-			if (g_str_equal(str, "")) {
-				technology->tethering_passphrase = NULL;
-
-				connman_dbus_property_changed_basic(technology->path,
-						CONNMAN_TECHNOLOGY_INTERFACE,
-						"TetheringPassphrase",
-						DBUS_TYPE_STRING,
-						&str);
-			}
-			else
-				return __connman_error_passphrase_required(msg);
-		} else {
-			if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
-				g_free(technology->tethering_passphrase);
-				technology->tethering_passphrase = g_strdup(str);
-				technology_save(technology);
-
-				connman_dbus_property_changed_basic(technology->path,
-						CONNMAN_TECHNOLOGY_INTERFACE,
-						"TetheringPassphrase",
-						DBUS_TYPE_STRING,
-						&technology->tethering_passphrase);
-			}
-		}
-	} else if (g_str_equal(name, "Hidden")) {
-		dbus_bool_t hidden;
-
-		if (type != DBUS_TYPE_BOOLEAN)
-			return __connman_error_invalid_arguments(msg);
-
-		dbus_message_iter_get_basic(&value, &hidden);
-
-		if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
-			return __connman_error_not_supported(msg);
+		err = __connman_service_check_passphrase(CONNMAN_SERVICE_SECURITY_PSK,
+							str);
+		if (err < 0)
+			return __connman_error_passphrase_required(msg);
 
-		technology->tethering_hidden = hidden;
-		technology_save(technology);
+		if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
+			g_free(technology->tethering_passphrase);
+			technology->tethering_passphrase = g_strdup(str);
+			technology_save(technology);
 
-		connman_dbus_property_changed_basic(technology->path,
+			connman_dbus_property_changed_basic(technology->path,
 					CONNMAN_TECHNOLOGY_INTERFACE,
-					"Hidden",
-					DBUS_TYPE_BOOLEAN,
-					&hidden);
+					"TetheringPassphrase",
+					DBUS_TYPE_STRING,
+					&technology->tethering_passphrase);
+		}
 	} else if (g_str_equal(name, "Powered")) {
 		dbus_bool_t enable;
 
@@ -1001,6 +1193,17 @@ static DBusMessage *set_property(DBusConnection *conn,
 		dbus_message_iter_get_basic(&value, &enable);
 
 		return set_powered(technology, msg, enable);
+#if defined TIZEN_EXT
+	} else if (g_str_equal(name, "SetBSSID")) {
+		char *key;
+
+		if (type != DBUS_TYPE_STRING)
+			return __connman_error_invalid_arguments(msg);
+
+		dbus_message_iter_get_basic(&value, &key);
+		DBG("BSSID %s", key);
+		set_connman_bssid(SET_BSSID, key, NULL);
+#endif
 	} else
 		return __connman_error_invalid_property(msg);
 
@@ -1014,8 +1217,12 @@ static void reply_scan_pending(struct connman_technology *technology, int err)
 	DBG("technology %p err %d", technology, err);
 
 	while (technology->scan_pending) {
+#if defined TIZEN_EXT
+		struct connman_scan_pending *pending_data = technology->scan_pending->data;
+		DBusMessage *msg = pending_data->msg;
+#else
 		DBusMessage *msg = technology->scan_pending->data;
-
+#endif
 		DBG("reply to %s", dbus_message_get_sender(msg));
 
 		if (err == 0)
@@ -1028,60 +1235,198 @@ static void reply_scan_pending(struct connman_technology *technology, int err)
 		technology->scan_pending =
 			g_slist_delete_link(technology->scan_pending,
 					technology->scan_pending);
+#if defined TIZEN_EXT
+		g_free(pending_data->ifname);
+		g_free(pending_data);
+#endif
 	}
 }
 
-void __connman_technology_scan_started(struct connman_device *device)
+#if defined TIZEN_EXT
+dbus_bool_t __connman_technology_notify_scan_changed(const char *key, void *val)
 {
-	DBG("device %p", device);
+	DBG("key %s", key);
+	DBusMessage *signal;
+	DBusMessageIter iter;
+	dbus_bool_t result = FALSE;
+
+	signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+			CONNMAN_MANAGER_INTERFACE, "ScanChanged");
+	if (!signal)
+		return result;
+
+	dbus_message_iter_init_append(signal, &iter);
+	if (key)
+		connman_dbus_property_append_basic(&iter, key, DBUS_TYPE_BOOLEAN, val);
+	else
+		connman_dbus_property_append_basic(&iter, "", DBUS_TYPE_BOOLEAN, val);
+
+	result = dbus_connection_send(connection, signal, NULL);
+	dbus_message_unref(signal);
+
+	DBG("Successfuly sent signal");
+
+	return result;
 }
 
-void __connman_technology_scan_stopped(struct connman_device *device,
-					enum connman_service_type type)
+void __connman_technology_notify_scan_done(const char *ifname, int val)
 {
-	int count = 0;
-	struct connman_technology *technology;
+	DBG("");
+	DBusMessage *signal;
+	DBusMessageIter iter;
+
+	signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+			CONNMAN_MANAGER_INTERFACE, "ScanDone");
+	if (!signal)
+		return;
+
+	dbus_message_iter_init_append(signal, &iter);
+	if (ifname)
+		connman_dbus_property_append_basic(&iter, ifname,
+				DBUS_TYPE_INT32, &val);
+	else
+		connman_dbus_property_append_basic(&iter, "",
+				DBUS_TYPE_INT32, &val);
+
+	dbus_connection_send(connection, signal, NULL);
+	dbus_message_unref(signal);
+
+	DBG("Successfuly sent ScanDone signal");
+}
+
+static void reply_scan_pending_device(
+		struct connman_technology *technology, const char *ifname, int count)
+{
+	DBusMessage *reply;
 	GSList *list;
+	dbus_bool_t status = 0;
+	connman_scan_type_e scan_type = CONNMAN_SCAN_TYPE_UNKNOWN;
 
-	technology = technology_find(type);
+	DBG("technology %p ifname %s count %d", technology, ifname, count);
 
-	DBG("technology %p device %p", technology, device);
+	list = technology->scan_pending;
 
-	if (!technology)
-		return;
+	while (list) {
+		struct connman_scan_pending *pending_data = list->data;
+		DBusMessage *msg = pending_data->msg;
+		list = list->next;
 
-	for (list = technology->device_list; list; list = list->next) {
-		struct connman_device *other_device = list->data;
+		if (scan_type == CONNMAN_SCAN_TYPE_UNKNOWN)
+			scan_type = pending_data->scan_type;
 
-		if (device == other_device)
+		if (count != 0 && g_strcmp0(pending_data->ifname, ifname) != 0)
 			continue;
 
-		if (__connman_device_get_service_type(other_device) != type)
-			continue;
+		scan_type = pending_data->scan_type;
 
-		if (connman_device_get_scanning(other_device))
-			count += 1;
+		DBG("reply to %s", dbus_message_get_sender(msg));
+		reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+		g_dbus_send_message(connection, reply);
+		dbus_message_unref(msg);
+
+		technology->scan_pending =
+				g_slist_remove(technology->scan_pending, pending_data);
+
+		g_free(pending_data->ifname);
+		g_free(pending_data);
 	}
 
-	if (count == 0)
-		reply_scan_pending(technology, 0);
+	if (scan_type == CONNMAN_SCAN_TYPE_UNKNOWN)
+		scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+
+	__connman_technology_notify_scan_changed(ifname, &status);
+	__connman_technology_notify_scan_done(ifname, scan_type);
 }
 
-void __connman_technology_notify_regdom_by_device(struct connman_device *device,
-						int result, const char *alpha2)
+static void __connman_technology_notify_device_detected(
+		struct connman_technology *technology, const char *ifname, bool val)
 {
-	bool regdom_set = false;
-	struct connman_technology *technology;
-	enum connman_service_type type;
-	GSList *tech_drivers;
+	DBG("");
+	DBusMessage *signal;
+	DBusMessageIter iter;
+	dbus_bool_t detected = val;
 
-	type = __connman_device_get_service_type(device);
-	technology = technology_find(type);
+	if (!ifname)
+		return;
 
-	if (!technology)
+	signal = dbus_message_new_signal(technology->path,
+			CONNMAN_TECHNOLOGY_INTERFACE, "DeviceDetected");
+	if (!signal)
 		return;
 
-	if (result < 0) {
+	dbus_message_iter_init_append(signal, &iter);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &ifname);
+	dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &detected);
+
+	dbus_connection_send(connection, signal, NULL);
+	dbus_message_unref(signal);
+
+	DBG("Successfuly sent DeviceDetected signal");
+}
+#endif
+
+void __connman_technology_scan_started(struct connman_device *device)
+{
+	DBG("device %p", device);
+#if defined TIZEN_EXT
+	dbus_bool_t status = 1;
+	const char *ifname = connman_device_get_string(device, "Interface");
+
+	__connman_technology_notify_scan_changed(ifname, &status);
+#endif
+}
+
+void __connman_technology_scan_stopped(struct connman_device *device,
+					enum connman_service_type type)
+{
+	int count = 0;
+	struct connman_technology *technology;
+	GSList *list;
+
+	technology = technology_find(type);
+
+	DBG("technology %p device %p", technology, device);
+
+	if (!technology)
+		return;
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *other_device = list->data;
+
+		if (device == other_device)
+			continue;
+
+		if (connman_device_get_scanning(other_device, type))
+			count += 1;
+	}
+
+#if defined TIZEN_EXT
+	const char *ifname = connman_device_get_string(device, "Interface");
+	reply_scan_pending_device(technology, ifname, count);
+
+	return;
+#else
+	if (count == 0)
+		reply_scan_pending(technology, 0);
+#endif
+}
+
+void __connman_technology_notify_regdom_by_device(struct connman_device *device,
+						int result, const char *alpha2)
+{
+	bool regdom_set = false;
+	struct connman_technology *technology;
+	enum connman_service_type type;
+	GSList *tech_drivers;
+
+	type = __connman_device_get_service_type(device);
+	technology = technology_find(type);
+
+	if (!technology)
+		return;
+
+	if (result < 0) {
 
 		for (tech_drivers = technology->driver_list;
 		     tech_drivers;
@@ -1089,38 +1434,1042 @@ void __connman_technology_notify_regdom_by_device(struct connman_device *device,
 			struct connman_technology_driver *driver =
 				tech_drivers->data;
 
-			if (driver->set_regdom) {
-				driver->set_regdom(technology, alpha2);
-				regdom_set = true;
+			if (driver->set_regdom) {
+				driver->set_regdom(technology, alpha2);
+				regdom_set = true;
+			}
+
+		}
+
+		if (!regdom_set)
+			alpha2 = NULL;
+	}
+
+	connman_technology_regdom_notify(technology, alpha2);
+}
+
+static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	struct connman_technology *technology = data;
+	int err;
+
+	DBG("technology %p request from %s", technology,
+			dbus_message_get_sender(msg));
+
+	if (technology->type == CONNMAN_SERVICE_TYPE_P2P &&
+				!technology->enabled)
+		return __connman_error_permission_denied(msg);
+
+#if !defined TIZEN_EXT
+	dbus_message_ref(msg);
+	technology->scan_pending =
+		g_slist_prepend(technology->scan_pending, msg);
+#endif
+
+	err = __connman_device_request_scan_full(technology->type);
+	if (err < 0)
+#if defined TIZEN_EXT
+		return __connman_error_failed(msg, -err);
+#else
+		reply_scan_pending(technology, err);
+#endif
+
+#if defined TIZEN_EXT
+	struct connman_scan_pending *pending_data =
+			g_try_malloc0(sizeof(struct connman_scan_pending));
+	if (!pending_data)
+		return __connman_error_failed(msg, ENOMEM);
+
+	pending_data->scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+	DBG("scan_type %d", pending_data->scan_type);
+
+	pending_data->msg = dbus_message_ref(msg);
+
+	technology->scan_pending =
+		g_slist_prepend(technology->scan_pending, pending_data);
+#endif
+	return NULL;
+}
+
+#if defined TIZEN_EXT
+static DBusMessage *scan_device(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	struct connman_technology *technology = data;
+	DBusMessageIter iter;
+	const char *ifname;
+	int err;
+
+	DBG("technology %p request from %s", technology,
+			dbus_message_get_sender(msg));
+
+	if (!dbus_message_iter_init(msg, &iter))
+		return __connman_error_invalid_arguments(msg);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_get_basic(&iter, &ifname);
+	DBG("Interface name %s", ifname);
+
+	if (!ifname || strlen(ifname) == 0)
+		return __connman_error_invalid_arguments(msg);
+
+	err = connman_device_request_device_scan(technology->type, ifname, true);
+	if (err < 0)
+		return __connman_error_failed(msg, -err);
+
+	struct connman_scan_pending *pending_data =
+			g_try_malloc0(sizeof(struct connman_scan_pending));
+	if (!pending_data)
+		return __connman_error_failed(msg, ENOMEM);
+
+	pending_data->ifname =  g_strdup(ifname);
+	if (pending_data->ifname == NULL) {
+		g_free(pending_data);
+		return __connman_error_failed(msg, ENOMEM);
+	}
+
+	pending_data->scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+	DBG("scan_type %d", pending_data->scan_type);
+
+	pending_data->msg = dbus_message_ref(msg);
+
+	technology->scan_pending =
+		g_slist_prepend(technology->scan_pending, pending_data);
+
+	return NULL;
+}
+
+static DBusMessage *specific_scan(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	struct connman_technology *technology = data;
+	GSList *specific_scan_list = NULL;
+	int scan_type = 0;
+	const char *name = NULL;
+	const char *freq = NULL;
+	const char *ifname = NULL;
+	DBusMessageIter iter, dict;
+	int err;
+
+	DBG("technology %p request from %s", technology,
+			dbus_message_get_sender(msg));
+
+	if (!dbus_message_iter_init(msg, &iter))
+		return __connman_error_invalid_arguments(msg);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_recurse(&iter, &dict);
+	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+		DBusMessageIter entry, value2;
+		const char *key;
+		int type;
+
+		dbus_message_iter_recurse(&dict, &entry);
+		if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) {
+			g_slist_free_full(specific_scan_list, g_free);
+			return __connman_error_invalid_arguments(msg);
+		}
+
+		dbus_message_iter_get_basic(&entry, &key);
+		dbus_message_iter_next(&entry);
+
+		if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) {
+			g_slist_free_full(specific_scan_list, g_free);
+			return __connman_error_invalid_arguments(msg);
+		}
+
+		dbus_message_iter_recurse(&entry, &value2);
+		type = dbus_message_iter_get_arg_type(&value2);
+		if (g_str_equal(key, "Ifname") && type == DBUS_TYPE_STRING) {
+
+			dbus_message_iter_get_basic(&value2, &ifname);
+			DBG("ifname %s", ifname);
+		} else if (g_str_equal(key, "SSID")) {
+			if (type != DBUS_TYPE_STRING) {
+				g_slist_free_full(specific_scan_list, g_free);
+				return __connman_error_invalid_arguments(msg);
+			}
+
+			scan_type = CONNMAN_MULTI_SCAN_SSID; /* SSID based scan */
+			dbus_message_iter_get_basic(&value2, &name);
+			DBG("name %s", name);
+			specific_scan_list = g_slist_append(specific_scan_list, g_strdup(name));
+		} else if (g_str_equal(key, "Frequency")) {
+			if (type != DBUS_TYPE_STRING) {
+				g_slist_free_full(specific_scan_list, g_free);
+				return __connman_error_invalid_arguments(msg);
+			}
+
+			scan_type = CONNMAN_MULTI_SCAN_FREQ; /* Frequency based scan */
+			dbus_message_iter_get_basic(&value2, &freq);
+			DBG("freq %s", freq);
+			specific_scan_list = g_slist_append(specific_scan_list, GINT_TO_POINTER(atoi(freq)));
+		} else if (g_str_equal(key, "SSID_Mixed")) {
+			if (type != DBUS_TYPE_STRING) {
+				g_slist_free_full(specific_scan_list, g_free);
+				return __connman_error_invalid_arguments(msg);
+			}
+
+			scan_type = CONNMAN_MULTI_SCAN_SSID_FREQ; /* SSID & Frequency mixed scan */
+			dbus_message_iter_get_basic(&value2, &name);
+
+			connman_multi_scan_ap_s *ap =
+					(connman_multi_scan_ap_s*)g_try_malloc0(sizeof(connman_multi_scan_ap_s));
+			if (ap) {
+				g_strlcpy(ap->str, name, strlen(name) + 1);
+				ap->flag = true;
+				specific_scan_list = g_slist_append(specific_scan_list, ap);
+			} else
+				DBG("Failed to allocate memory");
+
+		} else if (g_str_equal(key, "Frequency_Mixed")) {
+			if (type != DBUS_TYPE_STRING) {
+				g_slist_free_full(specific_scan_list, g_free);
+				return __connman_error_invalid_arguments(msg);
+			}
+
+			scan_type = CONNMAN_MULTI_SCAN_SSID_FREQ; /* SSID & Frequency mixed scan */
+			dbus_message_iter_get_basic(&value2, &freq);
+
+			connman_multi_scan_ap_s *ap =
+					(connman_multi_scan_ap_s*)g_try_malloc0(sizeof(connman_multi_scan_ap_s));
+			if (ap) {
+				g_strlcpy(ap->str, freq, strlen(freq) + 1);
+				ap->flag = false;
+				specific_scan_list = g_slist_append(specific_scan_list, ap);
+			} else
+				DBG("Failed to allocate memory");
+		}
+		dbus_message_iter_next(&dict);
+	}
+
+	err = __connman_device_request_specific_scan(technology->type, ifname, scan_type, specific_scan_list);
+	if (err < 0)
+		return __connman_error_failed(msg, -err);
+
+	guint list_size = g_slist_length(specific_scan_list);
+
+	if (scan_type == CONNMAN_MULTI_SCAN_SSID ||
+			scan_type == CONNMAN_MULTI_SCAN_SSID_FREQ)
+		g_slist_free_full(specific_scan_list, g_free);
+
+	struct connman_scan_pending *pending_data =
+			g_try_malloc0(sizeof(struct connman_scan_pending));
+	if (!pending_data)
+		return __connman_error_failed(msg, ENOMEM);
+
+	if (ifname) {
+		pending_data->ifname =  g_strdup(ifname);
+		if (pending_data->ifname == NULL) {
+			g_free(pending_data);
+			return __connman_error_failed(msg, ENOMEM);
+		}
+	}
+
+	if (list_size == 1)
+		pending_data->scan_type = CONNMAN_SCAN_TYPE_SPECIFIC_AP;
+	else
+		pending_data->scan_type = CONNMAN_SCAN_TYPE_MULTI_AP;
+	DBG("list_size %u scan_type %d", list_size, pending_data->scan_type);
+
+	pending_data->msg = dbus_message_ref(msg);
+
+	technology->scan_pending =
+		g_slist_prepend(technology->scan_pending, pending_data);
+
+	return NULL;
+}
+
+static DBusMessage *get_5ghz_supported(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	DBusMessage *reply;
+	DBusMessageIter iter, dict;
+	GSList *list;
+	struct connman_technology *technology = data;
+	dbus_bool_t supported = false;
+	const char *ifname = NULL;
+
+	DBG("technology %p", technology);
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+	connman_dbus_dict_open(&iter, &dict);
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *device = list->data;
+
+		supported = connman_device_get_wifi_5ghz_supported(device);
+		ifname = connman_device_get_string(device, "Interface");
+
+		DBG("ifname %s supported : %d", ifname, supported);
+		connman_dbus_dict_append_basic(&dict, ifname,
+						DBUS_TYPE_BOOLEAN,
+						&supported);
+	}
+
+	connman_dbus_dict_close(&iter, &dict);
+
+	return reply;
+}
+
+static DBusMessage *get_scan_state(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	DBusMessage *reply;
+	DBusMessageIter iter, dict;
+	GSList *list;
+	struct connman_technology *technology = data;
+	dbus_bool_t scanning = false;
+	const char *ifname = NULL;
+
+	DBG("technology %p", technology);
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+	connman_dbus_dict_open(&iter, &dict);
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *device = list->data;
+
+		scanning = connman_device_get_scanning(device, technology->type);
+		ifname = connman_device_get_string(device, "Interface");
+
+		DBG("ifname %s scanning : %d", ifname, scanning);
+		connman_dbus_dict_append_basic(&dict, ifname,
+						DBUS_TYPE_BOOLEAN,
+						&scanning);
+	}
+
+	connman_dbus_dict_close(&iter, &dict);
+
+	return reply;
+}
+
+static DBusMessage *get_max_scan_ssid(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+	DBusMessage *reply;
+	DBusMessageIter iter, dict;
+	GSList *list;
+	struct connman_technology *technology = data;
+	dbus_int32_t max_scan_ssids = 0;
+	const char *ifname = NULL;
+
+	DBG("technology %p", technology);
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+	connman_dbus_dict_open(&iter, &dict);
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *device = list->data;
+
+		max_scan_ssids = connman_device_get_max_scan_ssids(device);
+		ifname = connman_device_get_string(device, "Interface");
+
+		DBG("ifname %s max_scan_ssids : %d", ifname, max_scan_ssids);
+		connman_dbus_dict_append_basic(&dict, ifname,
+				DBUS_TYPE_INT32,
+				&max_scan_ssids);
+	}
+
+	connman_dbus_dict_close(&iter, &dict);
+
+	return reply;
+}
+
+static int technology_enable_device(struct connman_technology *technology,
+				bool enable_device, const char *ifname, struct connman_device **device_out)
+{
+	int err = 0;
+	GSList *list;
+
+	for (list = technology->device_list; list; list = list->next) {
+		struct connman_device *device = list->data;
+		const char *str = connman_device_get_string(device, "Interface");
+
+		if (g_strcmp0(str, ifname) != 0)
+			continue;
+
+		if (enable_device)
+			err = __connman_device_enable(device);
+		else
+			err = __connman_device_disable(device);
+
+		*device_out = device;
+		return err;
+	}
+
+	return -ENXIO;
+}
+
+static DBusMessage *technology_set_device_powered(struct connman_technology *technology,
+				DBusMessage *msg, bool powered, const char *ifname)
+{
+	DBusMessage *reply = NULL;
+	struct connman_device *device = NULL;
+	int err = 0;
+
+	err = technology_enable_device(technology, powered, ifname, &device);
+
+	if (err == -EINPROGRESS) {
+		if (device)
+			connman_device_set_pending_reply(device, msg);
+		return reply;
+	} else if (err == -EALREADY) {
+		if (powered)
+			reply = __connman_error_already_enabled(msg);
+		else
+			reply = __connman_error_already_disabled(msg);
+	} else if (err < 0)
+		reply = __connman_error_failed(msg, -err);
+	else
+		reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage *set_device_power(DBusConnection *conn,
+					DBusMessage *msg, void *data)
+{
+	struct connman_technology *technology = data;
+	DBusMessageIter iter;
+	const char *name;
+	int len;
+	dbus_bool_t enable;
+
+	DBG("conn %p", conn);
+
+	if (!dbus_message_iter_init(msg, &iter))
+		return __connman_error_invalid_arguments(msg);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_get_basic(&iter, &name);
+	dbus_message_iter_next(&iter);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
+		return __connman_error_invalid_arguments(msg);
+
+	DBG("interface name %s", name);
+
+	len = strlen(name);
+
+	if (len + 1 > IFNAMSIZ)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_get_basic(&iter, &enable);
+	DBG("powered %s", enable ? "TRUE" : "FALSE");
+
+	return technology_set_device_powered(technology, msg, enable, name);
+}
+
+static DBusMessage *set_bssid(DBusConnection *conn,
+					DBusMessage *msg, void *data)
+{
+	DBusMessageIter iter;
+	char *name, *bssid;
+	int len;
+
+	DBG("conn %p", conn);
+
+	if (!dbus_message_iter_init(msg, &iter))
+		return __connman_error_invalid_arguments(msg);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_get_basic(&iter, &name);
+	dbus_message_iter_next(&iter);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_get_basic(&iter, &bssid);
+
+	DBG("interface name %s bssid %s", name, bssid);
+
+	len = strlen(name);
+
+	if (len + 1 > IFNAMSIZ)
+		return __connman_error_invalid_arguments(msg);
+
+	set_connman_bssid(SET_BSSID, bssid, name);
+
+	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+static struct connman_technology *technology_get(enum connman_service_type type);
+
+void technology_save_device(struct connman_device *device)
+{
+	struct connman_technology *technology;
+	enum connman_service_type type;
+
+	type = __connman_device_get_service_type(device);
+	technology = technology_get(type);
+	if (!technology)
+		return;
+
+	GKeyFile *keyfile;
+	gchar *identifier;
+	const char *name = get_name(technology->type);
+
+	DBG("technology %p type %d name %s", technology, technology->type,
+									name);
+	if (!name)
+		return;
+
+	keyfile = __connman_storage_load_global();
+	if (!keyfile)
+		keyfile = g_key_file_new();
+
+	identifier = g_strdup_printf("%s", name);
+	if (!identifier)
+		goto done;
+
+	GSList *list = NULL;
+	gchar **ifname_list = NULL;
+	guint dev_count = g_slist_length(technology->device_list);
+
+	if (dev_count > 1) {
+		GString *ifname_str = g_string_new(NULL);
+
+		if (ifname_str) {
+			for (list = technology->device_list; list; list = list->next) {
+				struct connman_device *device = list->data;
+
+				if (connman_device_get_powered(device)) {
+					const char *ifname = connman_device_get_string(device, "Interface");
+
+					if (ifname_str->len > 0)
+						g_string_append_printf(ifname_str, " %s", ifname);
+					else
+						g_string_append(ifname_str, ifname);
+				}
+			}
+
+			if (ifname_str->len > 0) {
+				ifname_list = g_strsplit_set(ifname_str->str, " ", 0);
+				dev_count = g_strv_length(ifname_list);
+				g_key_file_set_string_list(keyfile, identifier, "Enable.Devices",
+								(const gchar **) ifname_list, dev_count);
+
+				technology->enable_persistent = true;
+			} else {
+				g_key_file_remove_key(keyfile, identifier, "Enable.Devices", NULL);
+				technology->enable_persistent = false;
 			}
 
+			g_strfreev(ifname_list);
+			g_string_free(ifname_str, TRUE);
 		}
+	}
 
-		if (!regdom_set)
-			alpha2 = NULL;
+	g_key_file_set_boolean(keyfile, identifier, "Enable",
+				technology->enable_persistent);
+
+	g_key_file_set_boolean(keyfile, identifier, "Tethering",
+				technology->tethering_persistent);
+
+	if (technology->tethering_ident)
+		g_key_file_set_string(keyfile, identifier,
+					"Tethering.Identifier",
+					technology->tethering_ident);
+
+	if (technology->tethering_passphrase)
+		g_key_file_set_string(keyfile, identifier,
+					"Tethering.Passphrase",
+					technology->tethering_passphrase);
+
+done:
+	g_free(identifier);
+
+	__connman_storage_save_global(keyfile);
+
+	g_key_file_free(keyfile);
+}
+#endif
+
+#if defined TIZEN_EXT_WIFI_MESH
+bool __connman_technology_get_connected(enum connman_service_type type)
+{
+	struct connman_technology *technology;
+
+	technology = technology_find(type);
+
+	if (!technology)
+		return false;
+
+	return technology->connected;
+}
+
+void __connman_technology_mesh_interface_create_finished(
+							enum connman_service_type type, bool success,
+							const char *error)
+{
+	DBusMessage *reply;
+	struct connman_technology *technology;
+	DBusMessage *msg;
+	technology = technology_find(type);
+
+	DBG("technology %p success %d", technology, success);
+
+	if (!technology)
+		return;
+
+	msg = technology->mesh_dbus_msg;
+	if (!msg) {
+		DBG("No pending dbus message");
+		return;
 	}
 
-	connman_technology_regdom_notify(technology, alpha2);
+	if (success) {
+		reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+		__connman_device_request_scan(technology->type);
+	} else
+		reply = g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+				".MeshInterfaceAddFailed", "%s", error);
+	g_dbus_send_message(connection, reply);
+	dbus_message_unref(msg);
+	technology->mesh_dbus_msg = NULL;
 }
 
-static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
+void __connman_technology_mesh_interface_remove_finished(
+							enum connman_service_type type, bool success)
+{
+	DBusMessage *reply;
+	struct connman_technology *technology;
+	DBusMessage *msg;
+	technology = technology_find(type);
+
+	DBG("technology %p success %d", technology, success);
+
+	if (!technology || !technology->mesh_dbus_msg)
+		return;
+
+	msg = technology->mesh_dbus_msg;
+	if (!msg) {
+		DBG("No pending dbus message");
+		return;
+	}
+
+	if (success)
+		reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+	else
+		reply = __connman_error_failed(msg, EINVAL);
+	g_dbus_send_message(connection, reply);
+	dbus_message_unref(msg);
+	technology->mesh_dbus_msg = NULL;
+}
+
+void __connman_technology_notify_abort_scan(enum connman_service_type type,
+							int result)
+{
+	DBusMessage *reply;
+	struct connman_technology *technology;
+	DBusMessage *msg;
+	technology = technology_find(type);
+
+	DBG("technology %p result %d", technology, result);
+
+	if (!technology || !technology->mesh_dbus_msg)
+		return;
+
+	msg = technology->mesh_dbus_msg;
+	if (!msg) {
+		DBG("No pending dbus message");
+		return;
+	}
+
+	if (result < 0)
+		reply = __connman_error_scan_abort_failed(msg);
+	else
+		reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+	g_dbus_send_message(connection, reply);
+	dbus_message_unref(msg);
+	technology->mesh_dbus_msg = NULL;
+}
+
+static DBusMessage *mesh_commands(DBusConnection *conn,
+				  DBusMessage *msg, void *data)
 {
 	struct connman_technology *technology = data;
+	DBusMessageIter iter, value, dict;
+	const char *cmd = NULL, *ifname = NULL, *parent_ifname = NULL;
 	int err;
 
-	DBG("technology %p request from %s", technology,
-			dbus_message_get_sender(msg));
+	DBG("conn %p", conn);
 
-	dbus_message_ref(msg);
-	technology->scan_pending =
-		g_slist_prepend(technology->scan_pending, msg);
+	if (technology->type != CONNMAN_SERVICE_TYPE_MESH)
+		return __connman_error_invalid_arguments(msg);
 
-	err = __connman_device_request_scan(technology->type);
-	if (err < 0)
-		reply_scan_pending(technology, err);
+	if (!dbus_message_iter_init(msg, &iter))
+		return __connman_error_invalid_arguments(msg);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_get_basic(&iter, &cmd);
+	dbus_message_iter_next(&iter);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+		return __connman_error_invalid_arguments(msg);
+
+	dbus_message_iter_recurse(&iter, &value);
+
+	if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_ARRAY)
+		return __connman_error_invalid_arguments(msg);
+
+	DBG("Mesh Command %s", cmd);
+	if (g_str_equal(cmd, "MeshInterfaceAdd")) {
+		dbus_message_iter_recurse(&value, &dict);
+		const char *bridge_ifname = NULL;
+		while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+			DBusMessageIter entry, value2;
+			const char *key;
+			int type;
+
+			dbus_message_iter_recurse(&dict, &entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_get_basic(&entry, &key);
+			dbus_message_iter_next(&entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_recurse(&entry, &value2);
+
+			type = dbus_message_iter_get_arg_type(&value2);
+
+			if (g_str_equal(key, "Ifname")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &ifname);
+			} else if (g_str_equal(key, "ParentIfname")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &parent_ifname);
+			} else if (g_str_equal(key, "BridgeIfname")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &bridge_ifname);
+			}
+			dbus_message_iter_next(&dict);
+		}
+		DBG("Mesh Ifname %s parent %s bridge %s", ifname, parent_ifname,
+					bridge_ifname ? bridge_ifname : "NULL");
+		err = __connman_mesh_add_virtual_interface(ifname, parent_ifname,
+							   bridge_ifname);
+
+		if (err != 0) {
+			DBG("Failed to add virtual mesh interface");
+			return __connman_error_failed(msg, -err);
+		}
+
+		DBG("Successfully added virtual mesh interface");
 
+		dbus_message_ref(msg);
+		technology->mesh_dbus_msg = msg;
+
+	} else if (g_str_equal(cmd, "MeshInterfaceRemove")) {
+		dbus_message_iter_recurse(&value, &dict);
+		while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+			DBusMessageIter entry, value2;
+			const char *key;
+			int type;
+
+			dbus_message_iter_recurse(&dict, &entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_get_basic(&entry, &key);
+			dbus_message_iter_next(&entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_recurse(&entry, &value2);
+
+			type = dbus_message_iter_get_arg_type(&value2);
+
+			if (g_str_equal(key, "Ifname")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &ifname);
+			}
+			dbus_message_iter_next(&dict);
+		}
+		DBG("Mesh Ifname %s", ifname);
+		err = __connman_mesh_remove_virtual_interface(ifname);
+
+		if (err != 0) {
+			DBG("Failed to remove virtual mesh interface");
+			return __connman_error_failed(msg, -err);
+		}
+
+		DBG("Successfully removed virtual mesh interface");
+
+		dbus_message_ref(msg);
+		technology->mesh_dbus_msg = msg;
+
+	} else if (g_str_equal(cmd, "MeshCreateNetwork")) {
+		struct connman_mesh *connman_mesh;
+		const char *name = NULL;
+		const char *sec_type = NULL;
+		const char *mesh_ifname = NULL;
+		char *identifier, *group, *address;
+		unsigned int freq = 0;
+		unsigned int ieee80211w = 0;
+		GString *str;
+		int i;
+		dbus_message_iter_recurse(&value, &dict);
+		while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+			DBusMessageIter entry, value2;
+			const char *key;
+			int type;
+
+			dbus_message_iter_recurse(&dict, &entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_get_basic(&entry, &key);
+			dbus_message_iter_next(&entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_recurse(&entry, &value2);
+
+			type = dbus_message_iter_get_arg_type(&value2);
+
+			if (g_str_equal(key, "Name")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &name);
+			} else if (g_str_equal(key, "Frequency")) {
+				if (type != DBUS_TYPE_UINT16)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &freq);
+			} else if (g_str_equal(key, "Security")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &sec_type);
+			} else if (g_str_equal(key, "Pmf")) {
+				if (type != DBUS_TYPE_UINT16)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &ieee80211w);
+			}
+			dbus_message_iter_next(&dict);
+		}
+
+		if (name == NULL || sec_type == NULL || freq == 0)
+			return __connman_error_invalid_arguments(msg);
+
+		DBG("Name %s Frequency %d Security type %s Pmf %u",
+		    name, freq, sec_type, ieee80211w);
+
+		if (g_strcmp0(sec_type, "none") != 0 &&
+		    g_strcmp0(sec_type, "sae") != 0) {
+			DBG("Unsupported security");
+			return __connman_error_invalid_arguments(msg);
+		}
+
+		mesh_ifname = connman_mesh_get_interface_name();
+
+		if (!connman_mesh_is_interface_created()) {
+			DBG("Mesh interface doesn't exists");
+			return __connman_error_invalid_command(msg);
+		}
+
+		str = g_string_sized_new((strlen(name) * 2) + 24);
+
+		for (i = 0; name[i]; i++)
+			g_string_append_printf(str, "%02x", name[i]);
+
+		g_string_append_printf(str, "_mesh");
+
+		if (g_strcmp0(sec_type, "none") == 0)
+			g_string_append_printf(str, "_none");
+		else if (g_strcmp0(sec_type, "sae") == 0)
+			g_string_append_printf(str, "_sae");
+
+		group = g_string_free(str, FALSE);
+
+		identifier = connman_inet_ifaddr(mesh_ifname);
+		address = connman_inet_ifname2addr(mesh_ifname);
+
+		connman_mesh = connman_mesh_create(identifier, group);
+		connman_mesh_set_name(connman_mesh, name);
+		connman_mesh_set_address(connman_mesh, address);
+		connman_mesh_set_security(connman_mesh, sec_type);
+		connman_mesh_set_frequency(connman_mesh, freq);
+		connman_mesh_set_index(connman_mesh, connman_inet_ifindex(mesh_ifname));
+		connman_mesh_set_peer_type(connman_mesh,
+					   CONNMAN_MESH_PEER_TYPE_CREATED);
+		connman_mesh_set_ieee80211w(connman_mesh, ieee80211w);
+
+		connman_mesh_register(connman_mesh);
+		g_free(group);
+		g_free(identifier);
+		g_free(address);
+		DBG("Successfully Created Mesh Network");
+		return  g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+	} else if (g_str_equal(cmd, "AbortScan")) {
+		DBG("Abort Scan method");
+		err = __connman_device_abort_scan(technology->type);
+		if (err != 0) {
+			DBG("Failed to abort scan");
+			return __connman_error_failed(msg, -err);
+		}
+
+		DBG("Successfully requested to abort scan");
+		dbus_message_ref(msg);
+		technology->mesh_dbus_msg = msg;
+
+	} else if (g_str_equal(cmd, "MeshSpecificScan")) {
+		const char *name = NULL;
+		unsigned int freq = 0;
+		dbus_message_iter_recurse(&value, &dict);
+		while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+			DBusMessageIter entry, value2;
+			const char *key;
+			int type;
+
+			dbus_message_iter_recurse(&dict, &entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_get_basic(&entry, &key);
+			dbus_message_iter_next(&entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_recurse(&entry, &value2);
+
+			type = dbus_message_iter_get_arg_type(&value2);
+
+			if (g_str_equal(key, "Name")) {
+				if (type != DBUS_TYPE_STRING)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &name);
+			} else if (g_str_equal(key, "Frequency")) {
+				if (type != DBUS_TYPE_UINT16)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &freq);
+			}
+			dbus_message_iter_next(&dict);
+		}
+
+		DBG("MeshID %s Frequency %d sender %s", name, freq,
+						dbus_message_get_sender(msg));
+
+		struct connman_scan_pending *pending_data =
+				g_try_malloc0(sizeof(struct connman_scan_pending));
+		if (!pending_data)
+			return __connman_error_failed(msg, ENOMEM);
+
+		pending_data->msg = dbus_message_ref(msg);
+
+		technology->scan_pending =
+			g_slist_prepend(technology->scan_pending, pending_data);
+
+		err = __connman_device_request_mesh_specific_scan(technology->type,
+								  name, freq);
+		if (err < 0)
+			reply_scan_pending(technology, err);
+		else
+			DBG("Successfully requested to scan specific Mesh Network");
+
+	} else if (g_str_equal(cmd, "SetMeshGate")) {
+		unsigned int hwmp_rootmode = 0;
+		bool gate_announce = false;
+		unsigned int stp = 0;
+		int err;
+		dbus_message_iter_recurse(&value, &dict);
+		while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+			DBusMessageIter entry, value2;
+			const char *key;
+			int type;
+
+			dbus_message_iter_recurse(&dict, &entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_get_basic(&entry, &key);
+			dbus_message_iter_next(&entry);
+
+			if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+				return __connman_error_invalid_arguments(msg);
+
+			dbus_message_iter_recurse(&entry, &value2);
+
+			type = dbus_message_iter_get_arg_type(&value2);
+
+			if (g_str_equal(key, "GateAnnounce")) {
+				if (type != DBUS_TYPE_BOOLEAN)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &gate_announce);
+			} else if (g_str_equal(key, "HWMPRootMode")) {
+				if (type != DBUS_TYPE_UINT16)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &hwmp_rootmode);
+			} else if (g_str_equal(key, "STP")) {
+				if (type != DBUS_TYPE_UINT16)
+					return __connman_error_invalid_arguments(msg);
+
+				dbus_message_iter_get_basic(&value2, &stp);
+			}
+			dbus_message_iter_next(&dict);
+		}
+
+		DBG("GateAnnounce %d HWMPRootMode %d STP %d sender %s",
+		    gate_announce, hwmp_rootmode, stp, dbus_message_get_sender(msg));
+
+		err = __connman_mesh_set_stp_gate_announce(gate_announce,
+							   hwmp_rootmode,
+							   stp);
+
+		if (err < 0)
+			return __connman_error_failed(msg, -err);
+
+		return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+	} else
+		return __connman_error_invalid_command(msg);
 	return NULL;
 }
+#endif
 
 static const GDBusMethodTable technology_methods[] = {
 	{ GDBUS_DEPRECATED_METHOD("GetProperties",
@@ -1130,22 +2479,41 @@ static const GDBusMethodTable technology_methods[] = {
 			GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
 			NULL, set_property) },
 	{ GDBUS_ASYNC_METHOD("Scan", NULL, NULL, scan) },
+#if defined TIZEN_EXT
+	{ GDBUS_ASYNC_METHOD("ScanDevice", GDBUS_ARGS({ "interface_name", "s" }),
+			NULL, scan_device) },
+	{ GDBUS_ASYNC_METHOD("SpecificScan", GDBUS_ARGS({ "specificscan", "a{sv}" }),
+			NULL, specific_scan) },
+	{ GDBUS_METHOD("GetScanState", NULL, GDBUS_ARGS({ "scan_state", "a{sv}" }),
+			get_scan_state) },
+	{ GDBUS_METHOD("Get5GhzSupported", NULL, GDBUS_ARGS({ "supported", "a{sv}" }),
+			get_5ghz_supported) },
+	{ GDBUS_METHOD("GetMaxScanSsid", NULL, GDBUS_ARGS({ "maxscanssid", "a{sv}" }),
+			get_max_scan_ssid) },
+	{ GDBUS_ASYNC_METHOD("SetDevicePower",
+			GDBUS_ARGS({ "ifname", "s" }, { "value", "b" }),
+			NULL, set_device_power) },
+	{ GDBUS_ASYNC_METHOD("SetBSSID",
+			GDBUS_ARGS({ "ifname", "s" }, { "bssid", "s" }),
+			NULL, set_bssid) },
+#endif
+#if defined TIZEN_EXT_WIFI_MESH
+	{ GDBUS_ASYNC_METHOD("MeshCommands",
+			GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+			NULL, mesh_commands) },
+#endif
 	{ },
 };
 
 static const GDBusSignalTable technology_signals[] = {
 	{ GDBUS_SIGNAL("PropertyChanged",
 			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
-	{ GDBUS_SIGNAL("DhcpConnected",
-			GDBUS_ARGS({ "aptype", "s" },
-				{ "ipaddr", "s" },
-				{ "macaddr", "s" },
-				{ "hostname", "s" })) },
-	{ GDBUS_SIGNAL("DhcpLeaseDeleted",
-			GDBUS_ARGS({ "aptype", "s" },
-				{ "ipaddr", "s" },
-				{ "macaddr", "s" },
-				{ "hostname", "s" })) },
+#if defined TIZEN_EXT
+	{ GDBUS_SIGNAL("DeviceChanged",
+			GDBUS_ARGS({ "device_property", "a{sv}" })) },
+	{ GDBUS_SIGNAL("DeviceDetected",
+			GDBUS_ARGS({ "ifname", "s" }, { "detected", "b" })) },
+#endif
 	{ },
 };
 
@@ -1210,6 +2578,15 @@ static void technology_put(struct connman_technology *technology)
 
 	g_slist_free(technology->device_list);
 
+    if (technology->pending_reply) {
+        dbus_message_unref(technology->pending_reply);
+        technology->pending_reply = NULL;
+        g_source_remove(technology->pending_timeout);
+        technology->pending_timeout = 0;
+    }
+#ifdef TIZEN_EXT
+    g_strfreev(technology->enabled_devices);
+#endif
 	g_free(technology->path);
 	g_free(technology->regdom);
 	g_free(technology->tethering_ident);
@@ -1233,7 +2610,12 @@ static struct connman_technology *technology_get(enum connman_service_type type)
 
 	technology = technology_find(type);
 	if (technology) {
+#if defined TIZEN_EXT_WIFI_MESH
+		if (type != CONNMAN_SERVICE_TYPE_P2P &&
+			type != CONNMAN_SERVICE_TYPE_MESH)
+#else
 		if (type != CONNMAN_SERVICE_TYPE_P2P)
+#endif
 			__sync_fetch_and_add(&technology->refcount, 1);
 		return technology;
 	}
@@ -1260,10 +2642,19 @@ static struct connman_technology *technology_get(enum connman_service_type type)
 
 	technology->refcount = 1;
 	technology->type = type;
-	technology->tethering_hidden = FALSE;
 	technology->path = g_strdup_printf("%s/technology/%s",
 							CONNMAN_PATH, str);
 
+#if defined TIZEN_EXT_WIFI_MESH
+	if (type == CONNMAN_SERVICE_TYPE_MESH) {
+		struct connman_technology *wifi;
+
+		wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+		if (wifi)
+			technology->enabled = wifi->enabled;
+	}
+#endif
+
 	technology_load(technology);
 	technology_list = g_slist_prepend(technology_list, technology);
 	technology->driver_list = tech_drivers;
@@ -1342,6 +2733,13 @@ exist:
 			return -ENOMEM;
 	}
 
+#if defined TIZEN_EXT_WIFI_MESH
+	if (driver->type == CONNMAN_SERVICE_TYPE_MESH) {
+		if (!technology_get(CONNMAN_SERVICE_TYPE_MESH))
+			return -ENOMEM;
+	}
+#endif
+
 	return 0;
 }
 
@@ -1379,6 +2777,13 @@ void connman_technology_driver_unregister(struct connman_technology_driver *driv
 		if (technology)
 			technology_put(technology);
 	}
+#if defined TIZEN_EXT_WIFI_MESH
+	if (driver->type == CONNMAN_SERVICE_TYPE_MESH) {
+		technology = technology_find(CONNMAN_SERVICE_TYPE_MESH);
+		if (technology)
+			technology_put(technology);
+	}
+#endif
 }
 
 void __connman_technology_add_interface(enum connman_service_type type,
@@ -1401,6 +2806,9 @@ void __connman_technology_add_interface(enum connman_service_type type,
 	case CONNMAN_SERVICE_TYPE_VPN:
 	case CONNMAN_SERVICE_TYPE_GADGET:
 	case CONNMAN_SERVICE_TYPE_P2P:
+#if defined TIZEN_EXT_WIFI_MESH
+	case CONNMAN_SERVICE_TYPE_MESH:
+#endif
 		break;
 	}
 
@@ -1452,6 +2860,9 @@ void __connman_technology_remove_interface(enum connman_service_type type,
 	case CONNMAN_SERVICE_TYPE_VPN:
 	case CONNMAN_SERVICE_TYPE_GADGET:
 	case CONNMAN_SERVICE_TYPE_P2P:
+#if defined TIZEN_EXT_WIFI_MESH
+	case CONNMAN_SERVICE_TYPE_MESH:
+#endif
 		break;
 	}
 
@@ -1507,10 +2918,31 @@ int __connman_technology_add_device(struct connman_device *device)
 
 	if (technology->enable_persistent &&
 					!global_offlinemode) {
+#if defined TIZEN_EXT
+		bool found = true;
+		int err = 0;
+		if (technology->enabled_devices) {
+			int i = 0;
+			found = false;
+			const char *ifname = connman_device_get_string(device, "Interface");
+
+			while (technology->enabled_devices[i]) {
+				if (g_strcmp0(technology->enabled_devices[i], ifname) == 0) {
+					found = true;
+					break;
+				}
+				i++;
+			}
+		}
+
+		if (found)
+			err = __connman_device_enable(device);
+#else
 		int err = __connman_device_enable(device);
+#endif
 		/*
 		 * connman_technology_add_device() calls __connman_device_enable()
-		 * but since the device is already enabled, the calls does not
+		 * but since the device is already enabled, the call does not
 		 * propagate through to connman_technology_enabled via
 		 * connman_device_set_powered.
 		 */
@@ -1525,6 +2957,10 @@ done:
 	technology->device_list = g_slist_prepend(technology->device_list,
 								device);
 
+#if defined TIZEN_EXT
+	const char *ifname = connman_device_get_string(device, "Interface");
+	__connman_technology_notify_device_detected(technology, ifname, true);
+#endif
 	return 0;
 }
 
@@ -1547,6 +2983,11 @@ int __connman_technology_remove_device(struct connman_device *device)
 	technology->device_list = g_slist_remove(technology->device_list,
 								device);
 
+#if defined TIZEN_EXT
+	const char *ifname = connman_device_get_string(device, "Interface");
+	__connman_technology_notify_device_detected(technology, ifname, false);
+#endif
+
 	if (technology->tethering)
 		set_tethering(technology, false);
 
@@ -1566,6 +3007,7 @@ int __connman_technology_enabled(enum connman_service_type type)
 	DBG("technology %p type %s rfkill %d enabled %d", technology,
 		get_name(type), technology->rfkill_driven,
 		technology->enabled);
+
 #if !defined TIZEN_EXT
 	if (technology->rfkill_driven) {
 		if (technology->tethering_persistent)
@@ -1585,9 +3027,11 @@ int __connman_technology_disabled(enum connman_service_type type)
 	technology = technology_find(type);
 	if (!technology)
 		return -ENXIO;
+
 #if !defined TIZEN_EXT
 	if (technology->rfkill_driven)
 		return 0;
+
 #endif
 	for (list = technology->device_list; list; list = list->next) {
 		struct connman_device *device = list->data;
@@ -1615,7 +3059,7 @@ int __connman_technology_set_offlinemode(bool offlinemode)
 	 * resuming offlinemode from last saved profile. We need that
 	 * information in rfkill_update, otherwise it falls back on the
 	 * technology's persistent state. Hence we set the offline mode here
-	 * but save it & call the notifier only if its successful.
+	 * but save it & call the notifier only if it is successful.
 	 */
 
 	global_offlinemode = offlinemode;
@@ -1647,6 +3091,15 @@ int __connman_technology_set_offlinemode(bool offlinemode)
 	return err;
 }
 
+#if defined TIZEN_EXT_WIFI_MESH
+static gboolean __add_ethernet_to_bridge(gpointer data)
+{
+	DBG("");
+	__connman_mesh_add_ethernet_to_bridge();
+	return FALSE;
+}
+#endif
+
 void __connman_technology_set_connected(enum connman_service_type type,
 		bool connected)
 {
@@ -1661,6 +3114,11 @@ void __connman_technology_set_connected(enum connman_service_type type,
 
 	technology->connected = connected;
 
+#if defined TIZEN_EXT_WIFI_MESH
+	if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET && connected)
+		g_idle_add(__add_ethernet_to_bridge, NULL);
+#endif
+
 	val = connected;
 	connman_dbus_property_changed_basic(technology->path,
 			CONNMAN_TECHNOLOGY_INTERFACE, "Connected",
@@ -1767,6 +3225,10 @@ int __connman_technology_add_rfkill(unsigned int index,
 	g_hash_table_insert(rfkill_list, GINT_TO_POINTER(index), rfkill);
 
 done:
+#if defined TIZEN_EXT
+	/* Fix Svace Issue [WGID: 1348]. */
+	g_free(rfkill);
+#endif
 	technology = technology_get(type);
 	/* If there is no driver for this type, ignore it. */
 	if (!technology)
@@ -1780,6 +3242,7 @@ done:
 				softblock, hardblock, true))
 		return 0;
 #endif
+
 	if (global_offlinemode)
 		return 0;