5 * Copyright (C) 2011 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)
51 struct connman_dhcpv6 {
52 struct connman_network *network;
58 GDHCPClient *dhcp_client;
60 guint timeout; /* operation timeout in msec */
61 guint RT; /* in msec */
62 gboolean use_ta; /* set to TRUE if IPv6 privacy is enabled */
63 GSList *prefixes; /* network prefixes from radvd */
64 int request_count; /* how many times REQUEST have been sent */
67 static GHashTable *network_table;
69 static int dhcpv6_request(struct connman_dhcpv6 *dhcp, gboolean add_addresses);
71 static inline float get_random()
73 return (rand() % 200 - 100) / 1000.0;
76 /* Calculate a random delay, RFC 3315 chapter 14 */
77 /* RT and MRT are milliseconds */
78 static guint calc_delay(guint RT, guint MRT)
80 float delay = get_random();
81 float rt = RT * (2 + delay);
84 rt = MRT * (1 + delay);
92 static void free_prefix(gpointer data, gpointer user_data)
97 static void dhcpv6_free(struct connman_dhcpv6 *dhcp)
99 g_strfreev(dhcp->nameservers);
100 g_strfreev(dhcp->timeservers);
102 dhcp->nameservers = NULL;
103 dhcp->timeservers = NULL;
105 g_slist_foreach(dhcp->prefixes, free_prefix, NULL);
106 g_slist_free(dhcp->prefixes);
109 static gboolean compare_string_arrays(char **array_a, char **array_b)
113 if (array_a == NULL || array_b == NULL)
116 if (g_strv_length(array_a) != g_strv_length(array_b))
119 for (i = 0; array_a[i] != NULL && array_b[i] != NULL; i++)
120 if (g_strcmp0(array_a[i], array_b[i]) != 0)
126 static void dhcpv6_debug(const char *str, void *data)
128 connman_info("%s: %s\n", (const char *) data, str);
131 static gchar *convert_to_hex(unsigned char *buf, int len)
133 gchar *ret = g_try_malloc(len * 2 + 1);
136 for (i = 0; ret != NULL && i < len; i++)
137 g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
143 * DUID should not change over time so save it to file.
144 * See RFC 3315 chapter 9 for details.
146 static int set_duid(struct connman_service *service,
147 struct connman_network *network,
148 GDHCPClient *dhcp_client, int index)
156 ident = __connman_service_get_ident(service);
158 keyfile = connman_storage_load_service(ident);
162 hex_duid = g_key_file_get_string(keyfile, ident, "IPv6.DHCP.DUID",
164 if (hex_duid != NULL) {
165 unsigned int i, j = 0, hex;
166 size_t hex_duid_len = strlen(hex_duid);
168 duid = g_try_malloc0(hex_duid_len / 2);
170 g_key_file_free(keyfile);
175 for (i = 0; i < hex_duid_len; i += 2) {
176 sscanf(hex_duid + i, "%02x", &hex);
180 duid_len = hex_duid_len / 2;
183 int type = __connman_ipconfig_get_type_from_index(index);
185 ret = g_dhcpv6_create_duid(G_DHCPV6_DUID_LLT, index, type,
188 g_key_file_free(keyfile);
192 hex_duid = convert_to_hex(duid, duid_len);
193 if (hex_duid == NULL) {
194 g_key_file_free(keyfile);
198 g_key_file_set_string(keyfile, ident, "IPv6.DHCP.DUID",
201 __connman_storage_save_service(keyfile, ident);
205 g_key_file_free(keyfile);
207 g_dhcpv6_client_set_duid(dhcp_client, duid, duid_len);
212 static void clear_callbacks(GDHCPClient *dhcp_client)
214 g_dhcp_client_register_event(dhcp_client,
215 G_DHCP_CLIENT_EVENT_SOLICITATION,
218 g_dhcp_client_register_event(dhcp_client,
219 G_DHCP_CLIENT_EVENT_ADVERTISE,
222 g_dhcp_client_register_event(dhcp_client,
223 G_DHCP_CLIENT_EVENT_REQUEST,
226 g_dhcp_client_register_event(dhcp_client,
227 G_DHCP_CLIENT_EVENT_INFORMATION_REQ,
231 static void info_req_cb(GDHCPClient *dhcp_client, gpointer user_data)
233 struct connman_dhcpv6 *dhcp = user_data;
234 struct connman_service *service;
236 GList *option, *list;
237 char **nameservers, **timeservers;
239 DBG("dhcpv6 information-request %p", dhcp);
241 service = __connman_service_lookup_from_network(dhcp->network);
242 if (service == NULL) {
243 connman_error("Can not lookup service");
247 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
248 entries = g_list_length(option);
250 nameservers = g_try_new0(char *, entries + 1);
251 if (nameservers != NULL) {
252 for (i = 0, list = option; list; list = list->next, i++)
253 nameservers[i] = g_strdup(list->data);
256 if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
257 if (dhcp->nameservers != NULL) {
258 for (i = 0; dhcp->nameservers[i] != NULL; i++)
259 __connman_service_nameserver_remove(service,
260 dhcp->nameservers[i],
262 g_strfreev(dhcp->nameservers);
265 dhcp->nameservers = nameservers;
267 for (i = 0; dhcp->nameservers[i] != NULL; i++)
268 __connman_service_nameserver_append(service,
269 dhcp->nameservers[i],
272 g_strfreev(nameservers);
275 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
276 entries = g_list_length(option);
278 timeservers = g_try_new0(char *, entries + 1);
279 if (timeservers != NULL) {
280 for (i = 0, list = option; list; list = list->next, i++)
281 timeservers[i] = g_strdup(list->data);
284 if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
285 if (dhcp->timeservers != NULL) {
286 for (i = 0; dhcp->timeservers[i] != NULL; i++)
287 __connman_service_timeserver_remove(service,
288 dhcp->timeservers[i]);
289 g_strfreev(dhcp->timeservers);
292 dhcp->timeservers = timeservers;
294 for (i = 0; dhcp->timeservers[i] != NULL; i++)
295 __connman_service_timeserver_append(service,
296 dhcp->timeservers[i]);
298 g_strfreev(timeservers);
301 if (dhcp->callback != NULL) {
302 uint16_t status = g_dhcpv6_client_get_status(dhcp_client);
303 dhcp->callback(dhcp->network, status == 0 ? TRUE : FALSE);
307 static int dhcpv6_info_request(struct connman_dhcpv6 *dhcp)
309 struct connman_service *service;
310 GDHCPClient *dhcp_client;
311 GDHCPClientError error;
314 DBG("dhcp %p", dhcp);
316 index = connman_network_get_index(dhcp->network);
318 dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
319 if (error != G_DHCP_CLIENT_ERROR_NONE)
322 if (getenv("CONNMAN_DHCPV6_DEBUG"))
323 g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
325 service = __connman_service_lookup_from_network(dhcp->network);
329 ret = set_duid(service, dhcp->network, dhcp_client, index);
333 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
334 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
335 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
337 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
338 G_DHCPV6_SNTP_SERVERS);
340 g_dhcp_client_register_event(dhcp_client,
341 G_DHCP_CLIENT_EVENT_INFORMATION_REQ, info_req_cb, dhcp);
343 dhcp->dhcp_client = dhcp_client;
345 return g_dhcp_client_start(dhcp_client, NULL);
348 static int check_ipv6_addr_prefix(GSList *prefixes, char *address)
350 struct in6_addr addr_prefix, addr;
354 for (list = prefixes; list; list = list->next) {
355 char *prefix = list->data;
356 const char *slash = g_strrstr(prefix, "/");
357 const unsigned char bits[] = { 0x00, 0xFE, 0xFC, 0xF8,
358 0xF0, 0xE0, 0xC0, 0x80 };
359 int left, count, i, plen;
364 prefix = g_strndup(prefix, slash - prefix);
365 len = strtol(slash + 1, NULL, 10);
372 inet_pton(AF_INET6, prefix, &addr_prefix);
373 inet_pton(AF_INET6, address, &addr);
375 memset(&addr_prefix.s6_addr[i], 0, count);
376 memset(&addr.s6_addr[i], 0, count);
379 addr_prefix.s6_addr[i - 1] &= bits[left];
380 addr.s6_addr[i - 1] &= bits[left];
385 if (memcmp(&addr_prefix, &addr, 16) == 0) {
394 static int set_addresses(GDHCPClient *dhcp_client,
395 struct connman_dhcpv6 *dhcp)
397 struct connman_service *service;
398 struct connman_ipconfig *ipconfig;
400 GList *option, *list;
401 char **nameservers, **timeservers;
402 const char *c_address;
403 char *address = NULL;
405 service = __connman_service_lookup_from_network(dhcp->network);
406 if (service == NULL) {
407 connman_error("Can not lookup service");
411 ipconfig = __connman_service_get_ip6config(service);
412 if (ipconfig == NULL) {
413 connman_error("Could not lookup ip6config");
417 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
418 entries = g_list_length(option);
420 nameservers = g_try_new0(char *, entries + 1);
421 if (nameservers != NULL) {
422 for (i = 0, list = option; list; list = list->next, i++)
423 nameservers[i] = g_strdup(list->data);
426 if (compare_string_arrays(nameservers, dhcp->nameservers) == FALSE) {
427 if (dhcp->nameservers != NULL) {
428 for (i = 0; dhcp->nameservers[i] != NULL; i++)
429 __connman_service_nameserver_remove(service,
430 dhcp->nameservers[i],
432 g_strfreev(dhcp->nameservers);
435 dhcp->nameservers = nameservers;
437 for (i = 0; dhcp->nameservers[i] != NULL; i++)
438 __connman_service_nameserver_append(service,
439 dhcp->nameservers[i],
442 g_strfreev(nameservers);
445 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
446 entries = g_list_length(option);
448 timeservers = g_try_new0(char *, entries + 1);
449 if (timeservers != NULL) {
450 for (i = 0, list = option; list; list = list->next, i++)
451 timeservers[i] = g_strdup(list->data);
454 if (compare_string_arrays(timeservers, dhcp->timeservers) == FALSE) {
455 if (dhcp->timeservers != NULL) {
456 for (i = 0; dhcp->timeservers[i] != NULL; i++)
457 __connman_service_timeserver_remove(service,
458 dhcp->timeservers[i]);
459 g_strfreev(dhcp->timeservers);
462 dhcp->timeservers = timeservers;
464 for (i = 0; dhcp->timeservers[i] != NULL; i++)
465 __connman_service_timeserver_append(service,
466 dhcp->timeservers[i]);
468 g_strfreev(timeservers);
471 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
473 address = g_strdup(option->data);
475 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
477 address = g_strdup(option->data);
480 c_address = __connman_ipconfig_get_local(ipconfig);
482 if (address != NULL &&
483 ((c_address != NULL &&
484 g_strcmp0(address, c_address) != 0) ||
485 (c_address == NULL))) {
488 /* Is this prefix part of the subnet we are suppose to use? */
489 prefix_len = check_ipv6_addr_prefix(dhcp->prefixes, address);
491 __connman_ipconfig_set_local(ipconfig, address);
492 __connman_ipconfig_set_prefixlen(ipconfig, prefix_len);
494 DBG("new address %s/%d", address, prefix_len);
500 static void re_cb(GDHCPClient *dhcp_client, gpointer user_data)
502 struct connman_dhcpv6 *dhcp = user_data;
506 ret = set_addresses(dhcp_client, dhcp);
508 status = g_dhcpv6_client_get_status(dhcp_client);
510 DBG("dhcpv6 cb msg %p ret %d status %d", dhcp, ret, status);
513 if (dhcp->callback != NULL)
514 dhcp->callback(dhcp->network, FALSE);
518 if (status == G_DHCPV6_ERROR_BINDING) {
519 /* RFC 3315, 18.1.8 */
520 dhcpv6_request(dhcp, FALSE);
522 if (dhcp->callback != NULL)
523 dhcp->callback(dhcp->network,
524 status == 0 ? TRUE : FALSE);
528 static void request_cb(GDHCPClient *dhcp_client, gpointer user_data)
532 re_cb(dhcp_client, user_data);
535 static int dhcpv6_request(struct connman_dhcpv6 *dhcp,
536 gboolean add_addresses)
538 GDHCPClient *dhcp_client;
541 DBG("dhcp %p add %d", dhcp, add_addresses);
543 dhcp_client = dhcp->dhcp_client;
545 g_dhcp_client_clear_requests(dhcp_client);
547 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
548 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
549 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
550 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
552 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
553 G_DHCPV6_SNTP_SERVERS);
555 g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2);
556 g_dhcpv6_client_set_ia(dhcp_client,
557 connman_network_get_index(dhcp->network),
558 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
559 &T1, &T2, add_addresses);
561 clear_callbacks(dhcp_client);
563 g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
566 dhcp->dhcp_client = dhcp_client;
568 return g_dhcp_client_start(dhcp_client, NULL);
571 static gboolean timeout_request(gpointer user_data)
573 struct connman_dhcpv6 *dhcp = user_data;
575 if (dhcp->request_count >= REQ_MAX_RC) {
576 DBG("max request retry attempts %d", dhcp->request_count);
577 dhcp->request_count = 0;
578 if (dhcp->callback != NULL)
579 dhcp->callback(dhcp->network, FALSE);
583 dhcp->request_count++;
585 dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
586 DBG("request RT timeout %d msec", dhcp->RT);
587 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
589 g_dhcp_client_start(dhcp->dhcp_client, NULL);
594 static int dhcpv6_release(struct connman_dhcpv6 *dhcp)
596 DBG("dhcp %p", dhcp);
598 if (dhcp->timeout > 0) {
599 g_source_remove(dhcp->timeout);
605 if (dhcp->dhcp_client == NULL)
608 g_dhcp_client_stop(dhcp->dhcp_client);
609 g_dhcp_client_unref(dhcp->dhcp_client);
611 dhcp->dhcp_client = NULL;
616 static void remove_network(gpointer user_data)
618 struct connman_dhcpv6 *dhcp = user_data;
620 DBG("dhcp %p", dhcp);
622 dhcpv6_release(dhcp);
627 static gboolean timeout_info_req(gpointer user_data)
629 struct connman_dhcpv6 *dhcp = user_data;
631 dhcp->RT = calc_delay(dhcp->RT, INF_MAX_RT);
633 DBG("info RT timeout %d msec", dhcp->RT);
635 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
637 g_dhcp_client_start(dhcp->dhcp_client, NULL);
642 static gboolean start_info_req(gpointer user_data)
644 struct connman_dhcpv6 *dhcp = user_data;
646 /* Set the retransmission timeout, RFC 3315 chapter 14 */
647 dhcp->RT = INF_TIMEOUT * (1 + get_random());
649 DBG("info initial RT timeout %d msec", dhcp->RT);
651 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
653 dhcpv6_info_request(dhcp);
658 int __connman_dhcpv6_start_info(struct connman_network *network,
661 struct connman_dhcpv6 *dhcp;
666 dhcp = g_try_new0(struct connman_dhcpv6, 1);
670 dhcp->network = network;
671 dhcp->callback = callback;
673 connman_network_ref(network);
675 g_hash_table_replace(network_table, network, dhcp);
677 /* Initial timeout, RFC 3315, 18.1.5 */
678 delay = rand() % 1000;
680 dhcp->timeout = g_timeout_add(delay, start_info_req, dhcp);
685 static void advertise_cb(GDHCPClient *dhcp_client, gpointer user_data)
687 struct connman_dhcpv6 *dhcp = user_data;
689 DBG("dhcpv6 advertise msg %p", dhcp);
691 if (dhcp->timeout > 0) {
692 g_source_remove(dhcp->timeout);
696 if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
697 if (dhcp->callback != NULL)
698 dhcp->callback(dhcp->network, FALSE);
702 dhcp->RT = REQ_TIMEOUT * (1 + get_random());
703 DBG("request initial RT timeout %d msec", dhcp->RT);
704 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
706 dhcp->request_count = 1;
708 dhcpv6_request(dhcp, TRUE);
711 static void solicitation_cb(GDHCPClient *dhcp_client, gpointer user_data)
713 /* We get here if server supports rapid commit */
714 struct connman_dhcpv6 *dhcp = user_data;
716 DBG("dhcpv6 solicitation msg %p", dhcp);
718 if (dhcp->timeout > 0) {
719 g_source_remove(dhcp->timeout);
723 set_addresses(dhcp_client, dhcp);
726 static gboolean timeout_solicitation(gpointer user_data)
728 struct connman_dhcpv6 *dhcp = user_data;
730 dhcp->RT = calc_delay(dhcp->RT, SOL_MAX_RT);
732 DBG("solicit RT timeout %d msec", dhcp->RT);
734 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
736 g_dhcp_client_start(dhcp->dhcp_client, NULL);
741 static int dhcpv6_solicitation(struct connman_dhcpv6 *dhcp)
743 struct connman_service *service;
744 struct connman_ipconfig *ipconfig_ipv6;
745 GDHCPClient *dhcp_client;
746 GDHCPClientError error;
749 DBG("dhcp %p", dhcp);
751 index = connman_network_get_index(dhcp->network);
753 dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
754 if (error != G_DHCP_CLIENT_ERROR_NONE)
757 if (getenv("CONNMAN_DHCPV6_DEBUG"))
758 g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
760 service = __connman_service_lookup_from_network(dhcp->network);
764 ret = set_duid(service, dhcp->network, dhcp_client, index);
768 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
769 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_RAPID_COMMIT);
770 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
771 g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
773 g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
774 G_DHCPV6_SNTP_SERVERS);
776 ipconfig_ipv6 = __connman_service_get_ip6config(service);
777 dhcp->use_ta = __connman_ipconfig_ipv6_privacy_enabled(ipconfig_ipv6);
779 g_dhcpv6_client_set_ia(dhcp_client, index,
780 dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
783 clear_callbacks(dhcp_client);
785 g_dhcp_client_register_event(dhcp_client,
786 G_DHCP_CLIENT_EVENT_SOLICITATION,
787 solicitation_cb, dhcp);
789 g_dhcp_client_register_event(dhcp_client,
790 G_DHCP_CLIENT_EVENT_ADVERTISE,
793 dhcp->dhcp_client = dhcp_client;
795 return g_dhcp_client_start(dhcp_client, NULL);
798 static gboolean start_solicitation(gpointer user_data)
800 struct connman_dhcpv6 *dhcp = user_data;
802 /* Set the retransmission timeout, RFC 3315 chapter 14 */
803 dhcp->RT = SOL_TIMEOUT * (1 + get_random());
805 DBG("solicit initial RT timeout %d msec", dhcp->RT);
807 dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
809 dhcpv6_solicitation(dhcp);
814 int __connman_dhcpv6_start(struct connman_network *network,
815 GSList *prefixes, dhcp_cb callback)
817 struct connman_dhcpv6 *dhcp;
822 dhcp = g_try_new0(struct connman_dhcpv6, 1);
826 dhcp->network = network;
827 dhcp->callback = callback;
828 dhcp->prefixes = prefixes;
830 connman_network_ref(network);
832 g_hash_table_replace(network_table, network, dhcp);
834 /* Initial timeout, RFC 3315, 17.1.2 */
835 delay = rand() % 1000;
837 dhcp->timeout = g_timeout_add(delay, start_solicitation, dhcp);
842 void __connman_dhcpv6_stop(struct connman_network *network)
846 if (network_table == NULL)
849 if (g_hash_table_remove(network_table, network) == TRUE)
850 connman_network_unref(network);
853 int __connman_dhcpv6_init(void)
859 network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
860 NULL, remove_network);
865 void __connman_dhcpv6_cleanup(void)
869 g_hash_table_destroy(network_table);
870 network_table = NULL;