*
* Connection Manager
*
- * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2012-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
#include <errno.h>
#include <string.h>
#include <stdlib.h>
+#include <net/if.h>
#include <connman/ipconfig.h>
#include <connman/storage.h>
#define CNF_TIMEOUT (1 * 1000)
#define CNF_MAX_RT (4 * 1000)
#define CNF_MAX_RD (10 * 1000)
+#define DEC_TIMEOUT (1 * 1000)
+#define DEC_MAX_RC 5
+enum request_type {
+ REQ_REQUEST = 1,
+ REQ_REBIND = 2,
+ REQ_RENEW = 3,
+};
struct connman_dhcpv6 {
struct connman_network *network;
- dhcp_cb callback;
+ dhcpv6_cb callback;
char **nameservers;
char **timeservers;
guint timeout; /* operation timeout in msec */
guint MRD; /* max operation timeout in msec */
guint RT; /* in msec */
- gboolean use_ta; /* set to TRUE if IPv6 privacy is enabled */
- GSList *prefixes; /* network prefixes from radvd */
+ bool use_ta; /* set to TRUE if IPv6 privacy is enabled */
+ GSList *prefixes; /* network prefixes from radvd or dhcpv6 pd */
int request_count; /* how many times REQUEST have been sent */
- gboolean stateless; /* TRUE if stateless DHCPv6 is used */
- gboolean started; /* TRUE if we have DHCPv6 started */
+ bool stateless; /* TRUE if stateless DHCPv6 is used */
+ bool started; /* TRUE if we have DHCPv6 started */
};
static GHashTable *network_table;
+static GHashTable *network_pd_table;
-static int dhcpv6_request(struct connman_dhcpv6 *dhcp, gboolean add_addresses);
+static int dhcpv6_request(struct connman_dhcpv6 *dhcp, bool add_addresses);
+static int dhcpv6_pd_request(struct connman_dhcpv6 *dhcp);
+static gboolean start_solicitation(gpointer user_data);
+static int dhcpv6_renew(struct connman_dhcpv6 *dhcp);
+static int dhcpv6_rebind(struct connman_dhcpv6 *dhcp);
static void clear_timer(struct connman_dhcpv6 *dhcp)
{
}
}
-static inline float get_random()
+static inline float get_random(void)
{
return (rand() % 200 - 100) / 1000.0;
}
return (guint)rt;
}
-static void free_prefix(gpointer data, gpointer user_data)
+static void free_prefix(gpointer data)
{
g_free(data);
}
dhcp->nameservers = NULL;
dhcp->timeservers = NULL;
- dhcp->started = FALSE;
+ dhcp->started = false;
- g_slist_foreach(dhcp->prefixes, free_prefix, NULL);
- g_slist_free(dhcp->prefixes);
+ g_slist_free_full(dhcp->prefixes, free_prefix);
}
-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 dhcpv6_debug(const char *str, void *data)
gchar *ret = g_try_malloc(len * 2 + 1);
int i;
- for (i = 0; ret != NULL && i < len; i++)
+ for (i = 0; ret && i < len; i++)
g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
return ret;
ident = __connman_service_get_ident(service);
keyfile = connman_storage_load_service(ident);
- if (keyfile == NULL)
+ if (!keyfile)
return -EINVAL;
hex_duid = g_key_file_get_string(keyfile, ident, "IPv6.DHCP.DUID",
NULL);
- if (hex_duid != NULL) {
+ if (hex_duid) {
unsigned int i, j = 0, hex;
size_t hex_duid_len = strlen(hex_duid);
duid = g_try_malloc0(hex_duid_len / 2);
- if (duid == NULL) {
+ if (!duid) {
g_key_file_free(keyfile);
g_free(hex_duid);
return -ENOMEM;
}
hex_duid = convert_to_hex(duid, duid_len);
- if (hex_duid == NULL) {
+ if (!hex_duid) {
g_key_file_free(keyfile);
return -ENOMEM;
}
NULL, NULL);
g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_DECLINE,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
G_DHCP_CLIENT_EVENT_INFORMATION_REQ,
NULL, NULL);
}
DBG("dhcpv6 information-request %p", dhcp);
service = connman_service_lookup_from_network(dhcp->network);
- if (service == NULL) {
+ if (!service) {
connman_error("Can not lookup service");
return;
}
entries = g_list_length(option);
nameservers = g_try_new0(char *, entries + 1);
- if (nameservers != NULL) {
+ if (nameservers) {
for (i = 0, list = option; list; list = list->next, i++)
nameservers[i] = g_strdup(list->data);
}
- if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
- if (dhcp->nameservers != NULL) {
- for (i = 0; dhcp->nameservers[i] != NULL; i++)
+ if (!compare_string_arrays(nameservers, dhcp->nameservers)) {
+ if (dhcp->nameservers) {
+ for (i = 0; dhcp->nameservers[i]; i++)
__connman_service_nameserver_remove(service,
dhcp->nameservers[i],
- FALSE);
+ false);
g_strfreev(dhcp->nameservers);
}
dhcp->nameservers = nameservers;
- for (i = 0; dhcp->nameservers != NULL &&
- dhcp->nameservers[i] != NULL; i++)
+ for (i = 0; dhcp->nameservers &&
+ dhcp->nameservers[i]; i++)
__connman_service_nameserver_append(service,
dhcp->nameservers[i],
- FALSE);
+ false);
} else
g_strfreev(nameservers);
entries = g_list_length(option);
timeservers = g_try_new0(char *, entries + 1);
- if (timeservers != NULL) {
+ if (timeservers) {
for (i = 0, list = option; list; list = list->next, i++)
timeservers[i] = g_strdup(list->data);
}
- 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]);
g_strfreev(dhcp->timeservers);
dhcp->timeservers = timeservers;
- for (i = 0; dhcp->timeservers != NULL &&
- dhcp->timeservers[i] != NULL; i++)
+ for (i = 0; dhcp->timeservers &&
+ dhcp->timeservers[i]; i++)
__connman_service_timeserver_append(service,
dhcp->timeservers[i]);
} else
g_strfreev(timeservers);
- if (dhcp->callback != NULL) {
+ if (dhcp->callback) {
uint16_t status = g_dhcpv6_client_get_status(dhcp_client);
- dhcp->callback(dhcp->network, status == 0 ? TRUE : FALSE);
+ dhcp->callback(dhcp->network, status == 0 ?
+ CONNMAN_DHCPV6_STATUS_SUCCEED :
+ CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
}
}
g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
service = connman_service_lookup_from_network(dhcp->network);
- if (service == NULL) {
+ if (!service) {
clear_timer(dhcp);
g_dhcp_client_unref(dhcp_client);
return -EINVAL;
0xF0, 0xE0, 0xC0, 0x80 };
int left, count, i, plen;
- if (slash == NULL)
+ if (!slash)
continue;
prefix = g_strndup(prefix, slash - prefix);
len = strtol(slash + 1, NULL, 10);
+ if (len < 3 || len > 128)
+ break;
+
plen = 128 - len;
count = plen / 8;
return ret;
}
-static int set_addresses(GDHCPClient *dhcp_client,
+static int set_other_addresses(GDHCPClient *dhcp_client,
struct connman_dhcpv6 *dhcp)
{
struct connman_service *service;
- struct connman_ipconfig *ipconfig;
int entries, i;
GList *option, *list;
char **nameservers, **timeservers;
- const char *c_address;
- char *address = NULL;
service = connman_service_lookup_from_network(dhcp->network);
- if (service == NULL) {
+ if (!service) {
connman_error("Can not lookup service");
return -EINVAL;
}
- ipconfig = __connman_service_get_ip6config(service);
- if (ipconfig == NULL) {
- connman_error("Could not lookup ip6config");
- return -EINVAL;
+ /*
+ * Check domains before nameservers so that the nameserver append
+ * function will update domain list in service.c
+ */
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ entries = g_list_length(option);
+ if (entries > 0) {
+ char **domains = g_try_new0(char *, entries + 1);
+ if (domains) {
+ for (i = 0, list = option; list;
+ list = list->next, i++)
+ domains[i] = g_strdup(list->data);
+ __connman_service_update_search_domains(service, domains);
+ g_strfreev(domains);
+ }
}
option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
entries = g_list_length(option);
nameservers = g_try_new0(char *, entries + 1);
- if (nameservers != NULL) {
+ if (nameservers) {
for (i = 0, list = option; list; list = list->next, i++)
nameservers[i] = g_strdup(list->data);
}
- if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
- if (dhcp->nameservers != NULL) {
- for (i = 0; dhcp->nameservers[i] != NULL; i++)
+ if (!compare_string_arrays(nameservers, dhcp->nameservers)) {
+ if (dhcp->nameservers) {
+ for (i = 0; dhcp->nameservers[i]; i++)
__connman_service_nameserver_remove(service,
dhcp->nameservers[i],
- FALSE);
+ false);
g_strfreev(dhcp->nameservers);
}
dhcp->nameservers = nameservers;
- for (i = 0; dhcp->nameservers != NULL &&
- dhcp->nameservers[i] != NULL; i++)
+ for (i = 0; dhcp->nameservers &&
+ dhcp->nameservers[i]; i++)
__connman_service_nameserver_append(service,
dhcp->nameservers[i],
- FALSE);
+ false);
} else
g_strfreev(nameservers);
entries = g_list_length(option);
timeservers = g_try_new0(char *, entries + 1);
- if (timeservers != NULL) {
+ if (timeservers) {
for (i = 0, list = option; list; list = list->next, i++)
timeservers[i] = g_strdup(list->data);
}
- 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]);
g_strfreev(dhcp->timeservers);
dhcp->timeservers = timeservers;
- for (i = 0; dhcp->timeservers != NULL &&
- dhcp->timeservers[i] != NULL; i++)
+ for (i = 0; dhcp->timeservers &&
+ dhcp->timeservers[i]; i++)
__connman_service_timeserver_append(service,
dhcp->timeservers[i]);
} else
g_strfreev(timeservers);
+ return 0;
+}
- option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
- if (option != NULL)
- address = g_strdup(option->data);
- else {
- option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
- if (option != NULL)
- address = g_strdup(option->data);
- }
+static GSList *copy_prefixes(GSList *prefixes)
+{
+ GSList *list, *copy = NULL;
+
+ for (list = prefixes; list; list = list->next)
+ copy = g_slist_prepend(copy, g_strdup(list->data));
+
+ return copy;
+}
+
+/*
+ * Helper struct for doing DAD (duplicate address detection).
+ * It is refcounted and freed after all reply's to neighbor
+ * discovery request are received.
+ */
+struct own_address {
+ int refcount;
+
+ int ifindex;
+ GDHCPClient *dhcp_client;
+ struct connman_ipconfig *ipconfig;
+ GSList *prefixes;
+ dhcpv6_cb callback;
+
+ GSList *dad_failed;
+ GSList *dad_succeed;
+};
+
+static void free_own_address(struct own_address *data)
+{
+ g_dhcp_client_unref(data->dhcp_client);
+ __connman_ipconfig_unref(data->ipconfig);
+ g_slist_free_full(data->prefixes, free_prefix);
+ g_slist_free_full(data->dad_failed, g_free);
+ g_slist_free_full(data->dad_succeed, g_free);
+
+ g_free(data);
+}
+
+static struct own_address *ref_own_address(struct own_address *address)
+{
+ DBG("%p ref %d", address, address->refcount + 1);
+
+ __sync_fetch_and_add(&address->refcount, 1);
+
+ return address;
+}
+
+static void unref_own_address(struct own_address *address)
+{
+ if (!address)
+ return;
+
+ DBG("%p ref %d", address, address->refcount - 1);
+
+ if (__sync_fetch_and_sub(&address->refcount, 1) != 1)
+ return;
+
+ free_own_address(address);
+}
+
+static void set_address(int ifindex, struct connman_ipconfig *ipconfig,
+ GSList *prefixes, char *address)
+{
+ const char *c_address;
c_address = __connman_ipconfig_get_local(ipconfig);
- if (address != NULL &&
- ((c_address != NULL &&
- g_strcmp0(address, c_address) != 0) ||
- (c_address == NULL))) {
+ if (address && ((c_address && g_strcmp0(address, c_address) != 0) ||
+ !c_address)) {
int prefix_len;
/* Is this prefix part of the subnet we are suppose to use? */
- prefix_len = check_ipv6_addr_prefix(dhcp->prefixes, address);
+ prefix_len = check_ipv6_addr_prefix(prefixes, address);
__connman_ipconfig_set_local(ipconfig, address);
__connman_ipconfig_set_prefixlen(ipconfig, prefix_len);
DBG("new address %s/%d", address, prefix_len);
__connman_ipconfig_set_dhcp_address(ipconfig, address);
- __connman_service_save(service);
+ __connman_service_save(
+ __connman_service_lookup_from_index(ifindex));
}
+}
- g_free(address);
- return 0;
+/*
+ * Helper struct that is used when waiting a reply to DECLINE message.
+ */
+struct decline_cb_data {
+ GDHCPClient *dhcp_client;
+ dhcpv6_cb callback;
+ int ifindex;
+ guint timeout;
+};
+
+static void decline_reply_callback(struct decline_cb_data *data)
+{
+ struct connman_network *network;
+ struct connman_service *service;
+
+ service = __connman_service_lookup_from_index(data->ifindex);
+ network = __connman_service_get_network(service);
+
+ if (data->callback)
+ data->callback(network, CONNMAN_DHCPV6_STATUS_RESTART, NULL);
+
+ g_dhcp_client_unref(data->dhcp_client);
}
-static void re_cb(GDHCPClient *dhcp_client, gpointer user_data)
+static gboolean decline_timeout(gpointer user_data)
{
- struct connman_dhcpv6 *dhcp = user_data;
- uint16_t status;
- int ret;
+ struct decline_cb_data *data = user_data;
- ret = set_addresses(dhcp_client, dhcp);
+ DBG("ifindex %d", data->ifindex);
- status = g_dhcpv6_client_get_status(dhcp_client);
+ /*
+ * We ignore all DECLINE replies that are received after the timeout
+ */
+ g_dhcp_client_register_event(data->dhcp_client,
+ G_DHCP_CLIENT_EVENT_DECLINE,
+ NULL, NULL);
- DBG("dhcpv6 cb msg %p ret %d status %d", dhcp, ret, status);
+ decline_reply_callback(data);
- if (ret < 0) {
- if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network, FALSE);
- return;
- }
+ g_free(data);
- if (status == G_DHCPV6_ERROR_BINDING) {
- /* RFC 3315, 18.1.8 */
- dhcpv6_request(dhcp, FALSE);
- } else {
- if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network,
- status == 0 ? TRUE : FALSE);
- }
+ return FALSE;
}
-static void rebind_cb(GDHCPClient *dhcp_client, gpointer user_data)
+static void decline_cb(GDHCPClient *dhcp_client, gpointer user_data)
{
- DBG("");
+ struct decline_cb_data *data = user_data;
+
+ DBG("ifindex %d", data->ifindex);
- g_dhcpv6_client_reset_rebind(dhcp_client);
- g_dhcpv6_client_reset_renew(dhcp_client);
g_dhcpv6_client_clear_retransmit(dhcp_client);
- re_cb(dhcp_client, user_data);
+ if (data->timeout)
+ g_source_remove(data->timeout);
+
+ decline_reply_callback(data);
+
+ g_free(data);
}
-static int dhcpv6_rebind(struct connman_dhcpv6 *dhcp)
+static int dhcpv6_decline(GDHCPClient *dhcp_client, int ifindex,
+ dhcpv6_cb callback, GSList *failed)
{
- GDHCPClient *dhcp_client;
-
- DBG("dhcp %p", dhcp);
+ struct decline_cb_data *data;
+ GList *option;
+ int code;
- dhcp_client = dhcp->dhcp_client;
+ DBG("dhcp_client %p", dhcp_client);
g_dhcp_client_clear_requests(dhcp_client);
+ g_dhcpv6_client_clear_send(dhcp_client, G_DHCPV6_ORO);
+
g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
- g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
- G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
+ if (!option) {
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
+ if (option)
+ code = G_DHCPV6_IA_TA;
+ else
+ return -EINVAL;
+ } else
+ code = G_DHCPV6_IA_NA;
- g_dhcpv6_client_set_ia(dhcp_client,
- connman_network_get_index(dhcp->network),
- dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
- NULL, NULL, FALSE, NULL);
+ g_dhcpv6_client_clear_send(dhcp_client, code);
+
+ g_dhcpv6_client_set_ias(dhcp_client, ifindex, code, NULL, NULL,
+ failed);
clear_callbacks(dhcp_client);
- g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REBIND,
- rebind_cb, dhcp);
+ data = g_try_new(struct decline_cb_data, 1);
+ if (!data)
+ return -ENOMEM;
- dhcp->dhcp_client = dhcp_client;
+ data->ifindex = ifindex;
+ data->callback = callback;
+ data->dhcp_client = g_dhcp_client_ref(dhcp_client);
+ data->timeout = g_timeout_add(DEC_TIMEOUT, decline_timeout, data);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_DECLINE,
+ decline_cb, data);
return g_dhcp_client_start(dhcp_client, NULL);
}
-static gboolean dhcpv6_restart(gpointer user_data)
+static void dad_reply(struct nd_neighbor_advert *reply,
+ unsigned int length, struct in6_addr *addr, void *user_data)
{
- struct connman_dhcpv6 *dhcp = user_data;
+ struct own_address *data = user_data;
+ GSList *list;
+ char address[INET6_ADDRSTRLEN];
+ enum __connman_dhcpv6_status status = CONNMAN_DHCPV6_STATUS_FAIL;
- if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network, FALSE);
+ inet_ntop(AF_INET6, addr, address, INET6_ADDRSTRLEN);
- return FALSE;
-}
+ DBG("user %p reply %p len %d address %s index %d data %p", user_data,
+ reply, length, address, data->ifindex, data);
-/*
- * Check if we need to restart the solicitation procedure. This
- * is done if all the addresses have expired. RFC 3315, 18.1.4
- */
-static int check_restart(struct connman_dhcpv6 *dhcp)
-{
- time_t current, expired;
+ if (!reply) {
+ if (length == 0)
+ DBG("DAD succeed for %s", address);
+ else
+ DBG("DAD cannot be done for %s", address);
- g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, NULL,
- NULL, NULL, &expired);
- current = time(NULL);
+ data->dad_succeed = g_slist_prepend(data->dad_succeed,
+ g_strdup(address));
- if (current > expired) {
- DBG("expired by %d secs", (int)(current - expired));
+ } else {
+ DBG("DAD failed for %s", address);
- g_timeout_add(0, dhcpv6_restart, dhcp);
+ data->dad_failed = g_slist_prepend(data->dad_failed,
+ g_strdup(address));
+ }
- return -ETIMEDOUT;
+ /*
+ * If refcount == 1 then we got the final reply and can continue.
+ */
+ if (data->refcount > 1)
+ return;
+
+ for (list = data->dad_succeed; list; list = list->next)
+ set_address(data->ifindex, data->ipconfig, data->prefixes,
+ list->data);
+
+ if (data->dad_failed) {
+ dhcpv6_decline(data->dhcp_client, data->ifindex,
+ data->callback, data->dad_failed);
+ } else {
+ if (data->dad_succeed)
+ status = CONNMAN_DHCPV6_STATUS_SUCCEED;
+
+ if (data->callback) {
+ struct connman_network *network;
+ struct connman_service *service;
+
+ service = __connman_service_lookup_from_index(
+ data->ifindex);
+ network = __connman_service_get_network(service);
+ data->callback(network, status, NULL);
+ }
}
- return 0;
+ unref_own_address(data);
}
-static gboolean timeout_rebind(gpointer user_data)
+/*
+ * Is the kernel configured to do DAD? If 0, then do not do DAD.
+ * See also RFC 4862 chapter 5.4 about DupAddrDetectTransmits
+ */
+static int dad_transmits(int ifindex)
{
- struct connman_dhcpv6 *dhcp = user_data;
+ char name[IF_NAMESIZE];
+ gchar *path;
+ int value = 1;
+ FILE *f;
- if (check_restart(dhcp) < 0)
- return FALSE;
+ if (!if_indextoname(ifindex, name))
+ return value;
- dhcp->RT = calc_delay(dhcp->RT, REB_MAX_RT);
+ path = g_strdup_printf("/proc/sys/net/ipv6/conf/%s/dad_transmits",
+ name);
- DBG("rebind RT timeout %d msec", dhcp->RT);
+ if (!path)
+ return value;
- dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
+ f = fopen(path, "r");
- g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+ g_free(path);
- g_dhcp_client_start(dhcp->dhcp_client, NULL);
+ if (f) {
+ if (fscanf(f, "%d", &value) < 0)
+ value = 1;
- return FALSE;
+ fclose(f);
+ }
+
+ return value;
}
-static gboolean start_rebind(gpointer user_data)
+static void do_dad(GDHCPClient *dhcp_client, struct connman_dhcpv6 *dhcp)
{
- struct connman_dhcpv6 *dhcp = user_data;
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+ int ifindex;
+ GList *option, *list;
+ struct own_address *user_data;
- dhcp->RT = REB_TIMEOUT * (1 + get_random());
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
+ if (!option)
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
- DBG("rebind initial RT timeout %d msec", dhcp->RT);
+ /*
+ * Even if we didn't had any addresses, just try to set
+ * the other options.
+ */
+ set_other_addresses(dhcp_client, dhcp);
- dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
+ if (!option) {
+ DBG("Skip DAD as no addresses found in reply");
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, NULL);
- dhcpv6_rebind(dhcp);
+ return;
+ }
- return FALSE;
-}
+ ifindex = connman_network_get_index(dhcp->network);
-static void request_cb(GDHCPClient *dhcp_client, gpointer user_data)
-{
- DBG("");
+ DBG("index %d", ifindex);
- g_dhcpv6_client_clear_retransmit(dhcp_client);
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ connman_error("Can not lookup service for index %d", ifindex);
+ goto error;
+ }
- re_cb(dhcp_client, user_data);
-}
+ ipconfig = __connman_service_get_ip6config(service);
+ if (!ipconfig) {
+ connman_error("Could not lookup ip6config for index %d",
+ ifindex);
+ goto error;
+ }
-static int dhcpv6_request(struct connman_dhcpv6 *dhcp,
- gboolean add_addresses)
-{
- GDHCPClient *dhcp_client;
- uint32_t T1, T2;
+ if (!dad_transmits(ifindex)) {
+ DBG("Skip DAD because of kernel configuration");
- DBG("dhcp %p add %d", dhcp, add_addresses);
+ for (list = option; list; list = list->next)
+ set_address(ifindex, ipconfig, dhcp->prefixes,
+ option->data);
- dhcp_client = dhcp->dhcp_client;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, NULL);
- g_dhcp_client_clear_requests(dhcp_client);
+ return;
+ }
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+ if (g_list_length(option) == 0) {
+ DBG("No addresses when doing DAD");
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, NULL);
- g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
- G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+ return;
+ }
- g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL, NULL);
- g_dhcpv6_client_set_ia(dhcp_client,
- connman_network_get_index(dhcp->network),
- dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
- &T1, &T2, add_addresses, NULL);
+ user_data = g_try_new0(struct own_address, 1);
+ if (!user_data)
+ goto error;
- clear_callbacks(dhcp_client);
+ user_data->refcount = 0;
+ user_data->ifindex = ifindex;
+ user_data->dhcp_client = g_dhcp_client_ref(dhcp_client);
+ user_data->ipconfig = __connman_ipconfig_ref(ipconfig);
+ user_data->prefixes = copy_prefixes(dhcp->prefixes);
+ user_data->callback = dhcp->callback;
- g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
- request_cb, dhcp);
+ /*
+ * We send one neighbor discovery request / address
+ * and after all checks are done, then report the status
+ * via dhcp callback.
+ */
- dhcp->dhcp_client = dhcp_client;
+ for (list = option; list; list = list->next) {
+ char *address = option->data;
+ struct in6_addr addr;
+ int ret;
- return g_dhcp_client_start(dhcp_client, NULL);
+ ref_own_address(user_data);
+
+ if (inet_pton(AF_INET6, address, &addr) < 0) {
+ DBG("Invalid IPv6 address %s %d/%s", address,
+ -errno, strerror(errno));
+ goto fail;
+ }
+
+ DBG("user %p address %s client %p ipconfig %p prefixes %p",
+ user_data, address,
+ user_data->dhcp_client, user_data->ipconfig,
+ user_data->prefixes);
+
+ ret = __connman_inet_ipv6_do_dad(ifindex, 1000,
+ &addr,
+ dad_reply,
+ user_data);
+ if (ret < 0) {
+ DBG("Could not send neighbor solicitation for %s",
+ address);
+ dad_reply(NULL, -1, &addr, user_data);
+ } else {
+ DBG("Sent neighbor solicitation %d bytes", ret);
+ }
+ }
+
+ return;
+
+fail:
+ unref_own_address(user_data);
+
+error:
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network, CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
}
-static gboolean timeout_request(gpointer user_data)
+static gboolean timeout_request_resend(gpointer user_data)
{
struct connman_dhcpv6 *dhcp = user_data;
if (dhcp->request_count >= REQ_MAX_RC) {
DBG("max request retry attempts %d", dhcp->request_count);
dhcp->request_count = 0;
- if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network, FALSE);
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
return FALSE;
}
dhcp->request_count++;
dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
- DBG("request RT timeout %d msec", dhcp->RT);
- dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
+ DBG("request resend RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request_resend, dhcp);
g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
return FALSE;
}
-static void renew_cb(GDHCPClient *dhcp_client, gpointer user_data)
+static gboolean request_resend(gpointer user_data)
{
- DBG("");
+ struct connman_dhcpv6 *dhcp = user_data;
- g_dhcpv6_client_reset_renew(dhcp_client);
- g_dhcpv6_client_clear_retransmit(dhcp_client);
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
- re_cb(dhcp_client, user_data);
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request resend RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request_resend, dhcp);
+
+ dhcpv6_request(dhcp, true);
+
+ return FALSE;
}
-static int dhcpv6_renew(struct connman_dhcpv6 *dhcp)
+static void do_resend_request(struct connman_dhcpv6 *dhcp)
{
- GDHCPClient *dhcp_client;
- uint32_t T1, T2;
-
- DBG("dhcp %p", dhcp);
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
- dhcp_client = dhcp->dhcp_client;
+ dhcp->request_count++;
- g_dhcp_client_clear_requests(dhcp_client);
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("resending request after %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, request_resend, dhcp);
+}
+
+static void re_cb(enum request_type req_type, GDHCPClient *dhcp_client,
+ gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ uint16_t status;
+
+ clear_timer(dhcp);
+
+ status = g_dhcpv6_client_get_status(dhcp_client);
+
+ DBG("dhcpv6 cb msg %p status %d", dhcp, status);
+
+ /*
+ * RFC 3315, 18.1.8 handle the resend if error
+ */
+ if (status == G_DHCPV6_ERROR_BINDING) {
+ dhcpv6_request(dhcp, false);
+ } else if (status == G_DHCPV6_ERROR_MCAST) {
+ switch (req_type) {
+ case REQ_REQUEST:
+ dhcpv6_request(dhcp, true);
+ break;
+ case REQ_REBIND:
+ dhcpv6_rebind(dhcp);
+ break;
+ case REQ_RENEW:
+ dhcpv6_renew(dhcp);
+ break;
+ }
+ } else if (status == G_DHCPV6_ERROR_LINK) {
+ if (req_type == REQ_REQUEST) {
+ g_dhcp_client_unref(dhcp->dhcp_client);
+ start_solicitation(dhcp);
+ } else {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ }
+ } else if (status == G_DHCPV6_ERROR_FAILURE) {
+ if (req_type == REQ_REQUEST) {
+ /* Rate limit the resend of request message */
+ do_resend_request(dhcp);
+ } else {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ }
+ } else {
+
+ /*
+ * If we did not got any addresses, then re-send
+ * a request.
+ */
+ GList *option;
+
+ option = g_dhcp_client_get_option(dhcp->dhcp_client,
+ G_DHCPV6_IA_NA);
+ if (!option) {
+ option = g_dhcp_client_get_option(dhcp->dhcp_client,
+ G_DHCPV6_IA_TA);
+ if (!option) {
+ switch (req_type) {
+ case REQ_REQUEST:
+ dhcpv6_request(dhcp, true);
+ break;
+ case REQ_REBIND:
+ dhcpv6_rebind(dhcp);
+ break;
+ case REQ_RENEW:
+ dhcpv6_renew(dhcp);
+ break;
+ }
+ return;
+ }
+ }
+
+ if (status == G_DHCPV6_ERROR_SUCCESS)
+ do_dad(dhcp_client, dhcp);
+ else if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ }
+}
+
+static void rebind_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_cb(REQ_REBIND, dhcp_client, user_data);
+}
+
+static int dhcpv6_rebind(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_ia(dhcp_client,
+ connman_network_get_index(dhcp->network),
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ NULL, NULL, TRUE, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REBIND,
+ rebind_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean dhcpv6_restart(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network, CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
+
+ return FALSE;
+}
+
+/*
+ * Check if we need to restart the solicitation procedure. This
+ * is done if all the addresses have expired. RFC 3315, 18.1.4
+ */
+static int check_restart(struct connman_dhcpv6 *dhcp)
+{
+ time_t current, expired;
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, NULL,
+ NULL, &expired);
+ current = time(NULL);
+
+ if (current >= expired) {
+ DBG("expired by %d secs", (int)(current - expired));
+
+ g_timeout_add(0, dhcpv6_restart, dhcp);
+
+ return -ETIMEDOUT;
+ }
+
+ return 0;
+}
+
+static gboolean timeout_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = calc_delay(dhcp->RT, REB_MAX_RT);
+
+ DBG("rebind RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = REB_TIMEOUT * (1 + get_random());
+
+ DBG("rebind initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
+
+ dhcpv6_rebind(dhcp);
+
+ return FALSE;
+}
+
+static void request_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_reset_request(dhcp_client);
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_cb(REQ_REQUEST, dhcp_client, user_data);
+}
+
+static int dhcpv6_request(struct connman_dhcpv6 *dhcp,
+ bool add_addresses)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p add %d", dhcp, add_addresses);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_ia(dhcp_client,
+ connman_network_get_index(dhcp->network),
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ &T1, &T2, add_addresses, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
+ request_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean timeout_request(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return FALSE;
+ }
+
+ dhcp->request_count++;
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static void renew_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_cb(REQ_RENEW, dhcp_client, user_data);
+}
+
+static int dhcpv6_renew(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
- g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL, NULL);
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
g_dhcpv6_client_set_ia(dhcp_client,
connman_network_get_index(dhcp->network),
- dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
&T1, &T2, TRUE, NULL);
clear_callbacks(dhcp_client);
static gboolean timeout_renew(gpointer user_data)
{
struct connman_dhcpv6 *dhcp = user_data;
+ time_t last_rebind, current;
+ uint32_t T2;
if (check_restart(dhcp) < 0)
return FALSE;
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, &T2,
+ &last_rebind, NULL);
+ current = time(NULL);
+ if ((unsigned)current >= (unsigned)last_rebind + T2) {
+ /*
+ * Do rebind instead if past T2
+ */
+ start_rebind(dhcp);
+ return FALSE;
+ }
+
dhcp->RT = calc_delay(dhcp->RT, REN_MAX_RT);
DBG("renew RT timeout %d msec", dhcp->RT);
}
int __connman_dhcpv6_start_renew(struct connman_network *network,
- dhcp_cb callback)
+ dhcpv6_cb callback)
{
struct connman_dhcpv6 *dhcp;
uint32_t T1, T2;
- time_t last_renew, last_rebind, current, expired;
+ time_t started, current, expired;
dhcp = g_hash_table_lookup(network_table, network);
- if (dhcp == NULL)
+ if (!dhcp)
return -ENOENT;
DBG("network %p dhcp %p", network, dhcp);
clear_timer(dhcp);
g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, &T1, &T2,
- &last_renew, &last_rebind, &expired);
+ &started, &expired);
current = time(NULL);
- DBG("T1 %u T2 %u expires %lu current %lu", T1, T2,
- (unsigned long)expired, current);
+ DBG("T1 %u T2 %u expires %lu current %lu started %lu", T1, T2,
+ (unsigned long)expired, current, started);
if (T1 == 0xffffffff)
/* RFC 3315, 22.4 */
*/
T1 = 1800;
+ dhcp->callback = callback;
+
/* RFC 3315, 18.1.4, start solicit if expired */
- if (current > expired) {
- DBG("expired by %d secs", (int)(current - expired));
- return -ETIMEDOUT;
- }
+ if (check_restart(dhcp) < 0)
+ return 0;
- dhcp->callback = callback;
+ if (T2 != 0xffffffff && T2 > 0) {
+ if ((unsigned)current >= (unsigned)started + T2) {
+ /* RFC 3315, chapter 18.1.3, start rebind */
+ DBG("rebind after %d secs", T2);
- if (T2 != 0xffffffff && T2 > 0 &&
- (unsigned)current > (unsigned)last_rebind + T2) {
- int timeout;
+ dhcp->timeout = g_timeout_add_seconds(T2, start_rebind,
+ dhcp);
- /* RFC 3315, chapter 18.1.3, start rebind */
- if ((unsigned)current > (unsigned)last_renew + T1)
- timeout = 0;
- else
- timeout = last_renew - current + T1;
+ } else if ((unsigned)current < (unsigned)started + T1) {
+ DBG("renew after %d secs", T1);
- /*
- * If we just did a renew, do not restart the rebind
- * immediately.
- */
- dhcp->timeout = g_timeout_add_seconds(timeout, start_rebind,
- dhcp);
- } else {
- DBG("renew after %d secs", T1);
+ dhcp->timeout = g_timeout_add_seconds(T1, start_renew,
+ dhcp);
+ } else {
+ DBG("rebind after %d secs", T2 - T1);
- dhcp->timeout = g_timeout_add_seconds(T1, start_renew, dhcp);
+ dhcp->timeout = g_timeout_add_seconds(T2 - T1,
+ start_rebind,
+ dhcp);
+ }
}
+
return 0;
}
}
int __connman_dhcpv6_start_release(struct connman_network *network,
- dhcp_cb callback)
+ dhcpv6_cb callback)
{
struct connman_dhcpv6 *dhcp;
GDHCPClient *dhcp_client;
- if (network_table == NULL)
+ if (!network_table)
return 0; /* we are already released */
dhcp = g_hash_table_lookup(network_table, network);
- if (dhcp == NULL)
+ if (!dhcp)
return -ENOENT;
DBG("network %p dhcp %p client %p stateless %d", network, dhcp,
dhcp->dhcp_client, dhcp->stateless);
- if (dhcp->stateless == TRUE)
+ if (dhcp->stateless)
return -EINVAL;
clear_timer(dhcp);
dhcp_client = dhcp->dhcp_client;
- if (dhcp_client == NULL) {
+ if (!dhcp_client) {
/*
* We had started the DHCPv6 handshaking i.e., we have called
* __connman_dhcpv6_start() but it has not yet sent
g_dhcpv6_client_set_ia(dhcp_client,
connman_network_get_index(dhcp->network),
- dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
NULL, NULL, TRUE, NULL);
clear_callbacks(dhcp_client);
dhcpv6_free(dhcp);
- if (dhcp->dhcp_client == NULL)
+ if (!dhcp->dhcp_client)
return 0;
g_dhcp_client_stop(dhcp->dhcp_client);
}
int __connman_dhcpv6_start_info(struct connman_network *network,
- dhcp_cb callback)
+ dhcpv6_cb callback)
{
struct connman_dhcpv6 *dhcp;
int delay;
DBG("");
- if (network_table != NULL) {
+ if (network_table) {
dhcp = g_hash_table_lookup(network_table, network);
- if (dhcp != NULL && dhcp->started == TRUE)
+ if (dhcp && dhcp->started)
return -EBUSY;
}
dhcp = g_try_new0(struct connman_dhcpv6, 1);
- if (dhcp == NULL)
+ if (!dhcp)
return -ENOMEM;
dhcp->network = network;
dhcp->callback = callback;
- dhcp->stateless = TRUE;
- dhcp->started = TRUE;
+ dhcp->stateless = true;
+ dhcp->started = true;
connman_network_ref(network);
g_dhcpv6_client_clear_retransmit(dhcp_client);
if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
- if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network, FALSE);
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
return;
}
dhcp->request_count = 1;
- dhcpv6_request(dhcp, TRUE);
+ dhcpv6_request(dhcp, true);
}
static void solicitation_cb(GDHCPClient *dhcp_client, gpointer user_data)
clear_timer(dhcp);
- set_addresses(dhcp_client, dhcp);
+ do_dad(dhcp_client, dhcp);
g_dhcpv6_client_clear_retransmit(dhcp_client);
}
g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
service = connman_service_lookup_from_network(dhcp->network);
- if (service == NULL) {
+ if (!service) {
clear_timer(dhcp);
g_dhcp_client_unref(dhcp_client);
return -EINVAL;
dhcp->use_ta = __connman_ipconfig_ipv6_privacy_enabled(ipconfig_ipv6);
g_dhcpv6_client_set_ia(dhcp_client, index,
- dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
NULL, NULL, FALSE, NULL);
clear_callbacks(dhcp_client);
clear_timer(dhcp);
- set_addresses(dhcp_client, dhcp);
-
g_dhcpv6_client_clear_retransmit(dhcp_client);
/*
if (status != 0) {
g_dhcp_client_unref(dhcp->dhcp_client);
start_solicitation(dhcp);
- } else if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network, TRUE);
+ } else {
+ do_dad(dhcp_client, dhcp);
+ }
}
static int dhcpv6_confirm(struct connman_dhcpv6 *dhcp)
g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
service = connman_service_lookup_from_network(dhcp->network);
- if (service == NULL) {
+ if (!service) {
clear_timer(dhcp);
g_dhcp_client_unref(dhcp_client);
return -EINVAL;
g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
g_dhcp_client_set_request(dhcp_client, G_DHCPV6_RAPID_COMMIT);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
- g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
-
- g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
- G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
ipconfig_ipv6 = __connman_service_get_ip6config(service);
dhcp->use_ta = __connman_ipconfig_ipv6_privacy_enabled(ipconfig_ipv6);
g_dhcpv6_client_set_ia(dhcp_client, index,
- dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
NULL, NULL, TRUE,
__connman_ipconfig_get_dhcp_address(ipconfig_ipv6));
g_dhcpv6_client_clear_retransmit(dhcp->dhcp_client);
- if (dhcp->callback != NULL)
- dhcp->callback(dhcp->network, FALSE);
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network, CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
return FALSE;
}
}
int __connman_dhcpv6_start(struct connman_network *network,
- GSList *prefixes, dhcp_cb callback)
+ GSList *prefixes, dhcpv6_cb callback)
{
struct connman_service *service;
struct connman_ipconfig *ipconfig_ipv6;
DBG("");
- if (network_table != NULL) {
+ if (network_table) {
dhcp = g_hash_table_lookup(network_table, network);
- if (dhcp != NULL && dhcp->started == TRUE)
+ if (dhcp && dhcp->started)
return -EBUSY;
}
service = connman_service_lookup_from_network(network);
- if (service == NULL)
+ if (!service)
return -EINVAL;
dhcp = g_try_new0(struct connman_dhcpv6, 1);
- if (dhcp == NULL)
+ if (!dhcp)
return -ENOMEM;
dhcp->network = network;
dhcp->callback = callback;
dhcp->prefixes = prefixes;
- dhcp->started = TRUE;
+ dhcp->started = true;
connman_network_ref(network);
ipconfig_ipv6 = __connman_service_get_ip6config(service);
last_address = __connman_ipconfig_get_dhcp_address(ipconfig_ipv6);
- if (prefixes != NULL && last_address != NULL &&
+ if (prefixes && last_address &&
check_ipv6_addr_prefix(prefixes,
last_address) != 128) {
/*
{
DBG("");
- if (network_table == NULL)
+ if (!network_table)
return;
- if (g_hash_table_remove(network_table, network) == TRUE)
+ if (g_hash_table_remove(network_table, network))
connman_network_unref(network);
}
-int __connman_dhcpv6_init(void)
+static int save_prefixes(struct connman_ipconfig *ipconfig,
+ GSList *prefixes)
{
- DBG("");
+ GSList *list;
+ int i = 0, count = g_slist_length(prefixes);
+ char **array;
- srand(time(NULL));
+ if (count == 0)
+ return 0;
+
+ array = g_try_new0(char *, count + 1);
+ if (!array)
+ return -ENOMEM;
+
+ for (list = prefixes; list; list = list->next) {
+ char *elem, addr_str[INET6_ADDRSTRLEN];
+ GDHCPIAPrefix *prefix = list->data;
+
+ elem = g_strdup_printf("%s/%d", inet_ntop(AF_INET6,
+ &prefix->prefix, addr_str, INET6_ADDRSTRLEN),
+ prefix->prefixlen);
+ if (!elem) {
+ g_strfreev(array);
+ return -ENOMEM;
+ }
+
+ array[i++] = elem;
+ }
+
+ __connman_ipconfig_set_dhcpv6_prefixes(ipconfig, array);
+ return 0;
+}
+
+static GSList *load_prefixes(struct connman_ipconfig *ipconfig)
+{
+ int i;
+ GSList *list = NULL;
+ char **array = __connman_ipconfig_get_dhcpv6_prefixes(ipconfig);
+
+ if (!array)
+ return NULL;
+
+ for (i = 0; array[i]; i++) {
+ GDHCPIAPrefix *prefix;
+ long int value;
+ char *ptr, **elems = g_strsplit(array[i], "/", 0);
+
+ if (!elems)
+ return list;
+
+ value = strtol(elems[1], &ptr, 10);
+ if (ptr != elems[1] && *ptr == '\0' && value <= 128) {
+ struct in6_addr addr;
+
+ if (inet_pton(AF_INET6, elems[0], &addr) == 1) {
+ prefix = g_try_new0(GDHCPIAPrefix, 1);
+ if (!prefix) {
+ g_strfreev(elems);
+ return list;
+ }
+ memcpy(&prefix->prefix, &addr,
+ sizeof(struct in6_addr));
+ prefix->prefixlen = value;
+
+ list = g_slist_prepend(list, prefix);
+ }
+ }
+
+ g_strfreev(elems);
+ }
+
+ return list;
+}
+
+static GDHCPIAPrefix *copy_prefix(gpointer data)
+{
+ GDHCPIAPrefix *copy, *prefix = data;
+
+ copy = g_try_new(GDHCPIAPrefix, 1);
+ if (!copy)
+ return NULL;
+
+ memcpy(copy, prefix, sizeof(GDHCPIAPrefix));
+
+ return copy;
+}
+
+static GSList *copy_and_convert_prefixes(GList *prefixes)
+{
+ GSList *copy = NULL;
+ GList *list;
+
+ for (list = prefixes; list; list = list->next)
+ copy = g_slist_prepend(copy, copy_prefix(list->data));
+
+ return copy;
+}
+
+static int set_prefixes(GDHCPClient *dhcp_client, struct connman_dhcpv6 *dhcp)
+{
+ if (dhcp->prefixes)
+ g_slist_free_full(dhcp->prefixes, free_prefix);
+
+ dhcp->prefixes =
+ copy_and_convert_prefixes(g_dhcp_client_get_option(dhcp_client,
+ G_DHCPV6_IA_PD));
+
+ DBG("Got %d prefix", g_slist_length(dhcp->prefixes));
+
+ if (dhcp->callback) {
+ uint16_t status = g_dhcpv6_client_get_status(dhcp_client);
+ if (status == G_DHCPV6_ERROR_NO_PREFIX)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ else {
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+ int ifindex = connman_network_get_index(dhcp->network);
+
+ service = __connman_service_lookup_from_index(ifindex);
+ if (service) {
+ ipconfig = __connman_service_get_ip6config(
+ service);
+ save_prefixes(ipconfig, dhcp->prefixes);
+ __connman_service_save(service);
+ }
+
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, dhcp->prefixes);
+ }
+ } else {
+ g_slist_free_full(dhcp->prefixes, free_prefix);
+ dhcp->prefixes = NULL;
+ }
+
+ return 0;
+}
+
+static void re_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ uint16_t status;
+ int ret;
+
+ status = g_dhcpv6_client_get_status(dhcp_client);
+
+ DBG("dhcpv6 cb msg %p status %d", dhcp, status);
+
+ if (status == G_DHCPV6_ERROR_BINDING) {
+ /* RFC 3315, 18.1.8 */
+ dhcpv6_pd_request(dhcp);
+ } else {
+ ret = set_prefixes(dhcp_client, dhcp);
+ if (ret < 0) {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+ }
+}
+
+static void rebind_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_pd_cb(dhcp_client, user_data);
+}
+
+static GDHCPClient *create_pd_client(struct connman_dhcpv6 *dhcp, int *err)
+{
+ GDHCPClient *dhcp_client;
+ GDHCPClientError error;
+ struct connman_service *service;
+ int index, ret;
+ uint32_t iaid;
+
+ index = connman_network_get_index(dhcp->network);
+
+ dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
+ if (error != G_DHCP_CLIENT_ERROR_NONE) {
+ *err = -EINVAL;
+ return NULL;
+ }
+
+ if (getenv("CONNMAN_DHCPV6_DEBUG"))
+ g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6:PD");
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ g_dhcp_client_unref(dhcp_client);
+ *err = -EINVAL;
+ return NULL;
+ }
+
+ ret = set_duid(service, dhcp->network, dhcp_client, index);
+ if (ret < 0) {
+ g_dhcp_client_unref(dhcp_client);
+ *err = ret;
+ return NULL;
+ }
+
+ g_dhcpv6_client_create_iaid(dhcp_client, index, (unsigned char *)&iaid);
+ g_dhcpv6_client_set_iaid(dhcp_client, iaid);
+
+ return dhcp_client;
+}
+
+static int dhcpv6_pd_rebind(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p", dhcp);
+
+ if (!dhcp->dhcp_client) {
+ /*
+ * We skipped the solicitation phase
+ */
+ int err;
+
+ dhcp->dhcp_client = create_pd_client(dhcp, &err);
+ if (!dhcp->dhcp_client) {
+ clear_timer(dhcp);
+ return err;
+ }
+ }
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REBIND,
+ rebind_pd_cb, dhcp);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static void renew_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_pd_cb(dhcp_client, user_data);
+}
+
+static int dhcpv6_pd_renew(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_RENEW,
+ renew_pd_cb, dhcp);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+/*
+ * Check if we need to restart the solicitation procedure. This
+ * is done if all the prefixes have expired.
+ */
+static int check_pd_restart(struct connman_dhcpv6 *dhcp)
+{
+ time_t current, expired;
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, NULL,
+ NULL, &expired);
+ current = time(NULL);
+
+ if (current > expired) {
+ DBG("expired by %d secs", (int)(current - expired));
+
+ g_timeout_add(0, dhcpv6_restart, dhcp);
+
+ return -ETIMEDOUT;
+ }
+
+ return 0;
+}
+
+static gboolean timeout_pd_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_pd_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = calc_delay(dhcp->RT, REB_MAX_RT);
+
+ DBG("rebind RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_rebind, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_pd_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_pd_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = REB_TIMEOUT * (1 + get_random());
+
+ DBG("rebind initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_rebind, dhcp);
+
+ dhcpv6_pd_rebind(dhcp);
+
+ return FALSE;
+}
+
+static gboolean timeout_pd_rebind_confirm(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = calc_delay(dhcp->RT, CNF_MAX_RT);
+
+ DBG("rebind with confirm RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT,
+ timeout_pd_rebind_confirm, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean timeout_pd_max_confirm(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->MRD = 0;
+
+ clear_timer(dhcp);
+
+ DBG("rebind with confirm max retransmit duration timeout");
+
+ g_dhcpv6_client_clear_retransmit(dhcp->dhcp_client);
+
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_pd_rebind_with_confirm(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = CNF_TIMEOUT * (1 + get_random());
+
+ DBG("rebind with confirm initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT,
+ timeout_pd_rebind_confirm, dhcp);
+ dhcp->MRD = g_timeout_add(CNF_MAX_RD, timeout_pd_max_confirm, dhcp);
+
+ dhcpv6_pd_rebind(dhcp);
+
+ return FALSE;
+}
+
+static gboolean timeout_pd_renew(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_pd_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = calc_delay(dhcp->RT, REN_MAX_RT);
+
+ DBG("renew RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_renew, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_pd_renew(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = REN_TIMEOUT * (1 + get_random());
+
+ DBG("renew initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_renew, dhcp);
+
+ dhcpv6_pd_renew(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start_pd_renew(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ uint32_t T1, T2;
+ time_t started, current, expired;
+
+ dhcp = g_hash_table_lookup(network_pd_table, network);
+ if (!dhcp)
+ return -ENOENT;
+
+ DBG("network %p dhcp %p", network, dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, &T1, &T2,
+ &started, &expired);
+
+ current = time(NULL);
+
+ DBG("T1 %u T2 %u expires %lu current %lu started %lu", T1, T2,
+ expired, current, started);
+
+ if (T1 == 0xffffffff)
+ /* RFC 3633, ch 9 */
+ return 0;
+
+ if (T1 == 0)
+ /* RFC 3633, ch 9
+ * Client can choose the timeout.
+ */
+ T1 = 120;
+
+ dhcp->callback = callback;
+
+ /* RFC 3315, 18.1.4, start solicit if expired */
+ if (check_pd_restart(dhcp) < 0)
+ return 0;
+
+ if (T2 != 0xffffffff && T2 > 0) {
+ if ((unsigned)current >= (unsigned)started + T2) {
+ /* RFC 3315, chapter 18.1.3, start rebind */
+ DBG("rebind after %d secs", T2);
+
+ dhcp->timeout = g_timeout_add_seconds(T2,
+ start_pd_rebind,
+ dhcp);
+
+ } else if ((unsigned)current < (unsigned)started + T1) {
+ DBG("renew after %d secs", T1);
+
+ dhcp->timeout = g_timeout_add_seconds(T1,
+ start_pd_renew,
+ dhcp);
+ } else {
+ DBG("rebind after %d secs", T2 - T1);
+
+ dhcp->timeout = g_timeout_add_seconds(T2 - T1,
+ start_pd_rebind,
+ dhcp);
+ }
+ }
+
+ return 0;
+}
+
+static void release_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+}
+
+int __connman_dhcpv6_start_pd_release(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ if (!network_table)
+ return 0; /* we are already released */
+
+ dhcp = g_hash_table_lookup(network_pd_table, network);
+ if (!dhcp)
+ return -ENOENT;
+
+ DBG("network %p dhcp %p client %p", network, dhcp, dhcp->dhcp_client);
+
+ clear_timer(dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+ if (!dhcp_client) {
+ DBG("DHCPv6 PD was not started");
+ return 0;
+ }
+
+ g_dhcp_client_clear_requests(dhcp_client);
+ g_dhcp_client_clear_values(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_RELEASE,
+ release_pd_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean timeout_pd_request(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return FALSE;
+ }
+
+ dhcp->request_count++;
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_request, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static void request_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ uint16_t status;
+
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ status = g_dhcpv6_client_get_status(dhcp_client);
+
+ DBG("dhcpv6 pd cb msg %p status %d", dhcp, status);
+
+ if (status == G_DHCPV6_ERROR_BINDING) {
+ /* RFC 3315, 18.1.8 */
+ dhcpv6_pd_request(dhcp);
+ } else {
+ set_prefixes(dhcp_client, dhcp);
+ }
+}
+
+static int dhcpv6_pd_request(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1 = 0, T2 = 0;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
+ request_pd_cb, dhcp);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static void advertise_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ DBG("dhcpv6 advertise pd msg %p", dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+
+ dhcp->RT = REQ_TIMEOUT * (1 + get_random());
+ DBG("request initial RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_request, dhcp);
+
+ dhcp->request_count = 1;
+
+ dhcpv6_pd_request(dhcp);
+}
+
+static void solicitation_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ /*
+ * This callback is here so that g_dhcp_client_start()
+ * will enter the proper L3 mode.
+ */
+ DBG("DHCPv6 %p solicitation msg received, ignoring it", user_data);
+}
+
+static int dhcpv6_pd_solicitation(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ int ret;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = create_pd_client(dhcp, &ret);
+ if (!dhcp_client) {
+ clear_timer(dhcp);
+ return ret;
+ }
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+
+ g_dhcpv6_client_set_pd(dhcp_client, NULL, NULL, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_ADVERTISE,
+ advertise_pd_cb, dhcp);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_SOLICITATION,
+ solicitation_pd_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean start_pd_solicitation(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ /* Set the retransmission timeout, RFC 3315 chapter 14 */
+ dhcp->RT = SOL_TIMEOUT * (1 + get_random());
+
+ DBG("solicit initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
+
+ dhcpv6_pd_solicitation(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start_pd(int index, GSList *prefixes, dhcpv6_cb callback)
+{
+ struct connman_service *service;
+ struct connman_network *network;
+ struct connman_dhcpv6 *dhcp;
+
+ if (index < 0)
+ return 0;
+
+ DBG("index %d", index);
+
+ service = __connman_service_lookup_from_index(index);
+ if (!service)
+ return -EINVAL;
+
+ network = __connman_service_get_network(service);
+ if (!network)
+ return -EINVAL;
+
+ if (network_pd_table) {
+ dhcp = g_hash_table_lookup(network_pd_table, network);
+ if (dhcp && dhcp->started)
+ return -EBUSY;
+ }
+
+ dhcp = g_try_new0(struct connman_dhcpv6, 1);
+ if (!dhcp)
+ return -ENOMEM;
+
+ dhcp->network = network;
+ dhcp->callback = callback;
+ dhcp->started = true;
+
+ if (!prefixes) {
+ /*
+ * Try to load the earlier prefixes if caller did not supply
+ * any that we could use.
+ */
+ struct connman_ipconfig *ipconfig;
+ ipconfig = __connman_service_get_ip6config(service);
+
+ dhcp->prefixes = load_prefixes(ipconfig);
+ } else
+ dhcp->prefixes = prefixes;
+
+ connman_network_ref(network);
+
+ DBG("replace network %p dhcp %p", network, dhcp);
+
+ g_hash_table_replace(network_pd_table, network, dhcp);
+
+ if (!dhcp->prefixes) {
+ /*
+ * Refresh start, try to get prefixes.
+ */
+ start_pd_solicitation(dhcp);
+ } else {
+ /*
+ * We used to have prefixes, try to use them again.
+ * We need to use timeouts from confirm msg, RFC 3633, ch 12.1
+ */
+ start_pd_rebind_with_confirm(dhcp);
+ }
+
+ return 0;
+}
+
+void __connman_dhcpv6_stop_pd(int index)
+{
+ struct connman_service *service;
+ struct connman_network *network;
+
+ if (index < 0)
+ return;
+
+ DBG("index %d", index);
+
+ if (!network_pd_table)
+ return;
+
+ service = __connman_service_lookup_from_index(index);
+ if (!service)
+ return;
+
+ network = __connman_service_get_network(service);
+ if (!network)
+ return;
+
+ __connman_dhcpv6_start_pd_release(network, NULL);
+
+ if (g_hash_table_remove(network_pd_table, network))
+ connman_network_unref(network);
+}
+
+int __connman_dhcpv6_init(void)
+{
+ DBG("");
+
+ srand(time(NULL));
network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, remove_network);
+ network_pd_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, remove_network);
+
return 0;
}
g_hash_table_destroy(network_table);
network_table = NULL;
+
+ g_hash_table_destroy(network_pd_table);
+ network_pd_table = NULL;
}
projects / platform / upstream / connman.git / blobdiff