X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdhcp.c;h=7c446cf81e246c10418e30ccfdc58a901916c55d;hb=00b8c314dc2cfb641494d413f4b00d90a10ecbeb;hp=0ed5ead8c0fda7aa92e5567e4d6d90f1b6d892e6;hpb=b18d9798b3a0ae46ed87d6d2be8d5a474bf3ab1e;p=platform%2Fupstream%2Fconnman.git

diff --git a/src/dhcp.c b/src/dhcp.c
index 0ed5ead..7c446cf 100644
--- a/src/dhcp.c
+++ b/src/dhcp.c
@@ -2,7 +2,7 @@
  *
  *  Connection Manager
  *
- *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2007-2013  Intel Corporation. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
@@ -26,8 +26,14 @@
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
+#include <net/ethernet.h>
+
+#ifndef IPV6_MIN_MTU
+#define IPV6_MIN_MTU 1280
+#endif
 
 #include <connman/ipconfig.h>
+#include <include/setting.h>
 
 #include <gdhcp/gdhcp.h>
 
@@ -35,21 +41,35 @@
 
 #include "connman.h"
 
+#define RATE_LIMIT_INTERVAL	60	/* delay between successive attempts */
+
 struct connman_dhcp {
+	struct connman_ipconfig *ipconfig;
 	struct connman_network *network;
 	dhcp_cb callback;
+	gpointer user_data;
 
 	char **nameservers;
 	char **timeservers;
 	char *pac;
 
+	unsigned int timeout;
+
+	GDHCPClient *ipv4ll_client;
 	GDHCPClient *dhcp_client;
+	char *ipv4ll_debug_prefix;
+	char *dhcp_debug_prefix;
+
+	bool ipv4ll_running;
 };
 
-static GHashTable *network_table;
+static GHashTable *ipconfig_table;
 
 static void dhcp_free(struct connman_dhcp *dhcp)
 {
+#if defined TIZEN_EXT
+	DBG("dhcp_free [%p]", dhcp);
+#endif
 	g_strfreev(dhcp->nameservers);
 	g_strfreev(dhcp->timeservers);
 	g_free(dhcp->pac);
@@ -57,6 +77,71 @@ static void dhcp_free(struct connman_dhcp *dhcp)
 	dhcp->nameservers = NULL;
 	dhcp->timeservers = NULL;
 	dhcp->pac = NULL;
+
+	g_free(dhcp);
+#if defined TIZEN_EXT
+	dhcp = NULL;
+#endif
+}
+
+static void ipv4ll_stop_client(struct connman_dhcp *dhcp)
+{
+#if defined TIZEN_EXT
+	DBG("dhcp [%p] ipv4ll_client [%p]", dhcp, dhcp->ipv4ll_client);
+#endif
+	if (!dhcp->ipv4ll_client)
+		return;
+
+	g_dhcp_client_stop(dhcp->ipv4ll_client);
+	g_dhcp_client_unref(dhcp->ipv4ll_client);
+	dhcp->ipv4ll_client = NULL;
+	dhcp->ipv4ll_running = false;
+
+	g_free(dhcp->ipv4ll_debug_prefix);
+	dhcp->ipv4ll_debug_prefix = NULL;
+}
+
+static bool apply_dhcp_invalidate_on_network(struct connman_dhcp *dhcp)
+{
+	struct connman_service *service;
+	int i;
+
+	if (!dhcp->network)
+		return true;
+
+	service = connman_service_lookup_from_network(dhcp->network);
+	if (!service) {
+		connman_error("Can not lookup service");
+		return false;
+	}
+
+	__connman_service_set_domainname(service, NULL);
+	__connman_ipconfig_set_proxy_autoconfig(dhcp->ipconfig, NULL);
+
+	if (dhcp->timeservers) {
+		for (i = 0; dhcp->timeservers[i]; i++) {
+			__connman_service_timeserver_remove(service,
+							dhcp->timeservers[i]);
+		}
+		g_strfreev(dhcp->timeservers);
+		dhcp->timeservers = NULL;
+	}
+	if (dhcp->nameservers) {
+		for (i = 0; dhcp->nameservers[i]; i++) {
+#if defined TIZEN_EXT
+			__connman_service_nameserver_remove(service,
+					dhcp->nameservers[i], false,
+					CONNMAN_IPCONFIG_TYPE_IPV4);
+#else
+			__connman_service_nameserver_remove(service,
+						dhcp->nameservers[i], false);
+#endif
+		}
+		g_strfreev(dhcp->nameservers);
+		dhcp->nameservers = NULL;
+	}
+
+	return true;
 }
 
 /**
@@ -71,75 +156,165 @@ static void dhcp_free(struct connman_dhcp *dhcp)
  * service state due to the IP configuration change implied by this
  * invalidation.
  */
-static void dhcp_invalidate(struct connman_dhcp *dhcp, connman_bool_t callback)
+static void dhcp_invalidate(struct connman_dhcp *dhcp, bool callback)
 {
-	struct connman_service *service;
-	struct connman_ipconfig *ipconfig;
-	int i;
-
 	DBG("dhcp %p callback %u", dhcp, callback);
 
-	if (dhcp == NULL)
+	if (!dhcp)
 		return;
 
-	service = __connman_service_lookup_from_network(dhcp->network);
-	if (service == NULL)
-		goto out;
+	__connman_6to4_remove(dhcp->ipconfig);
 
-	ipconfig = __connman_service_get_ip4config(service);
-	if (ipconfig == NULL)
-		goto out;
+	if (!apply_dhcp_invalidate_on_network(dhcp))
+		return;
 
-	__connman_6to4_remove(ipconfig);
+	__connman_ipconfig_set_dhcp_address(dhcp->ipconfig,
+				__connman_ipconfig_get_local(dhcp->ipconfig));
+	DBG("last address %s",
+			__connman_ipconfig_get_dhcp_address(dhcp->ipconfig));
 
-	__connman_service_set_domainname(service, NULL);
-	__connman_service_set_pac(service, NULL);
+	__connman_ipconfig_address_remove(dhcp->ipconfig);
 
-	if (dhcp->timeservers != NULL) {
-		for (i = 0; dhcp->timeservers[i] != NULL; i++) {
-			__connman_service_timeserver_remove(service,
-							dhcp->timeservers[i]);
-		}
+	__connman_ipconfig_set_local(dhcp->ipconfig, NULL);
+	__connman_ipconfig_set_broadcast(dhcp->ipconfig, NULL);
+	__connman_ipconfig_set_gateway(dhcp->ipconfig, NULL);
+	__connman_ipconfig_set_prefixlen(dhcp->ipconfig, 0);
+
+	if (dhcp->callback && callback)
+		dhcp->callback(dhcp->ipconfig, dhcp->network,
+						false, dhcp->user_data);
+}
+
+static void dhcp_valid(struct connman_dhcp *dhcp)
+{
+	if (dhcp->callback)
+		dhcp->callback(dhcp->ipconfig, dhcp->network,
+						true, dhcp->user_data);
+}
+
+static void dhcp_debug(const char *str, void *data)
+{
+	connman_info("%s: %s", (const char *) data, str);
+}
+
+static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data);
+static void ipv4ll_available_cb(GDHCPClient *ipv4ll_client, gpointer user_data);
+
+static int ipv4ll_start_client(struct connman_dhcp *dhcp)
+{
+	GDHCPClient *ipv4ll_client;
+	GDHCPClientError error;
+	const char *hostname;
+	int index;
+	int err;
+
+#if defined TIZEN_EXT
+	DBG("dhcp %p", dhcp);
+#endif
+
+	if (dhcp->ipv4ll_client)
+		return -EALREADY;
+
+	index = __connman_ipconfig_get_index(dhcp->ipconfig);
+
+	ipv4ll_client = g_dhcp_client_new(G_DHCP_IPV4LL, index, &error);
+	if (error != G_DHCP_CLIENT_ERROR_NONE)
+		return -EINVAL;
+
+#if !defined TIZEN_EXT
+	if (getenv("CONNMAN_DHCP_DEBUG")) {
+#endif
+		dhcp->ipv4ll_debug_prefix = g_strdup_printf("IPv4LL index %d",
+							index);
+		g_dhcp_client_set_debug(ipv4ll_client, dhcp_debug,
+					dhcp->ipv4ll_debug_prefix);
+#if !defined TIZEN_EXT
 	}
+#endif
 
-	if (dhcp->nameservers != NULL) {
-		for (i = 0; dhcp->nameservers[i] != NULL; i++) {
-			__connman_service_nameserver_remove(service,
-						dhcp->nameservers[i], FALSE);
-		}
+	g_dhcp_client_set_id(ipv4ll_client);
+
+	if (dhcp->network) {
+		hostname = connman_utsname_get_hostname();
+		if (hostname)
+			g_dhcp_client_set_send(ipv4ll_client,
+						G_DHCP_HOST_NAME, hostname);
 	}
 
-	__connman_ipconfig_set_dhcp_address(ipconfig,
-				__connman_ipconfig_get_local(ipconfig));
-	DBG("last address %s", __connman_ipconfig_get_dhcp_address(ipconfig));
+	g_dhcp_client_register_event(ipv4ll_client,
+			G_DHCP_CLIENT_EVENT_IPV4LL_LOST, ipv4ll_lost_cb, dhcp);
 
-	__connman_ipconfig_address_remove(ipconfig);
+	g_dhcp_client_register_event(ipv4ll_client,
+			G_DHCP_CLIENT_EVENT_IPV4LL_AVAILABLE,
+						ipv4ll_available_cb, dhcp);
 
-	__connman_ipconfig_set_local(ipconfig, NULL);
-	__connman_ipconfig_set_broadcast(ipconfig, NULL);
-	__connman_ipconfig_set_gateway(ipconfig, NULL);
-	__connman_ipconfig_set_prefixlen(ipconfig, 0);
+	dhcp->ipv4ll_client = ipv4ll_client;
 
-	if (dhcp->callback != NULL && callback)
-		dhcp->callback(dhcp->network, FALSE);
+	err = g_dhcp_client_start(dhcp->ipv4ll_client, NULL);
+	if (err < 0) {
+		ipv4ll_stop_client(dhcp);
+		return err;
+	}
 
-out:
-	dhcp_free(dhcp);
+	dhcp->ipv4ll_running = true;
+	return 0;
 }
 
-static void dhcp_valid(struct connman_dhcp *dhcp)
+static gboolean dhcp_retry_cb(gpointer user_data)
 {
-	if (dhcp->callback != NULL)
-		dhcp->callback(dhcp->network, TRUE);
+	struct connman_dhcp *dhcp = user_data;
+
+	dhcp->timeout = 0;
+
+#if defined TIZEN_EXT
+	DBG("dhcp %p", dhcp);
+	DBG("dhcp->timeout %d", dhcp->timeout);
+#endif
+	g_dhcp_client_start(dhcp->dhcp_client,
+			__connman_ipconfig_get_dhcp_address(dhcp->ipconfig));
+
+	return FALSE;
 }
 
 static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data)
 {
 	struct connman_dhcp *dhcp = user_data;
+	int err;
+
+	DBG("No lease available ipv4ll %d client %p", dhcp->ipv4ll_running,
+		dhcp->ipv4ll_client);
+
+#if defined TIZEN_EXT
+	if (dhcp->network &&
+			connman_network_get_bool(dhcp->network, "WiFi.RoamingDHCP")) {
+		connman_network_set_bool(dhcp->network, "WiFi.RoamingDHCP", false);
+		__connman_network_enable_ipconfig(dhcp->network, dhcp->ipconfig);
 
-	DBG("No lease available");
+		return;
+	}
+
+	if (connman_setting_get_bool("EnableAutoIp") == false) {
+		DBG("link-local address autoconfiguration is disabled.");
+		if (dhcp->network)
+			__connman_network_disconnect(dhcp->network);
+		return;
+	}
+#endif
+	if (dhcp->timeout > 0)
+		g_source_remove(dhcp->timeout);
 
-	dhcp_invalidate(dhcp, TRUE);
+	dhcp->timeout = g_timeout_add_seconds(RATE_LIMIT_INTERVAL,
+						dhcp_retry_cb,
+						dhcp);
+	if (dhcp->ipv4ll_running)
+		return;
+
+	err = ipv4ll_start_client(dhcp);
+	if (err < 0)
+		DBG("Cannot start ipv4ll client (%d/%s)", err, strerror(-err));
+
+	/* Only notify upper layer if we have a problem */
+	dhcp_invalidate(dhcp, !dhcp->ipv4ll_running);
 }
 
 static void lease_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
@@ -148,7 +323,8 @@ static void lease_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
 
 	DBG("Lease lost");
 
-	dhcp_invalidate(dhcp, TRUE);
+	/* Upper layer will decide what to do, e.g. nothing or retry. */
+	dhcp_invalidate(dhcp, true);
 }
 
 static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
@@ -157,154 +333,132 @@ static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
 
 	DBG("Lease lost");
 
-	dhcp_invalidate(dhcp, TRUE);
-}
+	ipv4ll_stop_client(dhcp);
 
+	/*
+	 * Since we lost our IPv4LL configuration we might as notify
+	 * the upper layers.
+	 */
+	dhcp_invalidate(dhcp, true);
+}
 
-static gboolean compare_string_arrays(char **array_a, char **array_b)
+static bool compare_string_arrays(char **array_a, char **array_b)
 {
 	int i;
 
-	if (array_a == NULL || array_b == NULL)
-		return FALSE;
+	if (!array_a || !array_b)
+		return false;
 
 	if (g_strv_length(array_a) != g_strv_length(array_b))
-		return FALSE;
+		return false;
 
-	for (i = 0; array_a[i] != NULL &&
-			     array_b[i] != NULL; i++) {
+	for (i = 0; array_a[i] &&
+			     array_b[i]; i++) {
 		if (g_strcmp0(array_a[i], array_b[i]) != 0)
-			return FALSE;
+			return false;
 	}
 
-	return TRUE;
+	return true;
 }
 
-static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
+static bool apply_lease_available_on_network(GDHCPClient *dhcp_client,
+						struct connman_dhcp *dhcp)
 {
-	struct connman_dhcp *dhcp = user_data;
-	GList *list, *option = NULL;
-	char *address, *netmask = NULL, *gateway = NULL;
-	const char *c_address, *c_gateway;
-	char *domainname = NULL, *hostname = NULL;
 	char **nameservers, **timeservers, *pac = NULL;
-	int ns_entries;
-	struct connman_ipconfig *ipconfig;
 	struct connman_service *service;
-	unsigned char prefixlen, c_prefixlen;
-	gboolean ip_change;
+	GList *list, *option = NULL;
+	int ns_entries;
 	int i;
 
-	DBG("Lease available");
+	if (!dhcp->network)
+		return true;
 
-	service = __connman_service_lookup_from_network(dhcp->network);
-	if (service == NULL) {
+	service = connman_service_lookup_from_network(dhcp->network);
+	if (!service) {
 		connman_error("Can not lookup service");
-		return;
+		return false;
 	}
 
-	ipconfig = __connman_service_get_ip4config(service);
-	if (ipconfig == NULL) {
-		connman_error("Could not lookup ipconfig");
-		return;
-	}
+	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_MTU);
+	if (option && option->data) {
+		int mtu, index, err;
 
-	c_address = __connman_ipconfig_get_local(ipconfig);
-	c_gateway = __connman_ipconfig_get_gateway(ipconfig);
-	c_prefixlen = __connman_ipconfig_get_prefixlen(ipconfig);
+		mtu = atoi(option->data);
 
-	address = g_dhcp_client_get_address(dhcp_client);
-
-	__connman_ipconfig_set_dhcp_address(ipconfig, address);
-	DBG("last address %s", address);
+		if (mtu >= IPV6_MIN_MTU && mtu <= ETH_DATA_LEN) {
+			index = __connman_ipconfig_get_index(dhcp->ipconfig);
+			err = connman_inet_set_mtu(index, mtu);
 
-	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
-	if (option != NULL)
-		netmask = g_strdup(option->data);
-
-	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
-	if (option != NULL)
-		gateway = g_strdup(option->data);
-
-	prefixlen = __connman_ipconfig_netmask_prefix_len(netmask);
-
-	DBG("c_address %s", c_address);
+			DBG("MTU %d index %d err %d", mtu, index, err);
+		}
+	}
 
-	if (address != NULL && c_address != NULL &&
-					g_strcmp0(address, c_address) != 0)
-		ip_change = TRUE;
-	else if (gateway != NULL && c_gateway != NULL &&
-					g_strcmp0(gateway, c_gateway) != 0)
-		ip_change = TRUE;
-	else if (prefixlen != c_prefixlen)
-		ip_change = TRUE;
-	else if (c_address == NULL || c_gateway == NULL)
-		ip_change = TRUE;
-	else
-		ip_change = FALSE;
+	option = g_dhcp_client_get_option(dhcp_client, 252);
+	if (option)
+		pac = g_strdup(option->data);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
-	for (ns_entries = 0, list = option; list; list = list->next)
-		ns_entries += 1;
+	ns_entries = g_list_length(option);
 	nameservers = g_try_new0(char *, ns_entries + 1);
-	if (nameservers != NULL) {
-		for (i = 0, list = option; list; list = list->next, i++)
+	if (nameservers) {
+		for (i = 0, list = option;list; list = list->next, i++)
 			nameservers[i] = g_strdup(list->data);
 		nameservers[ns_entries] = NULL;
 	}
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME);
-	if (option != NULL)
-		domainname = g_strdup(option->data);
+	if (option)
+		__connman_service_set_domainname(service, option->data);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_HOST_NAME);
-	if (option != NULL)
-		hostname = g_strdup(option->data);
+	if (option)
+		__connman_service_set_hostname(service, option->data);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_NTP_SERVER);
-	for (ns_entries = 0, list = option; list; list = list->next)
-		ns_entries += 1;
+	ns_entries = g_list_length(option);
 	timeservers = g_try_new0(char *, ns_entries + 1);
-	if (timeservers != NULL) {
+	if (timeservers) {
 		for (i = 0, list = option; list; list = list->next, i++)
 			timeservers[i] = g_strdup(list->data);
 		timeservers[ns_entries] = NULL;
 	}
 
-	option = g_dhcp_client_get_option(dhcp_client, 252);
-	if (option != NULL)
-		pac = g_strdup(option->data);
-
-	__connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_DHCP);
-
-	if (ip_change == TRUE) {
-		__connman_ipconfig_set_local(ipconfig, address);
-		__connman_ipconfig_set_prefixlen(ipconfig, prefixlen);
-		__connman_ipconfig_set_gateway(ipconfig, gateway);
-	}
-
-	if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
-		if (dhcp->nameservers != NULL) {
+	if (!compare_string_arrays(nameservers, dhcp->nameservers)) {
+		if (dhcp->nameservers) {
+#if defined TIZEN_EXT
 			for (i = 0; dhcp->nameservers[i] != NULL; i++) {
 				__connman_service_nameserver_remove(service,
-						dhcp->nameservers[i], FALSE);
+						dhcp->nameservers[i], false,
+						CONNMAN_IPCONFIG_TYPE_IPV4);
+			}
+#else
+			for (i = 0; dhcp->nameservers[i]; i++) {
+				__connman_service_nameserver_remove(service,
+						dhcp->nameservers[i], false);
 			}
+#endif
 			g_strfreev(dhcp->nameservers);
 		}
 
 		dhcp->nameservers = nameservers;
 
-		for (i = 0; dhcp->nameservers[i] != NULL; i++) {
+		for (i = 0; dhcp->nameservers && dhcp->nameservers[i]; i++) {
+#if defined TIZEN_EXT
+			__connman_service_nameserver_append(service,
+						dhcp->nameservers[i], false,
+						CONNMAN_IPCONFIG_TYPE_IPV4);
+#else
 			__connman_service_nameserver_append(service,
-						dhcp->nameservers[i], FALSE);
+						dhcp->nameservers[i], false);
+#endif
 		}
 	} else {
 		g_strfreev(nameservers);
 	}
 
-	if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
-		if (dhcp->timeservers != NULL) {
-			for (i = 0; dhcp->timeservers[i] != NULL; i++) {
+	if (!compare_string_arrays(timeservers, dhcp->timeservers)) {
+		if (dhcp->timeservers) {
+			for (i = 0; dhcp->timeservers[i]; i++) {
 				__connman_service_timeserver_remove(service,
 							dhcp->timeservers[i]);
 			}
@@ -313,7 +467,7 @@ static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
 
 		dhcp->timeservers = timeservers;
 
-		for (i = 0; dhcp->timeservers[i] != NULL; i++) {
+		for (i = 0; dhcp->timeservers && dhcp->timeservers[i]; i++) {
 			__connman_service_timeserver_append(service,
 							dhcp->timeservers[i]);
 		}
@@ -325,56 +479,163 @@ static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
 		g_free(dhcp->pac);
 		dhcp->pac = pac;
 
-		__connman_service_set_pac(service, dhcp->pac);
+		__connman_ipconfig_set_proxy_autoconfig(dhcp->ipconfig,
+								dhcp->pac);
 	}
 
-	__connman_service_set_domainname(service, domainname);
+	if (connman_setting_get_bool("Enable6to4"))
+		__connman_6to4_probe(service);
+
+	return true;
+}
+
+static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+	struct connman_dhcp *dhcp = user_data;
+	GList *option = NULL;
+	enum connman_ipconfig_method old_method;
+	char *address, *netmask = NULL, *gateway = NULL;
+	const char *c_address, *c_gateway;
+	unsigned char prefixlen, c_prefixlen;
+	bool ip_change = false;
+
+	DBG("Lease available");
 
-	if (domainname != NULL)
-		__connman_utsname_set_domainname(domainname);
+	if (dhcp->ipv4ll_client) {
+		ipv4ll_stop_client(dhcp);
+		dhcp_invalidate(dhcp, false);
+	}
 
-	if (hostname != NULL)
-		__connman_utsname_set_hostname(hostname);
+	c_address = __connman_ipconfig_get_local(dhcp->ipconfig);
+	c_gateway = __connman_ipconfig_get_gateway(dhcp->ipconfig);
+	c_prefixlen = __connman_ipconfig_get_prefixlen(dhcp->ipconfig);
 
-	if (ip_change == TRUE)
-		dhcp_valid(dhcp);
+	address = g_dhcp_client_get_address(dhcp_client);
+
+	__connman_ipconfig_set_dhcp_address(dhcp->ipconfig, address);
+	DBG("last address %s", address);
+
+#if defined TIZEN_EXT
+	int dhcp_lease_duration = g_dhcp_client_get_dhcp_lease_duration(dhcp_client);
+#endif
+
+	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
+	if (option)
+		netmask = g_strdup(option->data);
+
+	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
+	if (option)
+		gateway = g_strdup(option->data);
 
-	__connman_6to4_probe(service);
+	prefixlen = connman_ipaddress_calc_netmask_len(netmask);
+	if (prefixlen == 255)
+		connman_warn("netmask: %s is invalid", netmask);
+
+	DBG("c_address %s", c_address);
+
+	if (g_strcmp0(address, c_address)) {
+		ip_change = true;
+		if (c_address) {
+			/* Remove old ip address */
+			__connman_ipconfig_address_remove(dhcp->ipconfig);
+		}
+	}
+	if (g_strcmp0(gateway, c_gateway)) {
+		ip_change = true;
+		if (c_gateway) {
+			/* Remove gateway ip address */
+			__connman_ipconfig_gateway_remove(dhcp->ipconfig);
+		}
+	} else if (prefixlen != c_prefixlen)
+		ip_change = true;
+
+	old_method = __connman_ipconfig_get_method(dhcp->ipconfig);
+	__connman_ipconfig_set_method(dhcp->ipconfig,
+						CONNMAN_IPCONFIG_METHOD_DHCP);
+
+#if defined TIZEN_EXT
+	__connman_ipconfig_set_dhcp_lease_duration(dhcp->ipconfig, dhcp_lease_duration);
+#endif
 
+	/*
+	 * Notify IPv4.Configuration's method moved back to DHCP.
+	 *
+	 * This is the case ConnMan initially set an address by using
+	 * IPv4LL because DHCP failed but now we got an address from DHCP.
+	 */
+	if (old_method == CONNMAN_IPCONFIG_METHOD_AUTO) {
+		struct connman_service *service =
+			connman_service_lookup_from_network(dhcp->network);
+
+		if (service)
+			__connman_service_notify_ipv4_configuration(service);
+	}
+
+#if defined TIZEN_EXT
+	if (connman_network_get_bool(dhcp->network, "WiFi.RoamingDHCP")) {
+
+		if (ip_change)
+			connman_service_notify_reconnection(
+				connman_service_lookup_from_network(dhcp->network));
+
+		connman_network_set_bool(dhcp->network, "WiFi.RoamingDHCP", false);
+	}
+#endif
+
+	if (ip_change) {
+		__connman_ipconfig_set_local(dhcp->ipconfig, address);
+		__connman_ipconfig_set_prefixlen(dhcp->ipconfig, prefixlen);
+		__connman_ipconfig_set_gateway(dhcp->ipconfig, gateway);
+	}
+
+	if (!apply_lease_available_on_network(dhcp_client, dhcp))
+		goto done;
+
+	if (ip_change)
+		dhcp_valid(dhcp);
+
+done:
 	g_free(address);
 	g_free(netmask);
 	g_free(gateway);
-	g_free(domainname);
-	g_free(hostname);
 }
 
-static void ipv4ll_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
+static void ipv4ll_available_cb(GDHCPClient *ipv4ll_client, gpointer user_data)
 {
 	struct connman_dhcp *dhcp = user_data;
+	enum connman_ipconfig_method old_method;
 	char *address, *netmask;
-	struct connman_service *service;
-	struct connman_ipconfig *ipconfig;
 	unsigned char prefixlen;
 
 	DBG("IPV4LL available");
 
-	service = __connman_service_lookup_from_network(dhcp->network);
-	if (service == NULL)
-		return;
+	address = g_dhcp_client_get_address(ipv4ll_client);
+	netmask = g_dhcp_client_get_netmask(ipv4ll_client);
 
-	ipconfig = __connman_service_get_ip4config(service);
-	if (ipconfig == NULL)
-		return;
+	prefixlen = connman_ipaddress_calc_netmask_len(netmask);
 
-	address = g_dhcp_client_get_address(dhcp_client);
-	netmask = g_dhcp_client_get_netmask(dhcp_client);
+	old_method = __connman_ipconfig_get_method(dhcp->ipconfig);
+	__connman_ipconfig_set_method(dhcp->ipconfig,
+						CONNMAN_IPCONFIG_METHOD_AUTO);
 
-	prefixlen = __connman_ipconfig_netmask_prefix_len(netmask);
+	/*
+	 * Notify IPv4.Configuration's method is AUTO now.
+	 *
+	 * This is the case DHCP failed thus ConnMan used IPv4LL to get an
+	 * address. Set IPv4.Configuration method to AUTO allows user to
+	 * ask for a DHCP address by setting the method again to DHCP.
+	 */
+	if (old_method == CONNMAN_IPCONFIG_METHOD_DHCP) {
+		struct connman_service *service =
+			connman_service_lookup_from_network(dhcp->network);
 
-	__connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_DHCP);
-	__connman_ipconfig_set_local(ipconfig, address);
-	__connman_ipconfig_set_prefixlen(ipconfig, prefixlen);
-	__connman_ipconfig_set_gateway(ipconfig, NULL);
+		if (service)
+			__connman_service_notify_ipv4_configuration(service);
+	}
+
+	__connman_ipconfig_set_local(dhcp->ipconfig, address);
+	__connman_ipconfig_set_prefixlen(dhcp->ipconfig, prefixlen);
+	__connman_ipconfig_set_gateway(dhcp->ipconfig, NULL);
 
 	dhcp_valid(dhcp);
 
@@ -382,135 +643,276 @@ static void ipv4ll_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
 	g_free(netmask);
 }
 
-static void dhcp_debug(const char *str, void *data)
-{
-	connman_info("%s: %s\n", (const char *) data, str);
-}
-
-static int dhcp_request(struct connman_dhcp *dhcp)
+static int dhcp_initialize(struct connman_dhcp *dhcp)
 {
-	struct connman_service *service;
-	struct connman_ipconfig *ipconfig;
 	GDHCPClient *dhcp_client;
 	GDHCPClientError error;
-	const char *hostname;
 	int index;
+	const char *vendor_class_id;
 
 	DBG("dhcp %p", dhcp);
 
-	index = connman_network_get_index(dhcp->network);
+	index = __connman_ipconfig_get_index(dhcp->ipconfig);
 
 	dhcp_client = g_dhcp_client_new(G_DHCP_IPV4, index, &error);
 	if (error != G_DHCP_CLIENT_ERROR_NONE)
+#if defined TIZEN_EXT
+	{
+		DBG("failed g_dhcp_client_new(%d), index(%d)", error, index);
+#endif
 		return -EINVAL;
+#if defined TIZEN_EXT
+	}
+#endif
 
-	if (getenv("CONNMAN_DHCP_DEBUG"))
-		g_dhcp_client_set_debug(dhcp_client, dhcp_debug, "DHCP");
+#if !defined TIZEN_EXT
+	if (getenv("CONNMAN_DHCP_DEBUG")) {
+#endif
+		dhcp->dhcp_debug_prefix = g_strdup_printf("DHCP index %d",
+							index);
+		g_dhcp_client_set_debug(dhcp_client, dhcp_debug,
+					dhcp->dhcp_debug_prefix);
+#if !defined TIZEN_EXT
+	}
+#endif
 
 	g_dhcp_client_set_id(dhcp_client);
 
-	hostname = connman_utsname_get_hostname();
-	if (hostname != NULL)
-		g_dhcp_client_set_send(dhcp_client, G_DHCP_HOST_NAME, hostname);
+	if (dhcp->network) {
+		struct connman_service *service;
+		const char *hostname;
+
+		service = connman_service_lookup_from_network(dhcp->network);
+
+		hostname = __connman_service_get_hostname(service);
+		if (!hostname)
+			hostname = connman_utsname_get_hostname();
+
+		if (hostname)
+			g_dhcp_client_set_send(dhcp_client,
+						G_DHCP_HOST_NAME, hostname);
+
+		g_dhcp_client_set_request(dhcp_client, G_DHCP_HOST_NAME);
+		g_dhcp_client_set_request(dhcp_client, G_DHCP_DNS_SERVER);
+		g_dhcp_client_set_request(dhcp_client, G_DHCP_DOMAIN_NAME);
+		g_dhcp_client_set_request(dhcp_client, G_DHCP_NTP_SERVER);
+		g_dhcp_client_set_request(dhcp_client, 252);
+		g_dhcp_client_set_request(dhcp_client, G_DHCP_MTU);
+	}
 
-	g_dhcp_client_set_request(dhcp_client, G_DHCP_HOST_NAME);
-	g_dhcp_client_set_request(dhcp_client, G_DHCP_SUBNET);
-	g_dhcp_client_set_request(dhcp_client, G_DHCP_DNS_SERVER);
-	g_dhcp_client_set_request(dhcp_client, G_DHCP_DOMAIN_NAME);
-	g_dhcp_client_set_request(dhcp_client, G_DHCP_NTP_SERVER);
 	g_dhcp_client_set_request(dhcp_client, G_DHCP_ROUTER);
-	g_dhcp_client_set_request(dhcp_client, 252);
+	g_dhcp_client_set_request(dhcp_client, G_DHCP_SUBNET);
+
+	vendor_class_id = connman_setting_get_string("VendorClassID");
+	if (vendor_class_id)
+		g_dhcp_client_set_send(dhcp_client, G_DHCP_VENDOR_CLASS_ID,
+					vendor_class_id);
 
 	g_dhcp_client_register_event(dhcp_client,
 			G_DHCP_CLIENT_EVENT_LEASE_AVAILABLE,
 						lease_available_cb, dhcp);
 
 	g_dhcp_client_register_event(dhcp_client,
-			G_DHCP_CLIENT_EVENT_IPV4LL_AVAILABLE,
-						ipv4ll_available_cb, dhcp);
-
-	g_dhcp_client_register_event(dhcp_client,
 			G_DHCP_CLIENT_EVENT_LEASE_LOST, lease_lost_cb, dhcp);
 
 	g_dhcp_client_register_event(dhcp_client,
-			G_DHCP_CLIENT_EVENT_IPV4LL_LOST, ipv4ll_lost_cb, dhcp);
-
-	g_dhcp_client_register_event(dhcp_client,
 			G_DHCP_CLIENT_EVENT_NO_LEASE, no_lease_cb, dhcp);
 
 	dhcp->dhcp_client = dhcp_client;
 
-	service = __connman_service_lookup_from_network(dhcp->network);
-	ipconfig = __connman_service_get_ip4config(service);
-
-	return g_dhcp_client_start(dhcp_client,
-				__connman_ipconfig_get_dhcp_address(ipconfig));
+	return 0;
 }
 
 static int dhcp_release(struct connman_dhcp *dhcp)
 {
 	DBG("dhcp %p", dhcp);
 
-	if (dhcp->dhcp_client == NULL)
-		return 0;
+	if (dhcp->timeout > 0) {
+		g_source_remove(dhcp->timeout);
+		dhcp->timeout = 0;
+	}
 
-	g_dhcp_client_stop(dhcp->dhcp_client);
-	g_dhcp_client_unref(dhcp->dhcp_client);
+	if (dhcp->dhcp_client) {
+		g_dhcp_client_stop(dhcp->dhcp_client);
+		g_dhcp_client_unref(dhcp->dhcp_client);
+	}
 
 	dhcp->dhcp_client = NULL;
 
+	g_free(dhcp->dhcp_debug_prefix);
+	dhcp->dhcp_debug_prefix = NULL;
+
+	ipv4ll_stop_client(dhcp);
+
 	return 0;
 }
 
-static void remove_network(gpointer user_data)
+char *__connman_dhcp_get_server_address(struct connman_ipconfig *ipconfig)
 {
-	struct connman_dhcp *dhcp = user_data;
+	struct connman_dhcp *dhcp;
 
-	DBG("dhcp %p", dhcp);
+	dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+	if (!dhcp)
+		return NULL;
 
-	dhcp_invalidate(dhcp, FALSE);
-	dhcp_release(dhcp);
+	return g_dhcp_client_get_server_address(dhcp->dhcp_client);
+}
 
-	g_free(dhcp);
+#if defined TIZEN_EXT_WIFI_MESH
+int __connman_mesh_dhcp_start(struct connman_ipconfig *ipconfig,
+			dhcp_cb callback, gpointer user_data)
+{
+	struct connman_dhcp *dhcp;
+	int err;
+
+	DBG("");
+
+	dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+	if (!dhcp) {
+
+		dhcp = g_try_new0(struct connman_dhcp, 1);
+		if (!dhcp)
+			return -ENOMEM;
+
+		dhcp->ipconfig = ipconfig;
+		__connman_ipconfig_ref(ipconfig);
+
+		err = dhcp_initialize(dhcp);
+
+		if (err < 0) {
+			g_free(dhcp);
+			return err;
+		}
+
+		g_hash_table_insert(ipconfig_table, ipconfig, dhcp);
+	}
+
+	dhcp->callback = callback;
+	dhcp->user_data = user_data;
+	return g_dhcp_client_start(dhcp->dhcp_client, NULL);
 }
+#endif
 
-int __connman_dhcp_start(struct connman_network *network, dhcp_cb callback)
+int __connman_dhcp_start(struct connman_ipconfig *ipconfig,
+			struct connman_network *network, dhcp_cb callback,
+			gpointer user_data)
 {
+#if !defined TIZEN_EXT
+	const char *last_addr = NULL;
+#endif
 	struct connman_dhcp *dhcp;
+	int err;
 
 	DBG("");
 
-	dhcp = g_try_new0(struct connman_dhcp, 1);
-	if (dhcp == NULL)
-		return -ENOMEM;
+	if (network) {
+		struct connman_service *service;
+
+		service = connman_service_lookup_from_network(network);
+		if (!service)
+			return -EINVAL;
+	}
+
+#if !defined TIZEN_EXT
+	last_addr = __connman_ipconfig_get_dhcp_address(ipconfig);
+#endif
+
+	dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+	if (!dhcp) {
+
+		dhcp = g_try_new0(struct connman_dhcp, 1);
+		if (!dhcp)
+			return -ENOMEM;
+
+		dhcp->ipconfig = ipconfig;
+		__connman_ipconfig_ref(ipconfig);
+
+		if (network) {
+			dhcp->network = network;
+			connman_network_ref(network);
+		}
+
+		err = dhcp_initialize(dhcp);
+
+		if (err < 0) {
+			if (network)
+				connman_network_unref(network);
+			g_free(dhcp);
+			return err;
+		}
+
+		g_hash_table_insert(ipconfig_table, ipconfig, dhcp);
+	}
 
-	dhcp->network = network;
 	dhcp->callback = callback;
+	dhcp->user_data = user_data;
 
-	connman_network_ref(network);
+#if defined TIZEN_EXT
+	if (connman_network_get_bool(network, "WiFi.RoamingDHCP")) {
+		const char *last_addr = __connman_ipconfig_get_dhcp_address(ipconfig);
 
-	g_hash_table_replace(network_table, network, dhcp);
+		DBG("Start DHCP with last address request");
+		return g_dhcp_client_start(dhcp->dhcp_client, last_addr);
+	} else {
+		DBG("Start DHCP with DHCPDISCOVER request");
+		return g_dhcp_client_start(dhcp->dhcp_client, NULL);
+	}
+#else
+	return g_dhcp_client_start(dhcp->dhcp_client, last_addr);
+#endif
+}
 
-	return dhcp_request(dhcp);
+void __connman_dhcp_stop(struct connman_ipconfig *ipconfig)
+{
+	struct connman_dhcp *dhcp;
+
+	DBG("ipconfig_table %p ipconfig %p", ipconfig_table, ipconfig);
+
+	if (!ipconfig_table)
+		return;
+
+	dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+	if (dhcp) {
+		g_hash_table_remove(ipconfig_table, ipconfig);
+		__connman_ipconfig_unref(ipconfig);
+		if (dhcp->network)
+			connman_network_unref(dhcp->network);
+		dhcp_release(dhcp);
+		dhcp_invalidate(dhcp, false);
+		dhcp_free(dhcp);
+	}
 }
 
-void __connman_dhcp_stop(struct connman_network *network)
+void __connman_dhcp_decline(struct connman_ipconfig *ipconfig)
 {
-	DBG("");
+	struct connman_dhcp *dhcp;
+	const char *address;
+	struct in_addr addr;
 
-	if (network_table == NULL)
+	DBG("ipconfig_table %p ipconfig %p", ipconfig_table, ipconfig);
+
+	if (!ipconfig_table)
 		return;
 
-	if (g_hash_table_remove(network_table, network) == TRUE)
-		connman_network_unref(network);
+	dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+	if (dhcp) {
+		address = __connman_ipconfig_get_local(ipconfig);
+		if (!address)
+			return;
+
+		if (inet_pton(AF_INET, address, &addr) != 1)
+			connman_error("Could not convert address %s", address);
+
+		g_dhcp_client_decline(dhcp->dhcp_client, htonl(addr.s_addr));
+	}
 }
 
 int __connman_dhcp_init(void)
 {
 	DBG("");
 
-	network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
-							NULL, remove_network);
+	ipconfig_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+								NULL, NULL);
 
 	return 0;
 }
@@ -519,6 +921,6 @@ void __connman_dhcp_cleanup(void)
 {
 	DBG("");
 
-	g_hash_table_destroy(network_table);
-	network_table = NULL;
+	g_hash_table_destroy(ipconfig_table);
+	ipconfig_table = NULL;
 }