X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdhcp.c;h=7c446cf81e246c10418e30ccfdc58a901916c55d;hb=00b8c314dc2cfb641494d413f4b00d90a10ecbeb;hp=d6c27d0f37ee63b0bfdc6eb8071f06071fb18867;hpb=37fb27c85e07cf06a451b674682a36a0207a6875;p=platform%2Fupstream%2Fconnman.git diff --git a/src/dhcp.c b/src/dhcp.c index d6c27d0..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 #include #include +#include + +#ifndef IPV6_MIN_MTU +#define IPV6_MIN_MTU 1280 +#endif #include +#include #include @@ -35,77 +41,280 @@ #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 *timeserver; + 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_free(dhcp->timeserver); + g_strfreev(dhcp->timeservers); g_free(dhcp->pac); dhcp->nameservers = NULL; - dhcp->timeserver = 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 void dhcp_invalid(struct connman_dhcp *dhcp) +static bool apply_dhcp_invalidate_on_network(struct connman_dhcp *dhcp) { struct connman_service *service; - struct connman_ipconfig *ipconfig; int i; - service = __connman_service_lookup_from_network(dhcp->network); - if (service == NULL) + 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; +} + +/** + * 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, bool callback) +{ + DBG("dhcp %p callback %u", dhcp, callback); + + if (!dhcp) return; - ipconfig = __connman_service_get_ip4config(service); - if (ipconfig == NULL) + __connman_6to4_remove(dhcp->ipconfig); + + if (!apply_dhcp_invalidate_on_network(dhcp)) return; - __connman_service_set_domainname(service, NULL); - __connman_service_set_pac(service, NULL); - __connman_service_timeserver_remove(service, dhcp->timeserver); + __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_ipconfig_address_remove(dhcp->ipconfig); + + __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); +} - for (i = 0; dhcp->nameservers[i] != NULL; i++) { - __connman_service_nameserver_remove(service, - dhcp->nameservers[i]); +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 - __connman_ipconfig_set_local(ipconfig, NULL); - __connman_ipconfig_set_broadcast(ipconfig, NULL); - __connman_ipconfig_set_gateway(ipconfig, NULL); - __connman_ipconfig_set_prefixlen(ipconfig, 0); + g_dhcp_client_set_id(ipv4ll_client); - if (dhcp->callback != NULL) - dhcp->callback(dhcp->network, FALSE); + if (dhcp->network) { + hostname = connman_utsname_get_hostname(); + if (hostname) + g_dhcp_client_set_send(ipv4ll_client, + G_DHCP_HOST_NAME, hostname); + } + + g_dhcp_client_register_event(ipv4ll_client, + G_DHCP_CLIENT_EVENT_IPV4LL_LOST, ipv4ll_lost_cb, dhcp); + + g_dhcp_client_register_event(ipv4ll_client, + G_DHCP_CLIENT_EVENT_IPV4LL_AVAILABLE, + ipv4ll_available_cb, dhcp); + + dhcp->ipv4ll_client = ipv4ll_client; + + err = g_dhcp_client_start(dhcp->ipv4ll_client, NULL); + if (err < 0) { + ipv4ll_stop_client(dhcp); + return err; + } - 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); + + 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->timeout = g_timeout_add_seconds(RATE_LIMIT_INTERVAL, + dhcp_retry_cb, + dhcp); + if (dhcp->ipv4ll_running) + return; - DBG("No lease available"); + err = ipv4ll_start_client(dhcp); + if (err < 0) + DBG("Cannot start ipv4ll client (%d/%s)", err, strerror(-err)); - dhcp_invalid(dhcp); + /* 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) @@ -114,7 +323,8 @@ static void lease_lost_cb(GDHCPClient *dhcp_client, gpointer user_data) DBG("Lease lost"); - dhcp_invalid(dhcp); + /* 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) @@ -123,128 +333,309 @@ static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data) DBG("Lease lost"); - dhcp_invalid(dhcp); + ipv4ll_stop_client(dhcp); + + /* + * Since we lost our IPv4LL configuration we might as notify + * the upper layers. + */ + dhcp_invalidate(dhcp, true); } -static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data) +static bool compare_string_arrays(char **array_a, char **array_b) { - struct connman_dhcp *dhcp = user_data; + int i; + + if (!array_a || !array_b) + return false; + + if (g_strv_length(array_a) != g_strv_length(array_b)) + return false; + + for (i = 0; array_a[i] && + array_b[i]; i++) { + if (g_strcmp0(array_a[i], array_b[i]) != 0) + return false; + } + + return true; +} + +static bool apply_lease_available_on_network(GDHCPClient *dhcp_client, + struct connman_dhcp *dhcp) +{ + char **nameservers, **timeservers, *pac = NULL; + struct connman_service *service; GList *list, *option = NULL; - char *address, *netmask = NULL, *gateway = NULL; - char *domainname = NULL, *hostname = NULL; int ns_entries; - struct connman_ipconfig *ipconfig; - struct connman_service *service; - unsigned char prefixlen; 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; - address = g_dhcp_client_get_address(dhcp_client); + mtu = atoi(option->data); - option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET); - if (option != NULL) - netmask = g_strdup(option->data); + 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_ROUTER); - if (option != NULL) - gateway = g_strdup(option->data); + DBG("MTU %d index %d err %d", mtu, index, err); + } + } + + 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; - dhcp->nameservers = g_try_new0(char *, ns_entries + 1); - if (dhcp->nameservers) { - for (i = 0, list = option; list; list = list->next, i++) - dhcp->nameservers[i] = g_strdup(list->data); - dhcp->nameservers[ns_entries] = NULL; + ns_entries = g_list_length(option); + nameservers = g_try_new0(char *, ns_entries + 1); + 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); - if (option != NULL) - dhcp->timeserver = g_strdup(option->data); + ns_entries = g_list_length(option); + timeservers = g_try_new0(char *, ns_entries + 1); + 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) - dhcp->pac = g_strdup(option->data); + 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, + 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 && 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); +#endif + } + } else { + g_strfreev(nameservers); + } - prefixlen = __connman_ipconfig_netmask_prefix_len(netmask); + 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]); + } + g_strfreev(dhcp->timeservers); + } + + dhcp->timeservers = timeservers; + + for (i = 0; dhcp->timeservers && dhcp->timeservers[i]; i++) { + __connman_service_timeserver_append(service, + dhcp->timeservers[i]); + } + } else { + g_strfreev(timeservers); + } - 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, gateway); + if (g_strcmp0(pac, dhcp->pac) != 0) { + g_free(dhcp->pac); + dhcp->pac = pac; - for (i = 0; dhcp->nameservers[i] != NULL; i++) { - __connman_service_nameserver_append(service, - dhcp->nameservers[i]); + __connman_ipconfig_set_proxy_autoconfig(dhcp->ipconfig, + dhcp->pac); } - __connman_service_timeserver_append(service, dhcp->timeserver); - __connman_service_set_pac(service, dhcp->pac); - __connman_service_set_domainname(service, domainname); - if (domainname != NULL) - __connman_utsname_set_domainname(domainname); + if (connman_setting_get_bool("Enable6to4")) + __connman_6to4_probe(service); - if (hostname != NULL) - __connman_utsname_set_hostname(hostname); + return true; +} - dhcp_valid(dhcp); +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 (dhcp->ipv4ll_client) { + ipv4ll_stop_client(dhcp); + dhcp_invalidate(dhcp, false); + } + + c_address = __connman_ipconfig_get_local(dhcp->ipconfig); + c_gateway = __connman_ipconfig_get_gateway(dhcp->ipconfig); + c_prefixlen = __connman_ipconfig_get_prefixlen(dhcp->ipconfig); + + 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); + + 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); + + if (service) + __connman_service_notify_ipv4_configuration(service); + } - 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); + __connman_ipconfig_set_local(dhcp->ipconfig, address); + __connman_ipconfig_set_prefixlen(dhcp->ipconfig, prefixlen); + __connman_ipconfig_set_gateway(dhcp->ipconfig, NULL); dhcp_valid(dhcp); @@ -252,129 +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) { 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 - hostname = connman_utsname_get_hostname(); - if (hostname != NULL) - g_dhcp_client_set_send(dhcp_client, G_DHCP_HOST_NAME, hostname); + g_dhcp_client_set_id(dhcp_client); + + 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; - return g_dhcp_client_start(dhcp_client); + 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_release(dhcp); + return g_dhcp_client_get_server_address(dhcp->dhcp_client); +} - dhcp_free(dhcp); - 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; - g_hash_table_replace(network_table, network, dhcp); +#if defined TIZEN_EXT + if (connman_network_get_bool(network, "WiFi.RoamingDHCP")) { + const char *last_addr = __connman_ipconfig_get_dhcp_address(ipconfig); - return dhcp_request(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 } -void __connman_dhcp_stop(struct connman_network *network) +void __connman_dhcp_stop(struct connman_ipconfig *ipconfig) { struct connman_dhcp *dhcp; - DBG(""); + DBG("ipconfig_table %p ipconfig %p", ipconfig_table, ipconfig); - dhcp = g_hash_table_lookup(network_table, network); - if (dhcp == NULL) + if (!ipconfig_table) return; - dhcp_release(dhcp); + 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); + } +} - g_hash_table_remove(network_table, network); +void __connman_dhcp_decline(struct connman_ipconfig *ipconfig) +{ + struct connman_dhcp *dhcp; + const char *address; + struct in_addr addr; + + DBG("ipconfig_table %p ipconfig %p", ipconfig_table, ipconfig); + + if (!ipconfig_table) + return; + + 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; } @@ -383,5 +921,6 @@ void __connman_dhcp_cleanup(void) { DBG(""); - g_hash_table_destroy(network_table); + g_hash_table_destroy(ipconfig_table); + ipconfig_table = NULL; }