X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fconnection.c;h=d40f4281e78ff6eb785ac64ac14f3fcef657e42e;hb=86cd761a6e375875ec904ea378ed61d4fc41e1b8;hp=789a242f88d2e37b42c99a243f24545caa99c565;hpb=70c24bf12e8021c90475c31a488a78470b6bbf01;p=framework%2Fconnectivity%2Fconnman.git

diff --git a/src/connection.c b/src/connection.c
index 789a242..d40f428 100644
--- a/src/connection.c
+++ b/src/connection.c
@@ -2,7 +2,8 @@
  *
  *  Connection Manager
  *
- *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2011  BMW Car IT GmbH. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
@@ -23,6 +24,7 @@
 #include <config.h>
 #endif
 
+#include <errno.h>
 #include <string.h>
 #include <net/if.h>
 
@@ -30,89 +32,292 @@
 
 #include "connman.h"
 
-struct gateway_data {
-	int index;
-	char *ipv4_gateway;
-	char *ipv6_gateway;
-	struct connman_element *element;
-	unsigned int order;
+struct gateway_config {
 	gboolean active;
+	char *gateway;
+
 	/* VPN extra data */
 	gboolean vpn;
 	char *vpn_ip;
 	int vpn_phy_index;
+	char *vpn_phy_ip;
 };
 
-static GSList *gateway_list = NULL;
+struct gateway_data {
+	int index;
+	struct connman_service *service;
+	unsigned int order;
+	struct gateway_config *ipv4_gateway;
+	struct gateway_config *ipv6_gateway;
+	connman_bool_t default_checked;
+};
 
-static struct gateway_data *find_gateway(int index, const char *gateway)
+static GHashTable *gateway_hash = NULL;
+
+static struct gateway_config *find_gateway(int index, const char *gateway)
 {
-	GSList *list;
+	GHashTableIter iter;
+	gpointer value, key;
 
 	if (gateway == NULL)
 		return NULL;
 
-	for (list = gateway_list; list; list = list->next) {
-		struct gateway_data *data = list->data;
+	g_hash_table_iter_init(&iter, gateway_hash);
 
-		if (data->ipv4_gateway == NULL)
-			continue;
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
+
+		if (data->ipv4_gateway != NULL && data->index == index &&
+				g_str_equal(data->ipv4_gateway->gateway,
+					gateway) == TRUE)
+			return data->ipv4_gateway;
+
+		if (data->ipv6_gateway != NULL && data->index == index &&
+				g_str_equal(data->ipv6_gateway->gateway,
+					gateway) == TRUE)
+			return data->ipv6_gateway;
+	}
+
+	return NULL;
+}
+
+static struct gateway_data *lookup_gateway_data(struct gateway_config *config)
+{
+	GHashTableIter iter;
+	gpointer value, key;
+
+	if (config == NULL)
+		return NULL;
 
-		if (data->index == index &&
-				g_str_equal(data->ipv4_gateway, gateway)
-								== TRUE)
+	g_hash_table_iter_init(&iter, gateway_hash);
+
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
+
+		if (data->ipv4_gateway != NULL &&
+				data->ipv4_gateway == config)
+			return data;
+
+		if (data->ipv6_gateway != NULL &&
+				data->ipv6_gateway == config)
 			return data;
 	}
 
 	return NULL;
 }
 
-static int del_routes(struct gateway_data *data)
+/*
+ * Find the gateway that is serving the VPN link
+ */
+static struct gateway_data *find_phy_gateway(int index, const char *gateway)
 {
-	if (data->vpn) {
-		if (data->vpn_phy_index >= 0)
-			connman_inet_del_host_route(data->vpn_phy_index,
-							data->ipv4_gateway);
-		return connman_inet_clear_gateway_address(data->index,
-							data->vpn_ip);
-	} else if (g_strcmp0(data->ipv4_gateway, "0.0.0.0") == 0) {
-		return connman_inet_clear_gateway_interface(data->index);
-	} else {
-		connman_inet_del_ipv6_host_route(data->index,
-						data->ipv6_gateway);
-		connman_inet_clear_ipv6_gateway_address(data->index,
-							data->ipv6_gateway);
-		connman_inet_del_host_route(data->index, data->ipv4_gateway);
-		return connman_inet_clear_gateway_address(data->index,
-							data->ipv4_gateway);
+	GHashTableIter iter;
+	gpointer value, key;
+
+	if (gateway == NULL)
+		return NULL;
+
+	g_hash_table_iter_init(&iter, gateway_hash);
+
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
+
+		if (data->ipv4_gateway != NULL && data->index != index &&
+				g_str_equal(data->ipv4_gateway->gateway,
+					gateway) == TRUE)
+			return data;
+
+		if (data->ipv6_gateway != NULL && data->index != index &&
+				g_str_equal(data->ipv6_gateway->gateway,
+					gateway) == TRUE)
+			return data;
 	}
+
+	return NULL;
 }
 
-static void find_element(struct connman_element *element, gpointer user_data)
+static void set_vpn_routes(struct gateway_data *new_gateway,
+			struct connman_service *service,
+			const char *gateway,
+			enum connman_ipconfig_type type,
+			const char *peer,
+			struct gateway_data *active_gateway)
 {
-	struct gateway_data *data = user_data;
+	struct gateway_config *config;
+	struct gateway_data *data;
+	struct connman_ipconfig *ipconfig;
+	char *dest;
+	int index;
 
-	DBG("element %p name %s", element, element->name);
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+		ipconfig = __connman_service_get_ip4config(service);
+		config = new_gateway->ipv4_gateway;
+	} else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+		ipconfig = __connman_service_get_ip6config(service);
+		config = new_gateway->ipv6_gateway;
+	} else
+		return;
 
-	if (data->element != NULL)
+	if (config == NULL)
+		goto done;
+
+	config->vpn = TRUE;
+	if (peer != NULL)
+		config->vpn_ip = g_strdup(peer);
+	else if (gateway != NULL)
+		config->vpn_ip = g_strdup(gateway);
+
+	index = __connman_ipconfig_get_index(ipconfig);
+	data = find_phy_gateway(index, gateway);
+
+	if (data == NULL)
+		goto done;
+
+	/*
+	 * data->service points now to original
+	 * service that is serving the VPN link
+	 */
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		ipconfig = __connman_service_get_ip4config(data->service);
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		ipconfig = __connman_service_get_ip6config(data->service);
+	else
 		return;
 
-	if (element->index != data->index)
+	if (ipconfig != NULL) {
+		const char *address;
+
+		address = __connman_ipconfig_get_local(ipconfig);
+		config->vpn_phy_ip = g_strdup(address);
+	}
+
+	config->vpn_phy_index = data->index;
+
+	DBG("vpn %s phy %s index %d", config->vpn_ip,
+		config->vpn_phy_ip, config->vpn_phy_index);
+
+done:
+	if (active_gateway == NULL)
 		return;
 
-	data->element = element;
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+		/*
+		 * Special route to VPN server via gateway. This
+		 * is needed so that we can access hosts behind
+		 * the VPN. The route might already exist depending
+		 * on network topology.
+		 */
+		if (active_gateway->ipv4_gateway == NULL)
+			return;
+
+		if (g_strcmp0(active_gateway->ipv4_gateway->gateway,
+							"0.0.0.0") != 0)
+			dest = active_gateway->ipv4_gateway->gateway;
+		else
+			dest = NULL;
+
+		connman_inet_add_host_route(active_gateway->index, gateway,
+									dest);
+
+	} else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+
+		if (active_gateway->ipv6_gateway == NULL)
+			return;
+
+		if (g_strcmp0(active_gateway->ipv6_gateway->gateway,
+								"::") != 0)
+			dest = active_gateway->ipv6_gateway->gateway;
+		else
+			dest = NULL;
+
+		connman_inet_add_ipv6_host_route(active_gateway->index,
+								gateway, dest);
+	}
 }
 
-static struct gateway_data *add_gateway(int index, const char *gateway,
-						const char *ipv6_gateway)
+static int del_routes(struct gateway_data *data,
+			enum connman_ipconfig_type type)
 {
-	struct gateway_data *data;
-	struct connman_service *service;
+	int status4 = 0, status6 = 0;
+	int do_ipv4 = FALSE, do_ipv6 = FALSE;
+
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		do_ipv4 = TRUE;
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		do_ipv6 = TRUE;
+	else
+		do_ipv4 = do_ipv6 = TRUE;
+
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL) {
+		if (data->ipv4_gateway->vpn == TRUE) {
+			status4 = connman_inet_clear_gateway_address(
+						data->index,
+						data->ipv4_gateway->vpn_ip);
+
+		} else if (g_strcmp0(data->ipv4_gateway->gateway,
+							"0.0.0.0") == 0) {
+			status4 = connman_inet_clear_gateway_interface(
+								data->index);
+		} else {
+			connman_inet_del_host_route(data->index,
+						data->ipv4_gateway->gateway);
+			status4 = connman_inet_clear_gateway_address(
+						data->index,
+						data->ipv4_gateway->gateway);
+		}
+	}
+
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL) {
+		if (data->ipv6_gateway->vpn == TRUE) {
+			status6 = connman_inet_clear_ipv6_gateway_address(
+						data->index,
+						data->ipv6_gateway->vpn_ip);
+
+		} else if (g_strcmp0(data->ipv6_gateway->gateway, "::") == 0) {
+			status6 = connman_inet_clear_ipv6_gateway_interface(
+								data->index);
+		} else {
+			connman_inet_del_ipv6_host_route(data->index,
+						data->ipv6_gateway->gateway);
+			status6 = connman_inet_clear_ipv6_gateway_address(
+						data->index,
+						data->ipv6_gateway->gateway);
+		}
+	}
 
-	DBG("index %d ipv4 gateway %s ipv6 gateway %s", index, gateway,
-							ipv6_gateway);
+	return (status4 < 0 ? status4 : status6);
+}
+
+static int disable_gateway(struct gateway_data *data,
+			enum connman_ipconfig_type type)
+{
+	gboolean active = FALSE;
+
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+		if (data->ipv4_gateway != NULL)
+			active = data->ipv4_gateway->active;
+	} else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+		if (data->ipv6_gateway != NULL)
+			active = data->ipv6_gateway->active;
+	} else
+		active = TRUE;
+
+	DBG("type %d active %d", type, active);
+
+	if (active == TRUE)
+		return del_routes(data, type);
+
+	return 0;
+}
+
+static struct gateway_data *add_gateway(struct connman_service *service,
+					int index, const char *gateway,
+					enum connman_ipconfig_type type)
+{
+	struct gateway_data *data, *old;
+	struct gateway_config *config;
 
-	if (strlen(gateway) == 0)
+	if (gateway == NULL || strlen(gateway) == 0)
 		return NULL;
 
 	data = g_try_new0(struct gateway_data, 1);
@@ -120,127 +325,389 @@ static struct gateway_data *add_gateway(int index, const char *gateway,
 		return NULL;
 
 	data->index = index;
-	data->ipv4_gateway = g_strdup(gateway);
-	data->ipv6_gateway = g_strdup(ipv6_gateway);
-	data->active = FALSE;
-	data->element = NULL;
-	data->vpn_ip = NULL;
-	data->vpn = FALSE;
-	data->vpn_phy_index = -1;
-
-	__connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION,
-							find_element, data);
-
-	service = __connman_element_get_service(data->element);
+
+	config = g_try_new0(struct gateway_config, 1);
+	if (config == NULL) {
+		g_free(data);
+		return NULL;
+	}
+
+	config->gateway = g_strdup(gateway);
+	config->vpn_ip = NULL;
+	config->vpn_phy_ip = NULL;
+	config->vpn = FALSE;
+	config->vpn_phy_index = -1;
+	config->active = FALSE;
+
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		data->ipv4_gateway = config;
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		data->ipv6_gateway = config;
+	else {
+		g_free(config->gateway);
+		g_free(config);
+		g_free(data);
+		return NULL;
+	}
+
+	data->service = service;
+
 	data->order = __connman_service_get_order(service);
 
-	gateway_list = g_slist_append(gateway_list, data);
+	/*
+	 * If the service is already in the hash, then we
+	 * must not replace it blindly but disable the gateway
+	 * of the type we are replacing and take the other type
+	 * from old gateway settings.
+	 */
+	old = g_hash_table_lookup(gateway_hash, service);
+	if (old != NULL) {
+		DBG("Replacing gw %p ipv4 %p ipv6 %p", old,
+			old->ipv4_gateway, old->ipv6_gateway);
+		disable_gateway(old, type);
+		if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+			data->ipv6_gateway = old->ipv6_gateway;
+			old->ipv6_gateway = NULL;
+		} else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+			data->ipv4_gateway = old->ipv4_gateway;
+			old->ipv4_gateway = NULL;
+		}
+	} else {
+		/*
+		 * Only take a ref if we are adding new stuff to hash.
+		 */
+		connman_service_ref(service);
+	}
+
+	g_hash_table_replace(gateway_hash, service, data);
 
 	return data;
 }
 
-static void connection_newgateway(int index, const char *gateway)
+static void set_default_gateway(struct gateway_data *data,
+				enum connman_ipconfig_type type)
 {
-	struct gateway_data *data;
+	int index;
+	int status4 = 0, status6 = 0;
+	int do_ipv4 = FALSE, do_ipv6 = FALSE;
 
-	DBG("index %d gateway %s", index, gateway);
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		do_ipv4 = TRUE;
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		do_ipv6 = TRUE;
+	else
+		do_ipv4 = do_ipv6 = TRUE;
 
-	data = find_gateway(index, gateway);
-	if (data == NULL)
-		return;
+	DBG("type %d gateway ipv4 %p ipv6 %p", type, data->ipv4_gateway,
+						data->ipv6_gateway);
 
-	data->active = TRUE;
-}
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
+					data->ipv4_gateway->vpn == TRUE) {
+		connman_inet_set_gateway_address(data->index,
+						data->ipv4_gateway->vpn_ip);
+		connman_inet_add_host_route(data->index,
+					data->ipv4_gateway->vpn_ip, NULL);
+		data->ipv4_gateway->active = TRUE;
 
-static void set_default_gateway(struct gateway_data *data)
-{
-	struct connman_element *element = data->element;
-	struct connman_service *service = NULL;
+		DBG("set %p index %d vpn %s index %d phy %s",
+			data, data->index, data->ipv4_gateway->vpn_ip,
+			data->ipv4_gateway->vpn_phy_index,
+			data->ipv4_gateway->vpn_phy_ip);
 
-	DBG("gateway %s", data->ipv4_gateway);
+		__connman_service_indicate_default(data->service);
 
-	if (data->vpn == TRUE) {
-		connman_inet_set_gateway_address(data->index, data->vpn_ip);
-		data->active = TRUE;
+		return;
+	}
 
-		service = __connman_service_lookup_from_index(data->index);
-		if (service == NULL)
-			return;
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
+					data->ipv6_gateway->vpn == TRUE) {
+		connman_inet_set_ipv6_gateway_address(data->index,
+						data->ipv6_gateway->vpn_ip);
+		connman_inet_add_ipv6_host_route(data->index,
+					data->ipv6_gateway->vpn_ip, NULL);
+		data->ipv6_gateway->active = TRUE;
 
-		__connman_service_indicate_default(service);
+		DBG("set %p index %d vpn %s index %d phy %s",
+			data, data->index, data->ipv6_gateway->vpn_ip,
+			data->ipv6_gateway->vpn_phy_index,
+			data->ipv6_gateway->vpn_phy_ip);
+
+		__connman_service_indicate_default(data->service);
 
 		return;
 	}
 
-	if (g_strcmp0(data->ipv4_gateway, "0.0.0.0") == 0) {
-		if (connman_inet_set_gateway_interface(element->index) < 0)
+	index = __connman_service_get_index(data->service);
+
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
+			g_strcmp0(data->ipv4_gateway->gateway,
+							"0.0.0.0") == 0) {
+		if (connman_inet_set_gateway_interface(index) < 0)
 			return;
 		goto done;
 	}
 
-	connman_inet_set_ipv6_gateway_address(element->index,
-						data->ipv6_gateway);
-	if (connman_inet_set_gateway_address(element->index,
-					data->ipv4_gateway) < 0)
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
+			g_strcmp0(data->ipv6_gateway->gateway,
+							"::") == 0) {
+		if (connman_inet_set_ipv6_gateway_interface(index) < 0)
+			return;
+		goto done;
+	}
+
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL)
+		status6 = connman_inet_set_ipv6_gateway_address(index,
+						data->ipv6_gateway->gateway);
+
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL)
+		status4 = connman_inet_set_gateway_address(index,
+						data->ipv4_gateway->gateway);
+
+	if (status4 < 0 || status6 < 0)
 		return;
 
 done:
-	service = __connman_element_get_service(element);
-	__connman_service_indicate_default(service);
+	__connman_service_indicate_default(data->service);
+}
+
+static void unset_default_gateway(struct gateway_data *data,
+				enum connman_ipconfig_type type)
+{
+	int index;
+	int do_ipv4 = FALSE, do_ipv6 = FALSE;
+
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		do_ipv4 = TRUE;
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		do_ipv6 = TRUE;
+	else
+		do_ipv4 = do_ipv6 = TRUE;
+
+	DBG("type %d gateway ipv4 %p ipv6 %p", type, data->ipv4_gateway,
+						data->ipv6_gateway);
+
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
+					data->ipv4_gateway->vpn == TRUE) {
+		connman_inet_del_host_route(data->index,
+						data->ipv4_gateway->vpn_ip);
+		connman_inet_clear_gateway_address(data->index,
+						data->ipv4_gateway->vpn_ip);
+		data->ipv4_gateway->active = FALSE;
+
+		DBG("unset %p index %d vpn %s index %d phy %s",
+			data, data->index, data->ipv4_gateway->vpn_ip,
+			data->ipv4_gateway->vpn_phy_index,
+			data->ipv4_gateway->vpn_phy_ip);
+
+		return;
+	}
+
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
+					data->ipv6_gateway->vpn == TRUE) {
+		connman_inet_del_ipv6_host_route(data->index,
+						data->ipv6_gateway->vpn_ip);
+		connman_inet_clear_ipv6_gateway_address(data->index,
+						data->ipv6_gateway->vpn_ip);
+		data->ipv6_gateway->active = FALSE;
+
+		DBG("unset %p index %d vpn %s index %d phy %s",
+			data, data->index, data->ipv6_gateway->vpn_ip,
+			data->ipv6_gateway->vpn_phy_index,
+			data->ipv6_gateway->vpn_phy_ip);
+
+		return;
+	}
+
+	index = __connman_service_get_index(data->service);
+
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
+			g_strcmp0(data->ipv4_gateway->gateway,
+							"0.0.0.0") == 0) {
+		connman_inet_clear_gateway_interface(index);
+		return;
+	}
+
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
+			g_strcmp0(data->ipv6_gateway->gateway,
+							"::") == 0) {
+		connman_inet_clear_ipv6_gateway_interface(index);
+		return;
+	}
+
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL)
+		connman_inet_clear_ipv6_gateway_address(index,
+						data->ipv6_gateway->gateway);
+
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL)
+		connman_inet_clear_gateway_address(index,
+						data->ipv4_gateway->gateway);
 }
 
 static struct gateway_data *find_default_gateway(void)
 {
 	struct gateway_data *found = NULL;
 	unsigned int order = 0;
-	GSList *list;
+	GHashTableIter iter;
+	gpointer value, key;
 
-	for (list = gateway_list; list; list = list->next) {
-		struct gateway_data *data = list->data;
+	g_hash_table_iter_init(&iter, gateway_hash);
+
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
 
 		if (found == NULL || data->order > order) {
 			found = data;
 			order = data->order;
+
+			DBG("default %p order %d", found, order);
 		}
 	}
 
 	return found;
 }
 
-static int remove_gateway(struct gateway_data *data)
+static gboolean choose_default_gateway(struct gateway_data *data,
+					struct gateway_data *candidate)
 {
-	int err;
+	gboolean downgraded = FALSE;
+
+	/*
+	 * If the current default is not active, then we mark
+	 * this one as default. If the other one is already active
+	 * we mark this one as non default.
+	 */
+	if (data->ipv4_gateway != NULL) {
+		if (candidate->ipv4_gateway != NULL &&
+				candidate->ipv4_gateway->active == FALSE) {
+			DBG("ipv4 downgrading %p", candidate);
+			unset_default_gateway(candidate,
+						CONNMAN_IPCONFIG_TYPE_IPV4);
+		}
+		if (candidate->ipv4_gateway != NULL &&
+				candidate->ipv4_gateway->active == TRUE &&
+				candidate->order > data->order) {
+			DBG("ipv4 downgrading this %p", data);
+			unset_default_gateway(data,
+						CONNMAN_IPCONFIG_TYPE_IPV4);
+			downgraded = TRUE;
+		}
+	}
 
-	DBG("gateway %s", data->ipv4_gateway);
+	if (data->ipv6_gateway != NULL) {
+		if (candidate->ipv6_gateway != NULL &&
+				candidate->ipv6_gateway->active == FALSE) {
+			DBG("ipv6 downgrading %p", candidate);
+			unset_default_gateway(candidate,
+						CONNMAN_IPCONFIG_TYPE_IPV6);
+		}
 
-	gateway_list = g_slist_remove(gateway_list, data);
+		if (candidate->ipv6_gateway != NULL &&
+				candidate->ipv6_gateway->active == TRUE &&
+				candidate->order > data->order) {
+			DBG("ipv6 downgrading this %p", data);
+			unset_default_gateway(data,
+						CONNMAN_IPCONFIG_TYPE_IPV6);
+			downgraded = TRUE;
+		}
+	}
 
-	if (data->active == TRUE)
-		err = del_routes(data);
-	else
-		err = 0;
+	return downgraded;
+}
 
-	g_free(data->ipv4_gateway);
-	g_free(data->ipv6_gateway);
-	g_free(data->vpn_ip);
-	g_free(data);
+static void connection_newgateway(int index, const char *gateway)
+{
+	struct gateway_config *config;
+	struct gateway_data *data;
+	GHashTableIter iter;
+	gpointer value, key;
+	gboolean found = FALSE;
 
-	return err;
+	DBG("index %d gateway %s", index, gateway);
+
+	config = find_gateway(index, gateway);
+	if (config == NULL)
+		return;
+
+	config->active = TRUE;
+
+	/*
+	 * It is possible that we have two default routes atm
+	 * if there are two gateways waiting rtnl activation at the
+	 * same time.
+	 */
+	data = lookup_gateway_data(config);
+	if (data == NULL)
+		return;
+
+	if (data->default_checked == TRUE)
+		return;
+
+	/*
+	 * The next checks are only done once, otherwise setting
+	 * the default gateway could lead into rtnl forever loop.
+	 */
+
+	g_hash_table_iter_init(&iter, gateway_hash);
+
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *candidate = value;
+
+		if (candidate == data)
+			continue;
+
+		found = choose_default_gateway(data, candidate);
+		if (found == TRUE)
+			break;
+	}
+
+	if (found == FALSE) {
+		if (data->ipv4_gateway != NULL)
+			set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_IPV4);
+
+		if (data->ipv6_gateway != NULL)
+			set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_IPV6);
+	}
+
+	data->default_checked = TRUE;
+}
+
+static void remove_gateway(gpointer user_data)
+{
+	struct gateway_data *data = user_data;
+
+	DBG("gateway ipv4 %p ipv6 %p", data->ipv4_gateway, data->ipv6_gateway);
+
+	if (data->ipv4_gateway != NULL) {
+		g_free(data->ipv4_gateway->gateway);
+		g_free(data->ipv4_gateway->vpn_ip);
+		g_free(data->ipv4_gateway->vpn_phy_ip);
+		g_free(data->ipv4_gateway);
+	}
+
+	if (data->ipv6_gateway != NULL) {
+		g_free(data->ipv6_gateway->gateway);
+		g_free(data->ipv6_gateway->vpn_ip);
+		g_free(data->ipv6_gateway->vpn_phy_ip);
+		g_free(data->ipv6_gateway);
+	}
+
+	g_free(data);
 }
 
 static void connection_delgateway(int index, const char *gateway)
 {
+	struct gateway_config *config;
 	struct gateway_data *data;
 
 	DBG("index %d gateway %s", index, gateway);
 
-	data = find_gateway(index, gateway);
-	if (data != NULL)
-		data->active = FALSE;
+	config = find_gateway(index, gateway);
+	if (config != NULL)
+		config->active = FALSE;
 
 	data = find_default_gateway();
 	if (data != NULL)
-		set_default_gateway(data);
+		set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_ALL);
 }
 
 static struct connman_rtnl connection_rtnl = {
@@ -251,242 +718,407 @@ static struct connman_rtnl connection_rtnl = {
 
 static struct gateway_data *find_active_gateway(void)
 {
-	GSList *list;
+	GHashTableIter iter;
+	gpointer value, key;
 
 	DBG("");
 
-	for (list = gateway_list; list; list = list->next) {
-		struct gateway_data *data = list->data;
+	g_hash_table_iter_init(&iter, gateway_hash);
 
-		if (data->active == TRUE)
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
+
+		if (data->ipv4_gateway != NULL &&
+				data->ipv4_gateway->active == TRUE)
+			return data;
+
+		if (data->ipv6_gateway != NULL &&
+				data->ipv6_gateway->active == TRUE)
 			return data;
 	}
 
 	return NULL;
 }
 
-static int connection_probe(struct connman_element *element)
+static void update_order(void)
 {
-	struct connman_service *service = NULL;
-	const char *gateway = NULL, *ipv6_gateway = NULL;
-	const char *vpn_ip = NULL;
-	const char *domainname = NULL;
-	struct gateway_data *active_gateway = NULL;
-	struct gateway_data *new_gateway = NULL;
+	GHashTableIter iter;
+	gpointer value, key;
 
-	DBG("element %p name %s", element, element->name);
+	DBG("");
 
-	if (element->parent == NULL)
-		return -ENODEV;
+	g_hash_table_iter_init(&iter, gateway_hash);
 
-	/* FIXME: Remove temporarily for the static gateway support */
-	/* if (element->parent->type != CONNMAN_ELEMENT_TYPE_IPV4)
-		return -ENODEV; */
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
 
-	connman_element_get_value(element,
-				CONNMAN_PROPERTY_ID_IPV4_GATEWAY, &gateway);
-	connman_element_get_value(element,
-			CONNMAN_PROPERTY_ID_IPV6_GATEWAY, &ipv6_gateway);
+		data->order = __connman_service_get_order(data->service);
+	}
+}
 
-	connman_element_get_value(element,
-			CONNMAN_PROPERTY_ID_IPV4_PEER, &vpn_ip);
+void __connman_connection_gateway_activate(struct connman_service *service,
+					enum connman_ipconfig_type type)
+{
+	struct gateway_data *data = NULL;
 
-	if (vpn_ip == NULL)
-		connman_element_get_value(element,
-				CONNMAN_PROPERTY_ID_IPV4_ADDRESS, &vpn_ip);
+	data = g_hash_table_lookup(gateway_hash, service);
+	if (data == NULL)
+		return;
+
+	DBG("gateway %p/%p type %d", data->ipv4_gateway,
+					data->ipv6_gateway, type);
 
-	DBG("vpn_ip %s", vpn_ip);
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		data->ipv4_gateway->active = TRUE;
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		data->ipv6_gateway->active = TRUE;
+}
+
+static void add_host_route(int family, int index, const char *gateway,
+			enum connman_service_type service_type)
+{
+	switch (family) {
+	case AF_INET:
+		if (g_strcmp0(gateway, "0.0.0.0") != 0) {
+			/*
+			 * We must not set route to the phy dev gateway in
+			 * VPN link. The packets to VPN link might be routed
+			 * back to itself and not routed into phy link gateway.
+			 */
+			if (service_type != CONNMAN_SERVICE_TYPE_VPN)
+				connman_inet_add_host_route(index, gateway,
+									NULL);
+		} else {
+			/*
+			 * Add host route to P-t-P link so that services can
+			 * be moved around and we can have some link to P-t-P
+			 * network (although those P-t-P links have limited
+			 * usage if default route is not directed to them)
+			 */
+			char *dest;
+			if (connman_inet_get_dest_addr(index, &dest) == 0) {
+				connman_inet_add_host_route(index, dest, NULL);
+				g_free(dest);
+			}
+		}
+		break;
+
+	case AF_INET6:
+		if (g_strcmp0(gateway, "::") != 0) {
+			if (service_type != CONNMAN_SERVICE_TYPE_VPN)
+				connman_inet_add_ipv6_host_route(index,
+								gateway, NULL);
+		} else {
+			/* P-t-P link, add route to destination */
+			char *dest;
+			if (connman_inet_ipv6_get_dest_addr(index,
+								&dest) == 0) {
+				connman_inet_add_ipv6_host_route(index, dest,
+								NULL);
+				g_free(dest);
+			}
+		}
+		break;
+	}
+}
 
-	connman_element_get_value(element,
-			CONNMAN_PROPERTY_ID_DOMAINNAME, &domainname);
+int __connman_connection_gateway_add(struct connman_service *service,
+					const char *gateway,
+					enum connman_ipconfig_type type,
+					const char *peer)
+{
+	struct gateway_data *active_gateway = NULL;
+	struct gateway_data *new_gateway = NULL;
+	enum connman_ipconfig_type type4 = CONNMAN_IPCONFIG_TYPE_UNKNOWN,
+		type6 = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
+	enum connman_service_type service_type =
+					connman_service_get_type(service);
+	int index;
 
-	DBG("ipv4 gateway %s ipv6 gateway %s domainname %s",
-				gateway, ipv6_gateway, domainname);
+	index = __connman_service_get_index(service);
 
 	/*
 	 * If gateway is NULL, it's a point to point link and the default
-	 * gateway is 0.0.0.0, meaning the interface.
+	 * gateway for ipv4 is 0.0.0.0 and for ipv6 is ::, meaning the
+	 * interface
 	 */
-	if (gateway == NULL) {
+	if (gateway == NULL && type == CONNMAN_IPCONFIG_TYPE_IPV4)
 		gateway = "0.0.0.0";
-		element->ipv4.gateway = g_strdup(gateway);
-	}
 
-	connman_element_set_enabled(element, TRUE);
+	if (gateway == NULL && type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		gateway = "::";
 
-	active_gateway = find_active_gateway();
-	new_gateway = add_gateway(element->index, gateway, ipv6_gateway);
+	DBG("service %p index %d gateway %s vpn ip %s type %d",
+		service, index, gateway, peer, type);
+
+	new_gateway = add_gateway(service, index, gateway, type);
 	if (new_gateway == NULL)
-		return 0;
-
-	service = __connman_element_get_service(element);
-
-	if (new_gateway->ipv6_gateway)
-		connman_inet_add_ipv6_host_route(element->index,
-					new_gateway->ipv6_gateway, NULL);
-
-	if (g_strcmp0(new_gateway->ipv4_gateway, "0.0.0.0"))
-		connman_inet_add_host_route(element->index,
-					new_gateway->ipv4_gateway, NULL);
-	__connman_service_nameserver_add_routes(service,
-						new_gateway->ipv4_gateway);
-	__connman_service_set_domainname(service, domainname);
-
-	__connman_service_indicate_state(service, CONNMAN_SERVICE_STATE_READY);
-
-	if (service == NULL) {
-		new_gateway->vpn = TRUE;
-		new_gateway->vpn_ip = g_strdup(vpn_ip);
-		/* make sure vpn gateway are at higher priority */
-		new_gateway->order = 10;
-		if (active_gateway)
-			new_gateway->vpn_phy_index = active_gateway->index;
-	} else
-		new_gateway->vpn = FALSE;
+		return -EINVAL;
+
+	active_gateway = find_active_gateway();
+
+	DBG("active %p index %d new %p", active_gateway,
+		active_gateway ? active_gateway->index : -1, new_gateway);
+
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+				new_gateway->ipv4_gateway != NULL) {
+		add_host_route(AF_INET, index, gateway, service_type);
+		__connman_service_nameserver_add_routes(service,
+					new_gateway->ipv4_gateway->gateway);
+		type4 = CONNMAN_IPCONFIG_TYPE_IPV4;
+	}
+
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+				new_gateway->ipv6_gateway != NULL) {
+		add_host_route(AF_INET6, index, gateway, service_type);
+		__connman_service_nameserver_add_routes(service,
+					new_gateway->ipv6_gateway->gateway);
+		type6 = CONNMAN_IPCONFIG_TYPE_IPV6;
+	}
+
+	if (service_type == CONNMAN_SERVICE_TYPE_VPN) {
+
+		set_vpn_routes(new_gateway, service, gateway, type, peer,
+							active_gateway);
+
+	} else {
+		if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+					new_gateway->ipv4_gateway != NULL)
+			new_gateway->ipv4_gateway->vpn = FALSE;
+
+		if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+					new_gateway->ipv6_gateway != NULL)
+			new_gateway->ipv6_gateway->vpn = FALSE;
+	}
 
 	if (active_gateway == NULL) {
-		set_default_gateway(new_gateway);
-		return 0;
+		set_default_gateway(new_gateway, type);
+		goto done;
 	}
 
-	if (new_gateway->vpn == TRUE) {
-		connman_inet_add_host_route(active_gateway->index,
-						new_gateway->ipv4_gateway,
-						active_gateway->ipv4_gateway);
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+				new_gateway->ipv4_gateway != NULL &&
+				new_gateway->ipv4_gateway->vpn == TRUE) {
+		if (__connman_service_is_split_routing(new_gateway->service) ==
+									FALSE)
+			connman_inet_clear_gateway_address(
+					active_gateway->index,
+					active_gateway->ipv4_gateway->gateway);
 	}
 
-	if (new_gateway->order >= active_gateway->order) {
-		del_routes(active_gateway);
-		return 0;
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+				new_gateway->ipv6_gateway != NULL &&
+				new_gateway->ipv6_gateway->vpn == TRUE) {
+		if (__connman_service_is_split_routing(new_gateway->service) ==
+									FALSE)
+			connman_inet_clear_ipv6_gateway_address(
+					active_gateway->index,
+					active_gateway->ipv6_gateway->gateway);
 	}
 
+done:
+	if (type4 == CONNMAN_IPCONFIG_TYPE_IPV4)
+		__connman_service_ipconfig_indicate_state(service,
+						CONNMAN_SERVICE_STATE_READY,
+						CONNMAN_IPCONFIG_TYPE_IPV4);
+
+	if (type6 == CONNMAN_IPCONFIG_TYPE_IPV6)
+		__connman_service_ipconfig_indicate_state(service,
+						CONNMAN_SERVICE_STATE_READY,
+						CONNMAN_IPCONFIG_TYPE_IPV6);
 	return 0;
 }
 
-static void connection_remove(struct connman_element *element)
+void __connman_connection_gateway_remove(struct connman_service *service,
+					enum connman_ipconfig_type type)
 {
-	struct connman_service *service;
-	const char *gateway = NULL;
 	struct gateway_data *data = NULL;
-	gboolean set_default = FALSE;
+	gboolean set_default4 = FALSE, set_default6 = FALSE;
+	int do_ipv4 = FALSE, do_ipv6 = FALSE;
 	int err;
 
-	DBG("element %p name %s", element, element->name);
+	DBG("service %p type %d", service, type);
 
-	service = __connman_element_get_service(element);
-	__connman_service_nameserver_del_routes(service);
-	__connman_service_indicate_state(service,
-					CONNMAN_SERVICE_STATE_DISCONNECT);
+	if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+		do_ipv4 = TRUE;
+	else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+		do_ipv6 = TRUE;
+	else
+		do_ipv4 = do_ipv6 = TRUE;
 
-	connman_element_set_enabled(element, FALSE);
+	__connman_service_nameserver_del_routes(service, type);
+
+	data = g_hash_table_lookup(gateway_hash, service);
+	if (data == NULL)
+		return;
 
-	connman_element_get_value(element,
-				CONNMAN_PROPERTY_ID_IPV4_GATEWAY, &gateway);
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL)
+		set_default4 = data->ipv4_gateway->vpn;
 
-	DBG("gateway %s", gateway);
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL)
+		set_default6 = data->ipv6_gateway->vpn;
 
-	if (gateway == NULL)
-		return;
+	DBG("ipv4 gateway %s ipv6 gateway %s vpn %d/%d",
+		data->ipv4_gateway ? data->ipv4_gateway->gateway : "<null>",
+		data->ipv6_gateway ? data->ipv6_gateway->gateway : "<null>",
+		set_default4, set_default6);
 
-	data = find_gateway(element->index, gateway);
-	if (data == NULL)
-		return;
+	if (do_ipv4 == TRUE && data->ipv4_gateway != NULL &&
+			data->ipv4_gateway->vpn == TRUE && data->index >= 0)
+		connman_inet_del_host_route(data->index,
+						data->ipv4_gateway->gateway);
 
-	set_default = data->vpn;
+	if (do_ipv6 == TRUE && data->ipv6_gateway != NULL &&
+			data->ipv6_gateway->vpn == TRUE && data->index >= 0)
+		connman_inet_del_ipv6_host_route(data->index,
+						data->ipv6_gateway->gateway);
+
+	err = disable_gateway(data, type);
 
-	if (data->vpn == TRUE && data->vpn_phy_index >= 0)
-		connman_inet_del_host_route(data->vpn_phy_index,
-						data->ipv4_gateway);
-	err = remove_gateway(data);
+	/*
+	 * We remove the service from the hash only if all the gateway
+	 * settings are to be removed.
+	 */
+	if (do_ipv4 == do_ipv6 ||
+		(data->ipv4_gateway != NULL && data->ipv6_gateway == NULL
+			&& do_ipv4 == TRUE) ||
+		(data->ipv6_gateway != NULL && data->ipv4_gateway == NULL
+			&& do_ipv6 == TRUE)
+		) {
+		connman_service_unref(service);
+		g_hash_table_remove(gateway_hash, service);
+	} else
+		DBG("Not yet removing gw ipv4 %p/%d ipv6 %p/%d",
+			data->ipv4_gateway, do_ipv4,
+			data->ipv6_gateway, do_ipv6);
 
 	/* with vpn this will be called after the network was deleted,
 	 * we need to call set_default here because we will not recieve any
 	 * gateway delete notification.
 	 * We hit the same issue if remove_gateway() fails.
 	 */
-	if (set_default || err < 0) {
+	if (set_default4 || set_default6 || err < 0) {
 		data = find_default_gateway();
 		if (data != NULL)
-			set_default_gateway(data);
+			set_default_gateway(data, type);
 	}
-
-	connman_element_unref(element);
 }
 
-static struct connman_driver connection_driver = {
-	.name		= "connection",
-	.type		= CONNMAN_ELEMENT_TYPE_CONNECTION,
-	.priority	= CONNMAN_DRIVER_PRIORITY_LOW,
-	.probe		= connection_probe,
-	.remove		= connection_remove,
-};
-
-int __connman_connection_init(void)
+gboolean __connman_connection_update_gateway(void)
 {
-	DBG("");
+	struct gateway_data *default_gateway;
+	gboolean updated = FALSE;
+	GHashTableIter iter;
+	gpointer value, key;
 
-	if (connman_rtnl_register(&connection_rtnl) < 0)
-		connman_error("Failed to setup RTNL gateway driver");
+	if (gateway_hash == NULL)
+		return updated;
 
-	return connman_driver_register(&connection_driver);
-}
+	update_order();
 
-void __connman_connection_cleanup(void)
-{
-	GSList *list;
+	default_gateway = find_default_gateway();
 
-	DBG("");
+	__connman_service_update_ordering();
 
-	connman_driver_unregister(&connection_driver);
+	DBG("default %p", default_gateway);
 
-	connman_rtnl_unregister(&connection_rtnl);
+	/*
+	 * There can be multiple active gateways so we need to
+	 * check them all.
+	 */
+	g_hash_table_iter_init(&iter, gateway_hash);
+
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *active_gateway = value;
 
-	for (list = gateway_list; list; list = list->next) {
-		struct gateway_data *data = list->data;
+		if (active_gateway == default_gateway)
+			continue;
 
-		DBG("index %d gateway %s", data->index, data->ipv4_gateway);
+		if (active_gateway->ipv4_gateway != NULL &&
+				active_gateway->ipv4_gateway->active == TRUE) {
 
-		g_free(data->ipv4_gateway);
-		g_free(data);
-		list->data = NULL;
+			unset_default_gateway(active_gateway,
+						CONNMAN_IPCONFIG_TYPE_IPV4);
+			updated = TRUE;
+		}
+
+		if (active_gateway->ipv6_gateway != NULL &&
+				active_gateway->ipv6_gateway->active == TRUE) {
+
+			unset_default_gateway(active_gateway,
+						CONNMAN_IPCONFIG_TYPE_IPV6);
+			updated = TRUE;
+		}
 	}
 
-	g_slist_free(gateway_list);
-	gateway_list = NULL;
+	if (updated && default_gateway != NULL) {
+		if (default_gateway->ipv4_gateway)
+			set_default_gateway(default_gateway,
+					CONNMAN_IPCONFIG_TYPE_IPV4);
+
+		if (default_gateway->ipv6_gateway)
+			set_default_gateway(default_gateway,
+					CONNMAN_IPCONFIG_TYPE_IPV6);
+	}
+
+	return updated;
 }
 
-static void update_order(void)
+int __connman_connection_get_vpn_index(int phy_index)
 {
-	GSList *list = NULL;
+	GHashTableIter iter;
+	gpointer value, key;
 
-	for (list = gateway_list; list; list = list->next) {
-		struct gateway_data *data = list->data;
-		struct connman_service *service;
-		int index = data->index;
+	g_hash_table_iter_init(&iter, gateway_hash);
 
-		if (data->vpn)
-			service = __connman_service_lookup_from_index(index);
-		else
-			service = __connman_element_get_service(data->element);
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
 
-		data->order = __connman_service_get_order(service);
+		if (data->ipv4_gateway != NULL &&
+				data->ipv4_gateway->vpn_phy_index == phy_index)
+			return data->index;
+
+		if (data->ipv6_gateway != NULL &&
+				data->ipv6_gateway->vpn_phy_index == phy_index)
+			return data->index;
 	}
+
+	return -1;
 }
 
-gboolean __connman_connection_update_gateway(void)
+int __connman_connection_init(void)
 {
-	struct gateway_data *active_gateway, *default_gateway;
-	gboolean updated = FALSE;
+	int err;
 
-	update_order();
+	DBG("");
 
-	active_gateway = find_active_gateway();
-	default_gateway = find_default_gateway();
+	gateway_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+							NULL, remove_gateway);
+
+	err = connman_rtnl_register(&connection_rtnl);
+	if (err < 0)
+		connman_error("Failed to setup RTNL gateway driver");
+
+	return err;
+}
 
-	if (active_gateway && active_gateway != default_gateway) {
-		del_routes(active_gateway);
-		updated = TRUE;
+void __connman_connection_cleanup(void)
+{
+	GHashTableIter iter;
+	gpointer value, key;
+
+	DBG("");
+
+	connman_rtnl_unregister(&connection_rtnl);
+
+	g_hash_table_iter_init(&iter, gateway_hash);
+
+	while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
+		struct gateway_data *data = value;
+
+		disable_gateway(data, CONNMAN_IPCONFIG_TYPE_ALL);
 	}
 
-	return updated;
+	g_hash_table_destroy(gateway_hash);
+	gateway_hash = NULL;
 }