5 * Copyright (C) 2012 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
30 #include <connman/ipconfig.h>
31 #include <connman/storage.h>
33 #include <gdhcp/gdhcp.h>
39 /* Transmission params in msec, RFC 3315 chapter 5.5 */
40 #define INF_MAX_DELAY (1 * 1000)
41 #define INF_TIMEOUT (1 * 1000)
42 #define INF_MAX_RT (120 * 1000)
43 #define SOL_MAX_DELAY (1 * 1000)
44 #define SOL_TIMEOUT (1 * 1000)
45 #define SOL_MAX_RT (120 * 1000)
46 #define REQ_TIMEOUT (1 * 1000)
47 #define REQ_MAX_RT (30 * 1000)
49 #define REN_TIMEOUT (10 * 1000)
50 #define REN_MAX_RT (600 * 1000)
51 #define REB_TIMEOUT (10 * 1000)
52 #define REB_MAX_RT (600 * 1000)
55 struct connman_dhcpv6 {
56 struct connman_network *network;
62 GDHCPClient *dhcp_client;
64 guint timeout; /* operation timeout in msec */
65 guint RT; /* in msec */
66 gboolean use_ta; /* set to TRUE if IPv6 privacy is enabled */
67 GSList *prefixes; /* network prefixes from radvd */
68 int request_count; /* how many times REQUEST have been sent */
69 gboolean stateless; /* TRUE if stateless DHCPv6 is used */
70 gboolean started; /* TRUE if we have DHCPv6 started */
73 static GHashTable *network_table;
75 static int dhcpv6_request(struct connman_dhcpv6 *dhcp, gboolean add_addresses);
77 static void clear_timer(struct connman_dhcpv6 *dhcp)
79 if (dhcp->timeout > 0) {
80 g_source_remove(dhcp->timeout);
85 static inline float get_random()
87 return (rand() % 200 - 100) / 1000.0;
90 /* Calculate a random delay, RFC 3315 chapter 14 */
91 /* RT and MRT are milliseconds */
92 static guint calc_delay(guint RT, guint MRT)
94 float delay = get_random();
95 float rt = RT * (2 + delay);
98 rt = MRT * (1 + delay);
106 static void free_prefix(gpointer data, gpointer user_data)
111 static void dhcpv6_free(struct connman_dhcpv6 *dhcp)
113 g_strfreev(dhcp->nameservers);
114 g_strfreev(dhcp->timeservers);
116 dhcp->nameservers = NULL;
117 dhcp->timeservers = NULL;
118 dhcp->started = FALSE;
120 g_slist_foreach(dhcp->prefixes, free_prefix, NULL);
121 g_slist_free(dhcp->prefixes);
124 static gboolean compare_string_arrays(char **array_a, char **array_b)
128 if (array_a == NULL || array_b == NULL)
131 if (g_strv_length(array_a) != g_strv_length(array_b))
134 for (i = 0; array_a[i] != NULL && array_b[i] != NULL; i++)
135 if (g_strcmp0(array_a[i], array_b[i]) != 0)
141 static void dhcpv6_debug(const char *str, void *data)
143 connman_info("%s: %s\n", (const char *) data, str);
146 static gchar *convert_to_hex(unsigned char *buf, int len)
148 gchar *ret = g_try_malloc(len * 2 + 1);
151 for (i = 0; ret != NULL && i < len; i++)
152 g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
158 * DUID should not change over time so save it to file.
159 * See RFC 3315 chapter 9 for details.
161 static int set_duid(struct connman_service *service,
162 struct connman_network *network,
163 GDHCPClient *dhcp_client, int index)
171 ident = __connman_service_get_ident(service);
173 keyfile = connman_storage_load_service(ident);
177 hex_duid = g_key_file_get_string(keyfile, ident, "IPv6.DHCP.DUID",
179 if (hex_duid != NULL) {
180 unsigned int i, j = 0, hex;
181 size_t hex_duid_len = strlen(hex_duid);
183 duid = g_try_malloc0(hex_duid_len / 2);
185 g_key_file_free(keyfile);
190 for (i = 0; i < hex_duid_len; i += 2) {
191 sscanf(hex_duid + i, "%02x", &hex);
195 duid_len = hex_duid_len / 2;
198 int type = __connman_ipconfig_get_type_from_index(index);
200 ret = g_dhcpv6_create_duid(G_DHCPV6_DUID_LLT, index, type,
203 g_key_file_free(keyfile);
207 hex_duid = convert_to_hex(duid, duid_len);
208 if (hex_duid == NULL) {
209 g_key_file_free(keyfile);
213 g_key_file_set_string(keyfile, ident, "IPv6.DHCP.DUID",
216 __connman_storage_save_service(keyfile, ident);
220 g_key_file_free(keyfile);
222 g_dhcpv6_client_set_duid(dhcp_client, duid, duid_len);
227 static void clear_callbacks(GDHCPClient *dhcp_client)
229 g_dhcp_client_register_event(dhcp_client,
230 G_DHCP_CLIENT_EVENT_SOLICITATION,
233 g_dhcp_client_register_event(dhcp_client,
234 G_DHCP_CLIENT_EVENT_ADVERTISE,
237 g_dhcp_client_register_event(dhcp_client,
238 G_DHCP_CLIENT_EVENT_REQUEST,
241 g_dhcp_client_register_event(dhcp_client,
242 G_DHCP_CLIENT_EVENT_RENEW,
245 g_dhcp_client_register_event(dhcp_client,
246 G_DHCP_CLIENT_EVENT_REBIND,
249 g_dhcp_client_register_event(dhcp_client,
250 G_DHCP_CLIENT_EVENT_RELEASE,
253 g_dhcp_client_register_event(dhcp_client,
254 G_DHCP_CLIENT_EVENT_INFORMATION_REQ,
258 static void info_req_cb(GDHCPClient *dhcp_client, gpointer user_data)
260 struct connman_dhcpv6 *dhcp = user_data;
261 struct connman_service *service;
263 GList *option, *list;
264 char **nameservers, **timeservers;
266 DBG("dhcpv6 information-request %p", dhcp);
268 service = __connman_service_lookup_from_network(dhcp->network);
269 if (service == NULL) {
270 connman_error("Can not lookup service");
274 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
275 entries = g_list_length(option);
277 nameservers = g_try_new0(char *, entries + 1);
278 if (nameservers != NULL) {
279 for (i = 0, list = option; list; list = list->next, i++)
280 nameservers[i] = g_strdup(list->data);
283 if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
284 if (dhcp->nameservers != NULL) {
285 for (i = 0; dhcp->nameservers[i] != NULL; i++)
286 __connman_service_nameserver_remove(service,
287 dhcp->nameservers[i],
289 g_strfreev(dhcp->nameservers);
292 dhcp->nameservers = nameservers;
294 for (i = 0; dhcp->nameservers != NULL &&
295 dhcp->nameservers[i] != NULL; i++)
296 __connman_service_nameserver_append(service,
297 dhcp->nameservers[i],
300 g_strfreev(nameservers);
303 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
304 entries = g_list_length(option);
306 timeservers = g_try_new0(char *, entries + 1);
307 if (timeservers != NULL) {
308 for (i = 0, list = option; list; list = list->next, i++)
309 timeservers[i] = g_strdup(list->data);
312 if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
313 if (dhcp->timeservers != NULL) {
314 for (i = 0; dhcp->timeservers[i] != NULL; i++)
315 __connman_service_timeserver_remove(service,
316 dhcp->timeservers[i]);
317 g_strfreev(dhcp->timeservers);
320 dhcp->timeservers = timeservers;
322 for (i = 0; dhcp->timeservers != NULL &&
323 dhcp->timeservers[i] != NULL; i++)
324 __connman_service_timeserver_append(service,
325 dhcp->timeservers[i]);
327 g_strfreev(timeservers);
330 if (dhcp->callback != NULL) {
331 uint16_t status = g_dhcpv6_client_get_status(dhcp_client);
332 dhcp->callback(dhcp->network, status == 0 ? TRUE : FALSE);
336 static int dhcpv6_info_request(struct connman_dhcpv6 *dhcp)
338 struct connman_service *service;
339 GDHCPClient *dhcp_client;
340 GDHCPClientError error;
343 DBG("dhcp %p", dhcp);
345 index = connman_network_get_index(dhcp->network);
347 dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
348 if (error != G_DHCP_CLIENT_ERROR_NONE) {
353 if (getenv("CONNMAN_DHCPV6_DEBUG"))
354 g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
356 service = __connman_service_lookup_from_network(dhcp->network);
357 if (service == NULL) {
359 g_dhcp_client_unref(dhcp_client);
363 ret = set_duid(service, dhcp->network, dhcp_client, index);
366 g_dhcp_client_unref(dhcp_client);
370 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
371 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
372 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
374 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
375 G_DHCPV6_SNTP_SERVERS);
377 g_dhcp_client_register_event(dhcp_client,
378 G_DHCP_CLIENT_EVENT_INFORMATION_REQ, info_req_cb, dhcp);
380 dhcp->dhcp_client = dhcp_client;
382 return g_dhcp_client_start(dhcp_client, NULL);
385 static int check_ipv6_addr_prefix(GSList *prefixes, char *address)
387 struct in6_addr addr_prefix, addr;
391 for (list = prefixes; list; list = list->next) {
392 char *prefix = list->data;
393 const char *slash = g_strrstr(prefix, "/");
394 const unsigned char bits[] = { 0x00, 0xFE, 0xFC, 0xF8,
395 0xF0, 0xE0, 0xC0, 0x80 };
396 int left, count, i, plen;
401 prefix = g_strndup(prefix, slash - prefix);
402 len = strtol(slash + 1, NULL, 10);
409 inet_pton(AF_INET6, prefix, &addr_prefix);
410 inet_pton(AF_INET6, address, &addr);
412 memset(&addr_prefix.s6_addr[i], 0, count);
413 memset(&addr.s6_addr[i], 0, count);
416 addr_prefix.s6_addr[i - 1] &= bits[left];
417 addr.s6_addr[i - 1] &= bits[left];
422 if (memcmp(&addr_prefix, &addr, 16) == 0) {
431 static int set_addresses(GDHCPClient *dhcp_client,
432 struct connman_dhcpv6 *dhcp)
434 struct connman_service *service;
435 struct connman_ipconfig *ipconfig;
437 GList *option, *list;
438 char **nameservers, **timeservers;
439 const char *c_address;
440 char *address = NULL;
442 service = __connman_service_lookup_from_network(dhcp->network);
443 if (service == NULL) {
444 connman_error("Can not lookup service");
448 ipconfig = __connman_service_get_ip6config(service);
449 if (ipconfig == NULL) {
450 connman_error("Could not lookup ip6config");
454 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
455 entries = g_list_length(option);
457 nameservers = g_try_new0(char *, entries + 1);
458 if (nameservers != NULL) {
459 for (i = 0, list = option; list; list = list->next, i++)
460 nameservers[i] = g_strdup(list->data);
463 if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
464 if (dhcp->nameservers != NULL) {
465 for (i = 0; dhcp->nameservers[i] != NULL; i++)
466 __connman_service_nameserver_remove(service,
467 dhcp->nameservers[i],
469 g_strfreev(dhcp->nameservers);
472 dhcp->nameservers = nameservers;
474 for (i = 0; dhcp->nameservers[i] != NULL; i++)
475 __connman_service_nameserver_append(service,
476 dhcp->nameservers[i],
479 g_strfreev(nameservers);
482 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
483 entries = g_list_length(option);
485 timeservers = g_try_new0(char *, entries + 1);
486 if (timeservers != NULL) {
487 for (i = 0, list = option; list; list = list->next, i++)
488 timeservers[i] = g_strdup(list->data);
491 if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
492 if (dhcp->timeservers != NULL) {
493 for (i = 0; dhcp->timeservers[i] != NULL; i++)
494 __connman_service_timeserver_remove(service,
495 dhcp->timeservers[i]);
496 g_strfreev(dhcp->timeservers);
499 dhcp->timeservers = timeservers;
501 for (i = 0; dhcp->timeservers[i] != NULL; i++)
502 __connman_service_timeserver_append(service,
503 dhcp->timeservers[i]);
505 g_strfreev(timeservers);
508 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
510 address = g_strdup(option->data);
512 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
514 address = g_strdup(option->data);
517 c_address = __connman_ipconfig_get_local(ipconfig);
519 if (address != NULL &&
520 ((c_address != NULL &&
521 g_strcmp0(address, c_address) != 0) ||
522 (c_address == NULL))) {
525 /* Is this prefix part of the subnet we are suppose to use? */
526 prefix_len = check_ipv6_addr_prefix(dhcp->prefixes, address);
528 __connman_ipconfig_set_local(ipconfig, address);
529 __connman_ipconfig_set_prefixlen(ipconfig, prefix_len);
531 DBG("new address %s/%d", address, prefix_len);
537 static void re_cb(GDHCPClient *dhcp_client, gpointer user_data)
539 struct connman_dhcpv6 *dhcp = user_data;
543 ret = set_addresses(dhcp_client, dhcp);
545 status = g_dhcpv6_client_get_status(dhcp_client);
547 DBG("dhcpv6 cb msg %p ret %d status %d", dhcp, ret, status);
550 if (dhcp->callback != NULL)
551 dhcp->callback(dhcp->network, FALSE);
555 if (status == G_DHCPV6_ERROR_BINDING) {
556 /* RFC 3315, 18.1.8 */
557 dhcpv6_request(dhcp, FALSE);
559 if (dhcp->callback != NULL)
560 dhcp->callback(dhcp->network,
561 status == 0 ? TRUE : FALSE);
565 static void rebind_cb(GDHCPClient *dhcp_client, gpointer user_data)
569 g_dhcpv6_client_reset_rebind(dhcp_client);
570 g_dhcpv6_client_reset_renew(dhcp_client);
572 re_cb(dhcp_client, user_data);
575 static int dhcpv6_rebind(struct connman_dhcpv6 *dhcp)
577 GDHCPClient *dhcp_client;
579 DBG("dhcp %p", dhcp);
581 dhcp_client = dhcp->dhcp_client;
583 g_dhcp_client_clear_requests(dhcp_client);
585 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
586 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
587 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
589 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
590 G_DHCPV6_SNTP_SERVERS);
592 g_dhcpv6_client_set_ia(dhcp_client,
593 connman_network_get_index(dhcp->network),
594 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
597 clear_callbacks(dhcp_client);
599 g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REBIND,
602 dhcp->dhcp_client = dhcp_client;
604 return g_dhcp_client_start(dhcp_client, NULL);
607 static gboolean dhcpv6_restart(gpointer user_data)
609 struct connman_dhcpv6 *dhcp = user_data;
611 if (dhcp->callback != NULL)
612 dhcp->callback(dhcp->network, FALSE);
618 * Check if we need to restart the solicitation procedure. This
619 * is done if all the addresses have expired. RFC 3315, 18.1.4
621 static int check_restart(struct connman_dhcpv6 *dhcp)
623 time_t current, expired;
625 g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, NULL,
626 NULL, NULL, &expired);
627 current = time(NULL);
629 if (current > expired) {
630 DBG("expired by %d secs", (int)(current - expired));
632 g_timeout_add(0, dhcpv6_restart, dhcp);
640 static gboolean timeout_rebind(gpointer user_data)
642 struct connman_dhcpv6 *dhcp = user_data;
644 if (check_restart(dhcp) < 0)
647 dhcp->RT = calc_delay(dhcp->RT, REB_MAX_RT);
649 DBG("rebind RT timeout %d msec", dhcp->RT);
651 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
653 g_dhcp_client_start(dhcp->dhcp_client, NULL);
658 static gboolean start_rebind(gpointer user_data)
660 struct connman_dhcpv6 *dhcp = user_data;
662 dhcp->RT = REB_TIMEOUT * (1 + get_random());
664 DBG("rebind initial RT timeout %d msec", dhcp->RT);
666 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
673 static void request_cb(GDHCPClient *dhcp_client, gpointer user_data)
677 re_cb(dhcp_client, user_data);
680 static int dhcpv6_request(struct connman_dhcpv6 *dhcp,
681 gboolean add_addresses)
683 GDHCPClient *dhcp_client;
686 DBG("dhcp %p add %d", dhcp, add_addresses);
688 dhcp_client = dhcp->dhcp_client;
690 g_dhcp_client_clear_requests(dhcp_client);
692 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
693 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
694 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
695 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
697 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
698 G_DHCPV6_SNTP_SERVERS);
700 g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL, NULL);
701 g_dhcpv6_client_set_ia(dhcp_client,
702 connman_network_get_index(dhcp->network),
703 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
704 &T1, &T2, add_addresses);
706 clear_callbacks(dhcp_client);
708 g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
711 dhcp->dhcp_client = dhcp_client;
713 return g_dhcp_client_start(dhcp_client, NULL);
716 static gboolean timeout_request(gpointer user_data)
718 struct connman_dhcpv6 *dhcp = user_data;
720 if (dhcp->request_count >= REQ_MAX_RC) {
721 DBG("max request retry attempts %d", dhcp->request_count);
722 dhcp->request_count = 0;
723 if (dhcp->callback != NULL)
724 dhcp->callback(dhcp->network, FALSE);
728 dhcp->request_count++;
730 dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
731 DBG("request RT timeout %d msec", dhcp->RT);
732 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
734 g_dhcp_client_start(dhcp->dhcp_client, NULL);
739 static void renew_cb(GDHCPClient *dhcp_client, gpointer user_data)
743 g_dhcpv6_client_reset_renew(dhcp_client);
745 re_cb(dhcp_client, user_data);
748 static int dhcpv6_renew(struct connman_dhcpv6 *dhcp)
750 GDHCPClient *dhcp_client;
753 DBG("dhcp %p", dhcp);
755 dhcp_client = dhcp->dhcp_client;
757 g_dhcp_client_clear_requests(dhcp_client);
759 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
760 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
761 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
762 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
764 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
765 G_DHCPV6_SNTP_SERVERS);
767 g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL, NULL);
768 g_dhcpv6_client_set_ia(dhcp_client,
769 connman_network_get_index(dhcp->network),
770 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
773 clear_callbacks(dhcp_client);
775 g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_RENEW,
778 dhcp->dhcp_client = dhcp_client;
780 return g_dhcp_client_start(dhcp_client, NULL);
783 static gboolean timeout_renew(gpointer user_data)
785 struct connman_dhcpv6 *dhcp = user_data;
787 if (check_restart(dhcp) < 0)
790 dhcp->RT = calc_delay(dhcp->RT, REN_MAX_RT);
792 DBG("renew RT timeout %d msec", dhcp->RT);
794 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_renew, dhcp);
796 g_dhcp_client_start(dhcp->dhcp_client, NULL);
801 static gboolean start_renew(gpointer user_data)
803 struct connman_dhcpv6 *dhcp = user_data;
805 dhcp->RT = REN_TIMEOUT * (1 + get_random());
807 DBG("renew initial RT timeout %d msec", dhcp->RT);
809 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_renew, dhcp);
816 int __connman_dhcpv6_start_renew(struct connman_network *network,
819 struct connman_dhcpv6 *dhcp;
821 time_t last_renew, last_rebind, current, expired;
823 dhcp = g_hash_table_lookup(network_table, network);
827 DBG("network %p dhcp %p", network, dhcp);
831 g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, &T1, &T2,
832 &last_renew, &last_rebind, &expired);
834 current = time(NULL);
836 DBG("T1 %u T2 %u expires %lu current %lu", T1, T2,
837 (unsigned long)expired, current);
839 if (T1 == 0xffffffff)
845 * Client can choose the timeout.
849 /* RFC 3315, 18.1.4, start solicit if expired */
850 if (current > expired) {
851 DBG("expired by %d secs", (int)(current - expired));
855 dhcp->callback = callback;
857 if (T2 != 0xffffffff && T2 > 0 &&
858 (unsigned)current > (unsigned)last_rebind + T2) {
861 /* RFC 3315, chapter 18.1.3, start rebind */
862 if ((unsigned)current > (unsigned)last_renew + T1)
865 timeout = last_renew - current + T1;
868 * If we just did a renew, do not restart the rebind
871 dhcp->timeout = g_timeout_add_seconds(timeout, start_rebind,
874 DBG("renew after %d secs", T1);
876 dhcp->timeout = g_timeout_add_seconds(T1, start_renew, dhcp);
881 int __connman_dhcpv6_start_release(struct connman_network *network,
884 struct connman_dhcpv6 *dhcp;
885 GDHCPClient *dhcp_client;
887 if (network_table == NULL)
888 return 0; /* we are already released */
890 dhcp = g_hash_table_lookup(network_table, network);
894 DBG("network %p dhcp %p client %p stateless %d", network, dhcp,
895 dhcp->dhcp_client, dhcp->stateless);
897 if (dhcp->stateless == TRUE)
902 dhcp_client = dhcp->dhcp_client;
903 if (dhcp_client == NULL) {
905 * We had started the DHCPv6 handshaking i.e., we have called
906 * __connman_dhcpv6_start() but it has not yet sent
907 * a solicitation message to server. This means that we do not
908 * have DHCPv6 configured yet so we can just quit here.
910 DBG("DHCPv6 was not started");
914 g_dhcp_client_clear_requests(dhcp_client);
915 g_dhcp_client_clear_values(dhcp_client);
917 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
918 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
920 g_dhcpv6_client_set_ia(dhcp_client,
921 connman_network_get_index(dhcp->network),
922 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
925 clear_callbacks(dhcp_client);
928 * We do not register callback here because the answer might take too
929 * long time and network code might be in the middle of the disconnect.
930 * So we just inform the server that we are done with the addresses
931 * but ignore the reply from server. This is allowed by RFC 3315
935 dhcp->dhcp_client = dhcp_client;
937 return g_dhcp_client_start(dhcp_client, NULL);
940 static int dhcpv6_release(struct connman_dhcpv6 *dhcp)
942 DBG("dhcp %p", dhcp);
948 if (dhcp->dhcp_client == NULL)
951 g_dhcp_client_stop(dhcp->dhcp_client);
952 g_dhcp_client_unref(dhcp->dhcp_client);
954 dhcp->dhcp_client = NULL;
959 static void remove_network(gpointer user_data)
961 struct connman_dhcpv6 *dhcp = user_data;
963 DBG("dhcp %p", dhcp);
965 dhcpv6_release(dhcp);
970 static gboolean timeout_info_req(gpointer user_data)
972 struct connman_dhcpv6 *dhcp = user_data;
974 dhcp->RT = calc_delay(dhcp->RT, INF_MAX_RT);
976 DBG("info RT timeout %d msec", dhcp->RT);
978 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
980 g_dhcp_client_start(dhcp->dhcp_client, NULL);
985 static gboolean start_info_req(gpointer user_data)
987 struct connman_dhcpv6 *dhcp = user_data;
989 /* Set the retransmission timeout, RFC 3315 chapter 14 */
990 dhcp->RT = INF_TIMEOUT * (1 + get_random());
992 DBG("info initial RT timeout %d msec", dhcp->RT);
994 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
996 dhcpv6_info_request(dhcp);
1001 int __connman_dhcpv6_start_info(struct connman_network *network,
1004 struct connman_dhcpv6 *dhcp;
1009 if (network_table != NULL) {
1010 dhcp = g_hash_table_lookup(network_table, network);
1011 if (dhcp != NULL && dhcp->started == TRUE)
1015 dhcp = g_try_new0(struct connman_dhcpv6, 1);
1019 dhcp->network = network;
1020 dhcp->callback = callback;
1021 dhcp->stateless = TRUE;
1022 dhcp->started = TRUE;
1024 connman_network_ref(network);
1026 DBG("replace network %p dhcp %p", network, dhcp);
1028 g_hash_table_replace(network_table, network, dhcp);
1030 /* Initial timeout, RFC 3315, 18.1.5 */
1031 delay = rand() % 1000;
1033 dhcp->timeout = g_timeout_add(delay, start_info_req, dhcp);
1038 static void advertise_cb(GDHCPClient *dhcp_client, gpointer user_data)
1040 struct connman_dhcpv6 *dhcp = user_data;
1042 DBG("dhcpv6 advertise msg %p", dhcp);
1046 if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
1047 if (dhcp->callback != NULL)
1048 dhcp->callback(dhcp->network, FALSE);
1052 dhcp->RT = REQ_TIMEOUT * (1 + get_random());
1053 DBG("request initial RT timeout %d msec", dhcp->RT);
1054 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
1056 dhcp->request_count = 1;
1058 dhcpv6_request(dhcp, TRUE);
1061 static void solicitation_cb(GDHCPClient *dhcp_client, gpointer user_data)
1063 /* We get here if server supports rapid commit */
1064 struct connman_dhcpv6 *dhcp = user_data;
1066 DBG("dhcpv6 solicitation msg %p", dhcp);
1070 set_addresses(dhcp_client, dhcp);
1073 static gboolean timeout_solicitation(gpointer user_data)
1075 struct connman_dhcpv6 *dhcp = user_data;
1077 dhcp->RT = calc_delay(dhcp->RT, SOL_MAX_RT);
1079 DBG("solicit RT timeout %d msec", dhcp->RT);
1081 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
1083 g_dhcp_client_start(dhcp->dhcp_client, NULL);
1088 static int dhcpv6_solicitation(struct connman_dhcpv6 *dhcp)
1090 struct connman_service *service;
1091 struct connman_ipconfig *ipconfig_ipv6;
1092 GDHCPClient *dhcp_client;
1093 GDHCPClientError error;
1096 DBG("dhcp %p", dhcp);
1098 index = connman_network_get_index(dhcp->network);
1100 dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
1101 if (error != G_DHCP_CLIENT_ERROR_NONE) {
1106 if (getenv("CONNMAN_DHCPV6_DEBUG"))
1107 g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
1109 service = __connman_service_lookup_from_network(dhcp->network);
1110 if (service == NULL) {
1112 g_dhcp_client_unref(dhcp_client);
1116 ret = set_duid(service, dhcp->network, dhcp_client, index);
1119 g_dhcp_client_unref(dhcp_client);
1123 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
1124 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_RAPID_COMMIT);
1125 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
1126 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
1128 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
1129 G_DHCPV6_SNTP_SERVERS);
1131 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1132 dhcp->use_ta = __connman_ipconfig_ipv6_privacy_enabled(ipconfig_ipv6);
1134 g_dhcpv6_client_set_ia(dhcp_client, index,
1135 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
1138 clear_callbacks(dhcp_client);
1140 g_dhcp_client_register_event(dhcp_client,
1141 G_DHCP_CLIENT_EVENT_SOLICITATION,
1142 solicitation_cb, dhcp);
1144 g_dhcp_client_register_event(dhcp_client,
1145 G_DHCP_CLIENT_EVENT_ADVERTISE,
1146 advertise_cb, dhcp);
1148 dhcp->dhcp_client = dhcp_client;
1150 return g_dhcp_client_start(dhcp_client, NULL);
1153 static gboolean start_solicitation(gpointer user_data)
1155 struct connman_dhcpv6 *dhcp = user_data;
1157 /* Set the retransmission timeout, RFC 3315 chapter 14 */
1158 dhcp->RT = SOL_TIMEOUT * (1 + get_random());
1160 DBG("solicit initial RT timeout %d msec", dhcp->RT);
1162 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
1164 dhcpv6_solicitation(dhcp);
1169 int __connman_dhcpv6_start(struct connman_network *network,
1170 GSList *prefixes, dhcp_cb callback)
1172 struct connman_dhcpv6 *dhcp;
1177 if (network_table != NULL) {
1178 dhcp = g_hash_table_lookup(network_table, network);
1179 if (dhcp != NULL && dhcp->started == TRUE)
1183 dhcp = g_try_new0(struct connman_dhcpv6, 1);
1187 dhcp->network = network;
1188 dhcp->callback = callback;
1189 dhcp->prefixes = prefixes;
1190 dhcp->started = TRUE;
1192 connman_network_ref(network);
1194 DBG("replace network %p dhcp %p", network, dhcp);
1196 g_hash_table_replace(network_table, network, dhcp);
1198 /* Initial timeout, RFC 3315, 17.1.2 */
1199 delay = rand() % 1000;
1201 dhcp->timeout = g_timeout_add(delay, start_solicitation, dhcp);
1206 void __connman_dhcpv6_stop(struct connman_network *network)
1210 if (network_table == NULL)
1213 if (g_hash_table_remove(network_table, network) == TRUE)
1214 connman_network_unref(network);
1217 int __connman_dhcpv6_init(void)
1223 network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1224 NULL, remove_network);
1229 void __connman_dhcpv6_cleanup(void)
1233 g_hash_table_destroy(network_table);
1234 network_table = NULL;