X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdhcp.c;h=7c446cf81e246c10418e30ccfdc58a901916c55d;hb=00b8c314dc2cfb641494d413f4b00d90a10ecbeb;hp=e4497fcc7610dd8d59e70bddbca66a99f3405c67;hpb=6bcba613d63d3ecc7d70c1e0a67b64e427a6e62b;p=platform%2Fupstream%2Fconnman.git diff --git a/src/dhcp.c b/src/dhcp.c old mode 100755 new mode 100644 index e4497fc..7c446cf --- a/src/dhcp.c +++ b/src/dhcp.c @@ -26,6 +26,11 @@ #include #include #include +#include + +#ifndef IPV6_MIN_MTU +#define IPV6_MIN_MTU 1280 +#endif #include #include @@ -54,13 +59,17 @@ struct connman_dhcp { GDHCPClient *dhcp_client; char *ipv4ll_debug_prefix; char *dhcp_debug_prefix; + + bool ipv4ll_running; }; static GHashTable *ipconfig_table; -static bool ipv4ll_running; 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); @@ -70,17 +79,23 @@ static void dhcp_free(struct connman_dhcp *dhcp) 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; - ipv4ll_running = false; + dhcp->ipv4ll_running = false; g_free(dhcp->ipv4ll_debug_prefix); dhcp->ipv4ll_debug_prefix = NULL; @@ -108,12 +123,22 @@ static bool apply_dhcp_invalidate_on_network(struct connman_dhcp *dhcp) __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; @@ -183,6 +208,10 @@ static int ipv4ll_start_client(struct connman_dhcp *dhcp) int index; int err; +#if defined TIZEN_EXT + DBG("dhcp %p", dhcp); +#endif + if (dhcp->ipv4ll_client) return -EALREADY; @@ -192,12 +221,16 @@ static int ipv4ll_start_client(struct connman_dhcp *dhcp) 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 g_dhcp_client_set_id(ipv4ll_client); @@ -223,7 +256,7 @@ static int ipv4ll_start_client(struct connman_dhcp *dhcp) return err; } - ipv4ll_running = true; + dhcp->ipv4ll_running = true; return 0; } @@ -233,6 +266,10 @@ static gboolean dhcp_retry_cb(gpointer 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)); @@ -244,13 +281,32 @@ 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", ipv4ll_running, + 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 (ipv4ll_running) + if (dhcp->ipv4ll_running) return; err = ipv4ll_start_client(dhcp); @@ -258,7 +314,7 @@ static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data) DBG("Cannot start ipv4ll client (%d/%s)", err, strerror(-err)); /* Only notify upper layer if we have a problem */ - dhcp_invalidate(dhcp, !ipv4ll_running); + dhcp_invalidate(dhcp, !dhcp->ipv4ll_running); } static void lease_lost_cb(GDHCPClient *dhcp_client, gpointer user_data) @@ -323,6 +379,20 @@ static bool apply_lease_available_on_network(GDHCPClient *dhcp_client, return false; } + option = g_dhcp_client_get_option(dhcp_client, G_DHCP_MTU); + if (option && option->data) { + int mtu, index, err; + + mtu = atoi(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); + + 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); @@ -355,18 +425,32 @@ static bool apply_lease_available_on_network(GDHCPClient *dhcp_client, 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); @@ -409,10 +493,11 @@ 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; + bool ip_change = false; DBG("Lease available"); @@ -430,6 +515,10 @@ static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data) __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); @@ -444,17 +533,55 @@ static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data) DBG("c_address %s", c_address); - if (g_strcmp0(address, c_address)) + if (g_strcmp0(address, c_address)) { ip_change = true; - else if (g_strcmp0(gateway, c_gateway)) + if (c_address) { + /* Remove old ip address */ + __connman_ipconfig_address_remove(dhcp->ipconfig); + } + } + if (g_strcmp0(gateway, c_gateway)) { ip_change = true; - else if (prefixlen != c_prefixlen) + if (c_gateway) { + /* Remove gateway ip address */ + __connman_ipconfig_gateway_remove(dhcp->ipconfig); + } + } else if (prefixlen != c_prefixlen) ip_change = true; - else - ip_change = false; + 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); @@ -476,6 +603,7 @@ done: 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; unsigned char prefixlen; @@ -486,8 +614,25 @@ static void ipv4ll_available_cb(GDHCPClient *ipv4ll_client, gpointer user_data) prefixlen = connman_ipaddress_calc_netmask_len(netmask); + old_method = __connman_ipconfig_get_method(dhcp->ipconfig); __connman_ipconfig_set_method(dhcp->ipconfig, - CONNMAN_IPCONFIG_METHOD_DHCP); + CONNMAN_IPCONFIG_METHOD_AUTO); + + /* + * 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_local(dhcp->ipconfig, address); __connman_ipconfig_set_prefixlen(dhcp->ipconfig, prefixlen); __connman_ipconfig_set_gateway(dhcp->ipconfig, NULL); @@ -503,6 +648,7 @@ static int dhcp_initialize(struct connman_dhcp *dhcp) GDHCPClient *dhcp_client; GDHCPClientError error; int index; + const char *vendor_class_id; DBG("dhcp %p", dhcp); @@ -510,14 +656,25 @@ static int dhcp_initialize(struct connman_dhcp *dhcp) 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 !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); @@ -540,10 +697,16 @@ static int dhcp_initialize(struct connman_dhcp *dhcp) 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_SUBNET); g_dhcp_client_set_request(dhcp_client, G_DHCP_ROUTER); + 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, @@ -595,11 +758,48 @@ char *__connman_dhcp_get_server_address(struct connman_ipconfig *ipconfig) return g_dhcp_client_get_server_address(dhcp->dhcp_client); } +#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_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; @@ -613,7 +813,9 @@ int __connman_dhcp_start(struct connman_ipconfig *ipconfig, 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) { @@ -645,7 +847,19 @@ int __connman_dhcp_start(struct connman_ipconfig *ipconfig, dhcp->callback = callback; dhcp->user_data = user_data; +#if defined TIZEN_EXT + if (connman_network_get_bool(network, "WiFi.RoamingDHCP")) { + const char *last_addr = __connman_ipconfig_get_dhcp_address(ipconfig); + + 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_ipconfig *ipconfig) @@ -669,6 +883,30 @@ void __connman_dhcp_stop(struct connman_ipconfig *ipconfig) } } +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(""); @@ -685,6 +923,4 @@ void __connman_dhcp_cleanup(void) g_hash_table_destroy(ipconfig_table); ipconfig_table = NULL; - - dhcp_cleanup_random(); }