X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdhcp.c;h=3425b6d19d4986bbce2653d7bd1092738c250265;hb=2973e70796e17cff8b76b747f4fc45e77c208681;hp=163b0b7e656de24ac630b553a5d8eda4ded3b6a5;hpb=1ffd50749f3ae71bd87a6355b64f09575173868a;p=framework%2Fconnectivity%2Fconnman.git

diff --git a/src/dhcp.c b/src/dhcp.c
index 163b0b7..3425b6d 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-2012  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
@@ -27,100 +27,110 @@
 #include <string.h>
 #include <stdlib.h>
 
+#include <connman/ipconfig.h>
+
 #include <gdhcp/gdhcp.h>
 
 #include <glib.h>
 
 #include "connman.h"
 
-enum connman_dhcp_state {
-	CONNMAN_DHCP_STATE_UNKNOWN  = 0,
-	CONNMAN_DHCP_STATE_IDLE     = 1,
-	CONNMAN_DHCP_STATE_BOUND    = 2,
-	CONNMAN_DHCP_STATE_RENEW    = 3,
-	CONNMAN_DHCP_STATE_FAIL     = 4,
-};
-
 struct connman_dhcp {
-	GDHCPClient *dhcp_client;
+	struct connman_network *network;
+	dhcp_cb callback;
 
-	int index;
-	enum connman_dhcp_state state;
+	char **nameservers;
+	char **timeservers;
+	char *pac;
 
-	struct connman_element *element;
+	GDHCPClient *dhcp_client;
 };
 
-static void dhcp_set_value(struct connman_dhcp *dhcp,
-				const char *key, const char *value)
+static GHashTable *network_table;
+
+static void dhcp_free(struct connman_dhcp *dhcp)
 {
-	char **nameservers;
+	g_strfreev(dhcp->nameservers);
+	g_strfreev(dhcp->timeservers);
+	g_free(dhcp->pac);
 
-	if (g_strcmp0(key, "Address") == 0) {
-		g_free(dhcp->element->ipv4.address);
-		dhcp->element->ipv4.address = g_strdup(value);
-	} else if (g_strcmp0(key, "Netmask") == 0) {
-		g_free(dhcp->element->ipv4.netmask);
-		dhcp->element->ipv4.netmask = g_strdup(value);
-	} else if (g_strcmp0(key, "Gateway") == 0) {
-		g_free(dhcp->element->ipv4.gateway);
-		dhcp->element->ipv4.gateway = g_strdup(value);
-	} else if (g_strcmp0(key, "Network") == 0) {
-		g_free(dhcp->element->ipv4.network);
-		dhcp->element->ipv4.network = g_strdup(value);
-	} else if (g_strcmp0(key, "Broadcast") == 0) {
-		g_free(dhcp->element->ipv4.broadcast);
-		dhcp->element->ipv4.broadcast = g_strdup(value);
-	} else if (g_strcmp0(key, "Nameserver") == 0) {
-		g_free(dhcp->element->ipv4.nameserver);
-		nameservers = g_strsplit_set(value, " ", 0);
-		/* FIXME: The ipv4 structure can only hold one nameserver, so
-		 * we are only able to pass along the first nameserver sent by
-		 * the DHCP server.  If this situation changes, we should
-		 * retain all of them.
-		 */
-		dhcp->element->ipv4.nameserver = g_strdup(nameservers[0]);
-		g_strfreev(nameservers);
-	} else if (g_strcmp0(key, "Domainname") == 0) {
-		g_free(dhcp->element->domainname);
-		dhcp->element->domainname = g_strdup(value);
-
-		__connman_utsname_set_domainname(value);
-	} else if (g_strcmp0(key, "Hostname") == 0) {
-		g_free(dhcp->element->hostname);
-		dhcp->element->hostname = g_strdup(value);
-
-		__connman_utsname_set_hostname(value);
-	} else if (g_strcmp0(key, "Timeserver") == 0) {
-		connman_info("Timeserver %s", value);
-
-		g_free(dhcp->element->ipv4.timeserver);
-		dhcp->element->ipv4.timeserver = g_strdup(value);
-	} else if (g_strcmp0(key, "MTU") == 0) {
-	} else if (g_strcmp0(key, "PAC") == 0) {
-		connman_info("PAC configuration %s", value);
-
-		g_free(dhcp->element->ipv4.pac);
-		dhcp->element->ipv4.pac = g_strdup(value);
-	}
+	dhcp->nameservers = NULL;
+	dhcp->timeservers = NULL;
+	dhcp->pac = NULL;
 }
 
-static void dhcp_bound(struct connman_dhcp *dhcp)
+/**
+ * dhcp_invalidate: Invalidate an existing DHCP lease
+ * @dhcp: pointer to the DHCP lease to invalidate.
+ * @callback: flag indicating whether or not to invoke the client callback
+ *            if present.
+ *
+ * Invalidates an existing DHCP lease, optionally invoking the client
+ * callback. The caller may wish to avoid the client callback invocation
+ * when the invocation of that callback might otherwise unnecessarily upset
+ * service state due to the IP configuration change implied by this
+ * invalidation.
+ */
+static void dhcp_invalidate(struct connman_dhcp *dhcp, connman_bool_t callback)
 {
-	struct connman_element *element;
+	struct connman_service *service;
+	struct connman_ipconfig *ipconfig;
+	int i;
 
-	DBG("dhcp %p", dhcp);
+	DBG("dhcp %p callback %u", dhcp, callback);
 
-	element = connman_element_create(NULL);
-	if (element == NULL)
+	if (dhcp == NULL)
 		return;
 
-	element->type = CONNMAN_ELEMENT_TYPE_IPV4;
-	element->index = dhcp->index;
+	service = __connman_service_lookup_from_network(dhcp->network);
+	if (service == NULL)
+		goto out;
+
+	ipconfig = __connman_service_get_ip4config(service);
+	if (ipconfig == NULL)
+		goto out;
 
-	connman_element_update(dhcp->element);
+	__connman_6to4_remove(ipconfig);
 
-	if (connman_element_register(element, dhcp->element) < 0)
-		connman_element_unref(element);
+	__connman_service_set_domainname(service, NULL);
+	__connman_service_set_pac(service, NULL);
+
+	if (dhcp->timeservers != NULL) {
+		for (i = 0; dhcp->timeservers[i] != NULL; i++) {
+			__connman_service_timeserver_remove(service,
+							dhcp->timeservers[i]);
+		}
+	}
+
+	if (dhcp->nameservers != NULL) {
+		for (i = 0; dhcp->nameservers[i] != NULL; i++) {
+			__connman_service_nameserver_remove(service,
+						dhcp->nameservers[i], FALSE);
+		}
+	}
+
+	__connman_ipconfig_set_dhcp_address(ipconfig,
+				__connman_ipconfig_get_local(ipconfig));
+	DBG("last address %s", __connman_ipconfig_get_dhcp_address(ipconfig));
+
+	__connman_ipconfig_address_remove(ipconfig);
+
+	__connman_ipconfig_set_local(ipconfig, NULL);
+	__connman_ipconfig_set_broadcast(ipconfig, NULL);
+	__connman_ipconfig_set_gateway(ipconfig, NULL);
+	__connman_ipconfig_set_prefixlen(ipconfig, 0);
+
+	if (dhcp->callback != NULL && callback)
+		dhcp->callback(dhcp->network, FALSE);
+
+out:
+	dhcp_free(dhcp);
+}
+
+static void dhcp_valid(struct connman_dhcp *dhcp)
+{
+	if (dhcp->callback != NULL)
+		dhcp->callback(dhcp->network, TRUE);
 }
 
 static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data)
@@ -129,13 +139,16 @@ static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data)
 
 	DBG("No lease available");
 
-	connman_element_set_error(dhcp->element,
-					CONNMAN_ELEMENT_ERROR_FAILED);
+	dhcp_invalidate(dhcp, TRUE);
 }
 
 static void lease_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
 {
+	struct connman_dhcp *dhcp = user_data;
+
 	DBG("Lease lost");
+
+	dhcp_invalidate(dhcp, TRUE);
 }
 
 static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
@@ -144,85 +157,231 @@ static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
 
 	DBG("Lease lost");
 
-	connman_element_unregister_children(dhcp->element);
+	dhcp_invalidate(dhcp, TRUE);
+}
+
+
+static gboolean compare_string_arrays(char **array_a, char **array_b)
+{
+	int i;
+
+	if (array_a == NULL || array_b == NULL)
+		return FALSE;
+
+	if (g_strv_length(array_a) != g_strv_length(array_b))
+		return FALSE;
+
+	for (i = 0; array_a[i] != NULL &&
+			     array_b[i] != NULL; i++) {
+		if (g_strcmp0(array_a[i], array_b[i]) != 0)
+			return FALSE;
+	}
+
+	return TRUE;
 }
 
 static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
 {
 	struct connman_dhcp *dhcp = user_data;
 	GList *list, *option = NULL;
-	char *address, *nameservers;
-	size_t ns_strlen = 0;
+	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;
+	int i;
 
 	DBG("Lease available");
 
+	service = __connman_service_lookup_from_network(dhcp->network);
+	if (service == NULL) {
+		connman_error("Can not lookup service");
+		return;
+	}
+
+	ipconfig = __connman_service_get_ip4config(service);
+	if (ipconfig == NULL) {
+		connman_error("Could not lookup ipconfig");
+		return;
+	}
+
+	c_address = __connman_ipconfig_get_local(ipconfig);
+	c_gateway = __connman_ipconfig_get_gateway(ipconfig);
+	c_prefixlen = __connman_ipconfig_get_prefixlen(ipconfig);
+
 	address = g_dhcp_client_get_address(dhcp_client);
-	if (address != NULL)
-		dhcp_set_value(dhcp, "Address", address);
-	g_free(address);
+
+	__connman_ipconfig_set_dhcp_address(ipconfig, address);
+	DBG("last address %s", address);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
 	if (option != NULL)
-		dhcp_set_value(dhcp, "Netmask", option->data);
+		netmask = g_strdup(option->data);
 
-	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
-	for (list = option; list; list = list->next)
-		ns_strlen += strlen((char *) list->data) + 2;
-	nameservers = g_try_malloc0(ns_strlen);
-	if (nameservers) {
-		char *ns_index = nameservers;
-
-		for (list = option; list; list = list->next) {
-			sprintf(ns_index, "%s ", (char *) list->data);
-			ns_index += strlen((char *) list->data) + 1;
-		}
+	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);
+	if (prefixlen == 255)
+		connman_warn("netmask: %s is invalid", netmask);
+
+	DBG("c_address %s", c_address);
+
+	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;
 
-		dhcp_set_value(dhcp, "Nameserver", nameservers);
+	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
+	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++)
+			nameservers[i] = g_strdup(list->data);
+		nameservers[ns_entries] = NULL;
 	}
-	g_free(nameservers);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME);
 	if (option != NULL)
-		dhcp_set_value(dhcp, "Domainname", option->data);
-
-	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
-	if (option != NULL)
-		dhcp_set_value(dhcp, "Gateway", option->data);
+		domainname = g_strdup(option->data);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_HOST_NAME);
 	if (option != NULL)
-		dhcp_set_value(dhcp, "Hostname", option->data);
+		hostname = g_strdup(option->data);
 
 	option = g_dhcp_client_get_option(dhcp_client, G_DHCP_NTP_SERVER);
-	if (option != NULL)
-		dhcp_set_value(dhcp, "Timeserver", option->data);
+	ns_entries = g_list_length(option);
+	timeservers = g_try_new0(char *, ns_entries + 1);
+	if (timeservers != NULL) {
+		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)
-		dhcp_set_value(dhcp, "PAC", option->data);
+		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) {
+			for (i = 0; dhcp->nameservers[i] != NULL; i++) {
+				__connman_service_nameserver_remove(service,
+						dhcp->nameservers[i], FALSE);
+			}
+			g_strfreev(dhcp->nameservers);
+		}
+
+		dhcp->nameservers = nameservers;
+
+		for (i = 0; dhcp->nameservers != NULL &&
+					dhcp->nameservers[i] != NULL; i++) {
+			__connman_service_nameserver_append(service,
+						dhcp->nameservers[i], FALSE);
+		}
+	} else {
+		g_strfreev(nameservers);
+	}
+
+	if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
+		if (dhcp->timeservers != NULL) {
+			for (i = 0; dhcp->timeservers[i] != NULL; i++) {
+				__connman_service_timeserver_remove(service,
+							dhcp->timeservers[i]);
+			}
+			g_strfreev(dhcp->timeservers);
+		}
+
+		dhcp->timeservers = timeservers;
+
+		for (i = 0; dhcp->timeservers != NULL &&
+					 dhcp->timeservers[i] != NULL; i++) {
+			__connman_service_timeserver_append(service,
+							dhcp->timeservers[i]);
+		}
+	} else {
+		g_strfreev(timeservers);
+	}
+
+	if (g_strcmp0(pac, dhcp->pac) != 0) {
+		g_free(dhcp->pac);
+		dhcp->pac = pac;
+
+		__connman_service_set_pac(service, dhcp->pac);
+	}
+
+	__connman_service_set_domainname(service, domainname);
+
+	if (domainname != NULL)
+		__connman_utsname_set_domainname(domainname);
+
+	if (hostname != NULL)
+		__connman_utsname_set_hostname(hostname);
+
+	if (ip_change == TRUE)
+		dhcp_valid(dhcp);
 
-	dhcp_bound(dhcp);
+	__connman_6to4_probe(service);
+
+	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)
 {
 	struct connman_dhcp *dhcp = user_data;
 	char *address, *netmask;
+	struct connman_service *service;
+	struct connman_ipconfig *ipconfig;
+	unsigned char prefixlen;
 
 	DBG("IPV4LL available");
 
-	address = g_dhcp_client_get_address(dhcp_client);
-	if (address != NULL)
-		dhcp_set_value(dhcp, "Address", address);
+	service = __connman_service_lookup_from_network(dhcp->network);
+	if (service == NULL)
+		return;
+
+	ipconfig = __connman_service_get_ip4config(service);
+	if (ipconfig == NULL)
+		return;
 
+	address = g_dhcp_client_get_address(dhcp_client);
 	netmask = g_dhcp_client_get_netmask(dhcp_client);
-	if (netmask != NULL)
-		dhcp_set_value(dhcp, "Netmask", netmask);
+
+	prefixlen = __connman_ipconfig_netmask_prefix_len(netmask);
+
+	__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);
+
+	dhcp_valid(dhcp);
 
 	g_free(address);
 	g_free(netmask);
-
-	dhcp_bound(dhcp);
 }
 
 static void dhcp_debug(const char *str, void *data)
@@ -232,6 +391,8 @@ static void dhcp_debug(const char *str, void *data)
 
 static int dhcp_request(struct connman_dhcp *dhcp)
 {
+	struct connman_service *service;
+	struct connman_ipconfig *ipconfig;
 	GDHCPClient *dhcp_client;
 	GDHCPClientError error;
 	const char *hostname;
@@ -239,7 +400,7 @@ static int dhcp_request(struct connman_dhcp *dhcp)
 
 	DBG("dhcp %p", dhcp);
 
-	index = dhcp->index;
+	index = connman_network_get_index(dhcp->network);
 
 	dhcp_client = g_dhcp_client_new(G_DHCP_IPV4, index, &error);
 	if (error != G_DHCP_CLIENT_ERROR_NONE)
@@ -248,6 +409,8 @@ static int dhcp_request(struct connman_dhcp *dhcp)
 	if (getenv("CONNMAN_DHCP_DEBUG"))
 		g_dhcp_client_set_debug(dhcp_client, dhcp_debug, "DHCP");
 
+	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);
@@ -279,79 +442,85 @@ static int dhcp_request(struct connman_dhcp *dhcp)
 
 	dhcp->dhcp_client = dhcp_client;
 
-	return g_dhcp_client_start(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));
 }
 
 static int dhcp_release(struct connman_dhcp *dhcp)
 {
 	DBG("dhcp %p", dhcp);
 
+	if (dhcp->dhcp_client == NULL)
+		return 0;
+
 	g_dhcp_client_stop(dhcp->dhcp_client);
 	g_dhcp_client_unref(dhcp->dhcp_client);
 
+	dhcp->dhcp_client = NULL;
+
 	return 0;
 }
 
-static int dhcp_probe(struct connman_element *element)
+static void remove_network(gpointer user_data)
+{
+	struct connman_dhcp *dhcp = user_data;
+
+	DBG("dhcp %p", dhcp);
+
+	dhcp_invalidate(dhcp, FALSE);
+	dhcp_release(dhcp);
+
+	g_free(dhcp);
+}
+
+int __connman_dhcp_start(struct connman_network *network, dhcp_cb callback)
 {
 	struct connman_dhcp *dhcp;
 
-	DBG("element %p name %s", element, element->name);
+	DBG("");
 
 	dhcp = g_try_new0(struct connman_dhcp, 1);
 	if (dhcp == NULL)
 		return -ENOMEM;
 
-	dhcp->index = element->index;
-	dhcp->state = CONNMAN_DHCP_STATE_IDLE;
+	dhcp->network = network;
+	dhcp->callback = callback;
 
-	dhcp->element = element;
+	connman_network_ref(network);
 
-	connman_element_set_data(element, dhcp);
+	g_hash_table_replace(network_table, network, dhcp);
 
-	dhcp_request(dhcp);
-
-	return 0;
+	return dhcp_request(dhcp);
 }
 
-static void dhcp_remove(struct connman_element *element)
+void __connman_dhcp_stop(struct connman_network *network)
 {
-	struct connman_dhcp *dhcp = connman_element_get_data(element);
-
-	DBG("element %p name %s", element, element->name);
-
-	connman_element_set_data(element, NULL);
+	DBG("");
 
-	dhcp_release(dhcp);
-	g_free(dhcp);
+	if (network_table == NULL)
+		return;
 
-	connman_element_unref(element);
+	if (g_hash_table_remove(network_table, network) == TRUE)
+		connman_network_unref(network);
 }
 
-static void dhcp_change(struct connman_element *element)
+int __connman_dhcp_init(void)
 {
-	DBG("element %p name %s", element, element->name);
+	DBG("");
 
-	if (element->state == CONNMAN_ELEMENT_STATE_ERROR)
-		connman_element_set_error(element->parent,
-					CONNMAN_ELEMENT_ERROR_DHCP_FAILED);
-}
-
-static struct connman_driver dhcp_driver = {
-	.name		= "dhcp",
-	.type		= CONNMAN_ELEMENT_TYPE_DHCP,
-	.priority	= CONNMAN_DRIVER_PRIORITY_LOW,
-	.probe		= dhcp_probe,
-	.remove		= dhcp_remove,
-	.change		= dhcp_change,
-};
+	network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+							NULL, remove_network);
 
-int __connman_dhcp_init(void)
-{
-	return connman_driver_register(&dhcp_driver);
+	return 0;
 }
 
 void __connman_dhcp_cleanup(void)
 {
-	connman_driver_unregister(&dhcp_driver);
+	DBG("");
+
+	g_hash_table_destroy(network_table);
+	network_table = NULL;
 }