src/dhcpv6.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2011  Intel Corporation. All rights reserved.
   6  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25 #include <stdio.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 #include <connman/ipconfig.h>
  31 #include <connman/storage.h>
  32
  33 #include <gdhcp/gdhcp.h>
  34
  35 #include <glib.h>
  36
  37 #include "connman.h"
  38
  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)
  48 #define REQ_MAX_RC      10
  49
  50
  51 struct connman_dhcpv6 {
  52         struct connman_network *network;
  53         dhcp_cb callback;
  54
  55         char **nameservers;
  56         char **timeservers;
  57
  58         GDHCPClient *dhcp_client;
  59
  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 */
  65 };
  66
  67 static GHashTable *network_table;
  68
  69 static int dhcpv6_request(struct connman_dhcpv6 *dhcp, gboolean add_addresses);
  70
  71 static inline float get_random()
  72 {
  73         return (rand() % 200 - 100) / 1000.0;
  74 }
  75
  76 /* Calculate a random delay, RFC 3315 chapter 14 */
  77 /* RT and MRT are milliseconds */
  78 static guint calc_delay(guint RT, guint MRT)
  79 {
  80         float delay = get_random();
  81         float rt = RT * (2 + delay);
  82
  83         if (rt > MRT)
  84                 rt = MRT * (1 + delay);
  85
  86         if (rt < 0)
  87                 rt = MRT;
  88
  89         return (guint)rt;
  90 }
  91
  92 static void free_prefix(gpointer data, gpointer user_data)
  93 {
  94         g_free(data);
  95 }
  96
  97 static void dhcpv6_free(struct connman_dhcpv6 *dhcp)
  98 {
  99         g_strfreev(dhcp->nameservers);
 100         g_strfreev(dhcp->timeservers);
 101
 102         dhcp->nameservers = NULL;
 103         dhcp->timeservers = NULL;
 104
 105         g_slist_foreach(dhcp->prefixes, free_prefix, NULL);
 106         g_slist_free(dhcp->prefixes);
 107 }
 108
 109 static gboolean compare_string_arrays(char **array_a, char **array_b)
 110 {
 111         int i;
 112
 113         if (array_a == NULL || array_b == NULL)
 114                 return FALSE;
 115
 116         if (g_strv_length(array_a) != g_strv_length(array_b))
 117                 return FALSE;
 118
 119         for (i = 0; array_a[i] != NULL && array_b[i] != NULL; i++)
 120                 if (g_strcmp0(array_a[i], array_b[i]) != 0)
 121                         return FALSE;
 122
 123         return TRUE;
 124 }
 125
 126 static void dhcpv6_debug(const char *str, void *data)
 127 {
 128         connman_info("%s: %s\n", (const char *) data, str);
 129 }
 130
 131 static gchar *convert_to_hex(unsigned char *buf, int len)
 132 {
 133         gchar *ret = g_try_malloc(len * 2 + 1);
 134         int i;
 135
 136         for (i = 0; ret != NULL && i < len; i++)
 137                 g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
 138
 139         return ret;
 140 }
 141
 142 /*
 143  * DUID should not change over time so save it to file.
 144  * See RFC 3315 chapter 9 for details.
 145  */
 146 static int set_duid(struct connman_service *service,
 147                         struct connman_network *network,
 148                         GDHCPClient *dhcp_client, int index)
 149 {
 150         GKeyFile *keyfile;
 151         const char *ident;
 152         char *hex_duid;
 153         unsigned char *duid;
 154         int duid_len;
 155
 156         ident = __connman_service_get_ident(service);
 157
 158         keyfile = connman_storage_load_service(ident);
 159         if (keyfile == NULL)
 160                 return -EINVAL;
 161
 162         hex_duid = g_key_file_get_string(keyfile, ident, "IPv6.DHCP.DUID",
 163                                         NULL);
 164         if (hex_duid != NULL) {
 165                 unsigned int i, j = 0, hex;
 166                 size_t hex_duid_len = strlen(hex_duid);
 167
 168                 duid = g_try_malloc0(hex_duid_len / 2);
 169                 if (duid == NULL) {
 170                         g_key_file_free(keyfile);
 171                         g_free(hex_duid);
 172                         return -ENOMEM;
 173                 }
 174
 175                 for (i = 0; i < hex_duid_len; i += 2) {
 176                         sscanf(hex_duid + i, "%02x", &hex);
 177                         duid[j++] = hex;
 178                 }
 179
 180                 duid_len = hex_duid_len / 2;
 181         } else {
 182                 int ret;
 183                 int type = __connman_ipconfig_get_type_from_index(index);
 184
 185                 ret = g_dhcpv6_create_duid(G_DHCPV6_DUID_LLT, index, type,
 186                                         &duid, &duid_len);
 187                 if (ret < 0) {
 188                         g_key_file_free(keyfile);
 189                         return ret;
 190                 }
 191
 192                 hex_duid = convert_to_hex(duid, duid_len);
 193                 if (hex_duid == NULL) {
 194                         g_key_file_free(keyfile);
 195                         return -ENOMEM;
 196                 }
 197
 198                 g_key_file_set_string(keyfile, ident, "IPv6.DHCP.DUID",
 199                                 hex_duid);
 200
 201                 __connman_storage_save_service(keyfile, ident);
 202         }
 203         g_free(hex_duid);
 204
 205         g_key_file_free(keyfile);
 206
 207         g_dhcpv6_client_set_duid(dhcp_client, duid, duid_len);
 208
 209         return 0;
 210 }
 211
 212 static void clear_callbacks(GDHCPClient *dhcp_client)
 213 {
 214         g_dhcp_client_register_event(dhcp_client,
 215                                 G_DHCP_CLIENT_EVENT_SOLICITATION,
 216                                 NULL, NULL);
 217
 218         g_dhcp_client_register_event(dhcp_client,
 219                                 G_DHCP_CLIENT_EVENT_ADVERTISE,
 220                                 NULL, NULL);
 221
 222         g_dhcp_client_register_event(dhcp_client,
 223                                 G_DHCP_CLIENT_EVENT_REQUEST,
 224                                 NULL, NULL);
 225
 226         g_dhcp_client_register_event(dhcp_client,
 227                                 G_DHCP_CLIENT_EVENT_INFORMATION_REQ,
 228                                 NULL, NULL);
 229 }
 230
 231 static void info_req_cb(GDHCPClient *dhcp_client, gpointer user_data)
 232 {
 233         struct connman_dhcpv6 *dhcp = user_data;
 234         struct connman_service *service;
 235         int entries, i;
 236         GList *option, *list;
 237         char **nameservers, **timeservers;
 238
 239         DBG("dhcpv6 information-request %p", dhcp);
 240
 241         service = __connman_service_lookup_from_network(dhcp->network);
 242         if (service == NULL) {
 243                 connman_error("Can not lookup service");
 244                 return;
 245         }
 246
 247         option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
 248         entries = g_list_length(option);
 249
 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);
 254         }
 255
 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],
 261                                                         FALSE);
 262                         g_strfreev(dhcp->nameservers);
 263                 }
 264
 265                 dhcp->nameservers = nameservers;
 266
 267                 for (i = 0; dhcp->nameservers[i] != NULL; i++)
 268                         __connman_service_nameserver_append(service,
 269                                                 dhcp->nameservers[i],
 270                                                 FALSE);
 271         } else
 272                 g_strfreev(nameservers);
 273
 274
 275         option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
 276         entries = g_list_length(option);
 277
 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);
 282         }
 283
 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);
 290                 }
 291
 292                 dhcp->timeservers = timeservers;
 293
 294                 for (i = 0; dhcp->timeservers[i] != NULL; i++)
 295                         __connman_service_timeserver_append(service,
 296                                                         dhcp->timeservers[i]);
 297         } else
 298                 g_strfreev(timeservers);
 299
 300
 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);
 304         }
 305 }
 306
 307 static int dhcpv6_info_request(struct connman_dhcpv6 *dhcp)
 308 {
 309         struct connman_service *service;
 310         GDHCPClient *dhcp_client;
 311         GDHCPClientError error;
 312         int index, ret;
 313
 314         DBG("dhcp %p", dhcp);
 315
 316         index = connman_network_get_index(dhcp->network);
 317
 318         dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
 319         if (error != G_DHCP_CLIENT_ERROR_NONE)
 320                 return -EINVAL;
 321
 322         if (getenv("CONNMAN_DHCPV6_DEBUG"))
 323                 g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
 324
 325         service = __connman_service_lookup_from_network(dhcp->network);
 326         if (service == NULL)
 327                 return -EINVAL;
 328
 329         ret = set_duid(service, dhcp->network, dhcp_client, index);
 330         if (ret < 0)
 331                 return ret;
 332
 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);
 336
 337         g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
 338                                 G_DHCPV6_SNTP_SERVERS);
 339
 340         g_dhcp_client_register_event(dhcp_client,
 341                         G_DHCP_CLIENT_EVENT_INFORMATION_REQ, info_req_cb, dhcp);
 342
 343         dhcp->dhcp_client = dhcp_client;
 344
 345         return g_dhcp_client_start(dhcp_client, NULL);
 346 }
 347
 348 static int check_ipv6_addr_prefix(GSList *prefixes, char *address)
 349 {
 350         struct in6_addr addr_prefix, addr;
 351         GSList *list;
 352         int ret = 128, len;
 353
 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;
 360
 361                 if (slash == NULL)
 362                         continue;
 363
 364                 prefix = g_strndup(prefix, slash - prefix);
 365                 len = strtol(slash + 1, NULL, 10);
 366                 plen = 128 - len;
 367
 368                 count = plen / 8;
 369                 left = plen % 8;
 370                 i = 16 - count;
 371
 372                 inet_pton(AF_INET6, prefix, &addr_prefix);
 373                 inet_pton(AF_INET6, address, &addr);
 374
 375                 memset(&addr_prefix.s6_addr[i], 0, count);
 376                 memset(&addr.s6_addr[i], 0, count);
 377
 378                 if (left) {
 379                         addr_prefix.s6_addr[i - 1] &= bits[left];
 380                         addr.s6_addr[i - 1] &= bits[left];
 381                 }
 382
 383                 g_free(prefix);
 384
 385                 if (memcmp(&addr_prefix, &addr, 16) == 0) {
 386                         ret = len;
 387                         break;
 388                 }
 389         }
 390
 391         return ret;
 392 }
 393
 394 static int set_addresses(GDHCPClient *dhcp_client,
 395                                                 struct connman_dhcpv6 *dhcp)
 396 {
 397         struct connman_service *service;
 398         struct connman_ipconfig *ipconfig;
 399         int entries, i;
 400         GList *option, *list;
 401         char **nameservers, **timeservers;
 402         const char *c_address;
 403         char *address = NULL;
 404
 405         service = __connman_service_lookup_from_network(dhcp->network);
 406         if (service == NULL) {
 407                 connman_error("Can not lookup service");
 408                 return -EINVAL;
 409         }
 410
 411         ipconfig = __connman_service_get_ip6config(service);
 412         if (ipconfig == NULL) {
 413                 connman_error("Could not lookup ip6config");
 414                 return -EINVAL;
 415         }
 416
 417         option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
 418         entries = g_list_length(option);
 419
 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);
 424         }
 425
 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],
 431                                                         FALSE);
 432                         g_strfreev(dhcp->nameservers);
 433                 }
 434
 435                 dhcp->nameservers = nameservers;
 436
 437                 for (i = 0; dhcp->nameservers[i] != NULL; i++)
 438                         __connman_service_nameserver_append(service,
 439                                                         dhcp->nameservers[i],
 440                                                         FALSE);
 441         } else
 442                 g_strfreev(nameservers);
 443
 444
 445         option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
 446         entries = g_list_length(option);
 447
 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);
 452         }
 453
 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);
 460                 }
 461
 462                 dhcp->timeservers = timeservers;
 463
 464                 for (i = 0; dhcp->timeservers[i] != NULL; i++)
 465                         __connman_service_timeserver_append(service,
 466                                                         dhcp->timeservers[i]);
 467         } else
 468                 g_strfreev(timeservers);
 469
 470
 471         option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
 472         if (option != NULL)
 473                 address = g_strdup(option->data);
 474         else {
 475                 option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
 476                 if (option != NULL)
 477                         address = g_strdup(option->data);
 478         }
 479
 480         c_address = __connman_ipconfig_get_local(ipconfig);
 481
 482         if (address != NULL &&
 483                         ((c_address != NULL &&
 484                                 g_strcmp0(address, c_address) != 0) ||
 485                         (c_address == NULL))) {
 486                 int prefix_len;
 487
 488                 /* Is this prefix part of the subnet we are suppose to use? */
 489                 prefix_len = check_ipv6_addr_prefix(dhcp->prefixes, address);
 490
 491                 __connman_ipconfig_set_local(ipconfig, address);
 492                 __connman_ipconfig_set_prefixlen(ipconfig, prefix_len);
 493
 494                 DBG("new address %s/%d", address, prefix_len);
 495         }
 496
 497         return 0;
 498 }
 499
 500 static void re_cb(GDHCPClient *dhcp_client, gpointer user_data)
 501 {
 502         struct connman_dhcpv6 *dhcp = user_data;
 503         uint16_t status;
 504         int ret;
 505
 506         ret = set_addresses(dhcp_client, dhcp);
 507
 508         status = g_dhcpv6_client_get_status(dhcp_client);
 509
 510         DBG("dhcpv6 cb msg %p ret %d status %d", dhcp, ret, status);
 511
 512         if (ret < 0) {
 513                 if (dhcp->callback != NULL)
 514                         dhcp->callback(dhcp->network, FALSE);
 515                 return;
 516         }
 517
 518         if (status  == G_DHCPV6_ERROR_BINDING) {
 519                 /* RFC 3315, 18.1.8 */
 520                 dhcpv6_request(dhcp, FALSE);
 521         } else {
 522                 if (dhcp->callback != NULL)
 523                         dhcp->callback(dhcp->network,
 524                                                 status == 0 ? TRUE : FALSE);
 525         }
 526 }
 527
 528 static void request_cb(GDHCPClient *dhcp_client, gpointer user_data)
 529 {
 530         DBG("");
 531
 532         re_cb(dhcp_client, user_data);
 533 }
 534
 535 static int dhcpv6_request(struct connman_dhcpv6 *dhcp,
 536                         gboolean add_addresses)
 537 {
 538         GDHCPClient *dhcp_client;
 539         uint32_t T1, T2;
 540
 541         DBG("dhcp %p add %d", dhcp, add_addresses);
 542
 543         dhcp_client = dhcp->dhcp_client;
 544
 545         g_dhcp_client_clear_requests(dhcp_client);
 546
 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);
 551
 552         g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
 553                                 G_DHCPV6_SNTP_SERVERS);
 554
 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);
 560
 561         clear_callbacks(dhcp_client);
 562
 563         g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
 564                                         request_cb, dhcp);
 565
 566         dhcp->dhcp_client = dhcp_client;
 567
 568         return g_dhcp_client_start(dhcp_client, NULL);
 569 }
 570
 571 static gboolean timeout_request(gpointer user_data)
 572 {
 573         struct connman_dhcpv6 *dhcp = user_data;
 574
 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);
 580                 return FALSE;
 581         }
 582
 583         dhcp->request_count++;
 584
 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);
 588
 589         g_dhcp_client_start(dhcp->dhcp_client, NULL);
 590
 591         return FALSE;
 592 }
 593
 594 static int dhcpv6_release(struct connman_dhcpv6 *dhcp)
 595 {
 596         DBG("dhcp %p", dhcp);
 597
 598         if (dhcp->timeout > 0) {
 599                 g_source_remove(dhcp->timeout);
 600                 dhcp->timeout = 0;
 601         }
 602
 603         dhcpv6_free(dhcp);
 604
 605         if (dhcp->dhcp_client == NULL)
 606                 return 0;
 607
 608         g_dhcp_client_stop(dhcp->dhcp_client);
 609         g_dhcp_client_unref(dhcp->dhcp_client);
 610
 611         dhcp->dhcp_client = NULL;
 612
 613         return 0;
 614 }
 615
 616 static void remove_network(gpointer user_data)
 617 {
 618         struct connman_dhcpv6 *dhcp = user_data;
 619
 620         DBG("dhcp %p", dhcp);
 621
 622         dhcpv6_release(dhcp);
 623
 624         g_free(dhcp);
 625 }
 626
 627 static gboolean timeout_info_req(gpointer user_data)
 628 {
 629         struct connman_dhcpv6 *dhcp = user_data;
 630
 631         dhcp->RT = calc_delay(dhcp->RT, INF_MAX_RT);
 632
 633         DBG("info RT timeout %d msec", dhcp->RT);
 634
 635         dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
 636
 637         g_dhcp_client_start(dhcp->dhcp_client, NULL);
 638
 639         return FALSE;
 640 }
 641
 642 static gboolean start_info_req(gpointer user_data)
 643 {
 644         struct connman_dhcpv6 *dhcp = user_data;
 645
 646         /* Set the retransmission timeout, RFC 3315 chapter 14 */
 647         dhcp->RT = INF_TIMEOUT * (1 + get_random());
 648
 649         DBG("info initial RT timeout %d msec", dhcp->RT);
 650
 651         dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
 652
 653         dhcpv6_info_request(dhcp);
 654
 655         return FALSE;
 656 }
 657
 658 int __connman_dhcpv6_start_info(struct connman_network *network,
 659                                 dhcp_cb callback)
 660 {
 661         struct connman_dhcpv6 *dhcp;
 662         int delay;
 663
 664         DBG("");
 665
 666         dhcp = g_try_new0(struct connman_dhcpv6, 1);
 667         if (dhcp == NULL)
 668                 return -ENOMEM;
 669
 670         dhcp->network = network;
 671         dhcp->callback = callback;
 672
 673         connman_network_ref(network);
 674
 675         g_hash_table_replace(network_table, network, dhcp);
 676
 677         /* Initial timeout, RFC 3315, 18.1.5 */
 678         delay = rand() % 1000;
 679
 680         dhcp->timeout = g_timeout_add(delay, start_info_req, dhcp);
 681
 682         return 0;
 683 }
 684
 685 static void advertise_cb(GDHCPClient *dhcp_client, gpointer user_data)
 686 {
 687         struct connman_dhcpv6 *dhcp = user_data;
 688
 689         DBG("dhcpv6 advertise msg %p", dhcp);
 690
 691         if (dhcp->timeout > 0) {
 692                 g_source_remove(dhcp->timeout);
 693                 dhcp->timeout = 0;
 694         }
 695
 696         if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
 697                 if (dhcp->callback != NULL)
 698                         dhcp->callback(dhcp->network, FALSE);
 699                 return;
 700         }
 701
 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);
 705
 706         dhcp->request_count = 1;
 707
 708         dhcpv6_request(dhcp, TRUE);
 709 }
 710
 711 static void solicitation_cb(GDHCPClient *dhcp_client, gpointer user_data)
 712 {
 713         /* We get here if server supports rapid commit */
 714         struct connman_dhcpv6 *dhcp = user_data;
 715
 716         DBG("dhcpv6 solicitation msg %p", dhcp);
 717
 718         if (dhcp->timeout > 0) {
 719                 g_source_remove(dhcp->timeout);
 720                 dhcp->timeout = 0;
 721         }
 722
 723         set_addresses(dhcp_client, dhcp);
 724 }
 725
 726 static gboolean timeout_solicitation(gpointer user_data)
 727 {
 728         struct connman_dhcpv6 *dhcp = user_data;
 729
 730         dhcp->RT = calc_delay(dhcp->RT, SOL_MAX_RT);
 731
 732         DBG("solicit RT timeout %d msec", dhcp->RT);
 733
 734         dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
 735
 736         g_dhcp_client_start(dhcp->dhcp_client, NULL);
 737
 738         return FALSE;
 739 }
 740
 741 static int dhcpv6_solicitation(struct connman_dhcpv6 *dhcp)
 742 {
 743         struct connman_service *service;
 744         struct connman_ipconfig *ipconfig_ipv6;
 745         GDHCPClient *dhcp_client;
 746         GDHCPClientError error;
 747         int index, ret;
 748
 749         DBG("dhcp %p", dhcp);
 750
 751         index = connman_network_get_index(dhcp->network);
 752
 753         dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
 754         if (error != G_DHCP_CLIENT_ERROR_NONE)
 755                 return -EINVAL;
 756
 757         if (getenv("CONNMAN_DHCPV6_DEBUG"))
 758                 g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
 759
 760         service = __connman_service_lookup_from_network(dhcp->network);
 761         if (service == NULL)
 762                 return -EINVAL;
 763
 764         ret = set_duid(service, dhcp->network, dhcp_client, index);
 765         if (ret < 0)
 766                 return ret;
 767
 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);
 772
 773         g_dhcpv6_client_set_oro(dhcp_client, 2, G_DHCPV6_DNS_SERVERS,
 774                                 G_DHCPV6_SNTP_SERVERS);
 775
 776         ipconfig_ipv6 = __connman_service_get_ip6config(service);
 777         dhcp->use_ta = __connman_ipconfig_ipv6_privacy_enabled(ipconfig_ipv6);
 778
 779         g_dhcpv6_client_set_ia(dhcp_client, index,
 780                         dhcp->use_ta == TRUE ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
 781                         NULL, NULL, FALSE);
 782
 783         clear_callbacks(dhcp_client);
 784
 785         g_dhcp_client_register_event(dhcp_client,
 786                                 G_DHCP_CLIENT_EVENT_SOLICITATION,
 787                                 solicitation_cb, dhcp);
 788
 789         g_dhcp_client_register_event(dhcp_client,
 790                                 G_DHCP_CLIENT_EVENT_ADVERTISE,
 791                                 advertise_cb, dhcp);
 792
 793         dhcp->dhcp_client = dhcp_client;
 794
 795         return g_dhcp_client_start(dhcp_client, NULL);
 796 }
 797
 798 static gboolean start_solicitation(gpointer user_data)
 799 {
 800         struct connman_dhcpv6 *dhcp = user_data;
 801
 802         /* Set the retransmission timeout, RFC 3315 chapter 14 */
 803         dhcp->RT = SOL_TIMEOUT * (1 + get_random());
 804
 805         DBG("solicit initial RT timeout %d msec", dhcp->RT);
 806
 807         dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
 808
 809         dhcpv6_solicitation(dhcp);
 810
 811         return FALSE;
 812 }
 813
 814 int __connman_dhcpv6_start(struct connman_network *network,
 815                                 GSList *prefixes, dhcp_cb callback)
 816 {
 817         struct connman_dhcpv6 *dhcp;
 818         int delay;
 819
 820         DBG("");
 821
 822         dhcp = g_try_new0(struct connman_dhcpv6, 1);
 823         if (dhcp == NULL)
 824                 return -ENOMEM;
 825
 826         dhcp->network = network;
 827         dhcp->callback = callback;
 828         dhcp->prefixes = prefixes;
 829
 830         connman_network_ref(network);
 831
 832         g_hash_table_replace(network_table, network, dhcp);
 833
 834         /* Initial timeout, RFC 3315, 17.1.2 */
 835         delay = rand() % 1000;
 836
 837         dhcp->timeout = g_timeout_add(delay, start_solicitation, dhcp);
 838
 839         return 0;
 840 }
 841
 842 void __connman_dhcpv6_stop(struct connman_network *network)
 843 {
 844         DBG("");
 845
 846         if (network_table == NULL)
 847                 return;
 848
 849         if (g_hash_table_remove(network_table, network) == TRUE)
 850                 connman_network_unref(network);
 851 }
 852
 853 int __connman_dhcpv6_init(void)
 854 {
 855         DBG("");
 856
 857         srand(time(0));
 858
 859         network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
 860                                                         NULL, remove_network);
 861
 862         return 0;
 863 }
 864
 865 void __connman_dhcpv6_cleanup(void)
 866 {
 867         DBG("");
 868
 869         g_hash_table_destroy(network_table);
 870         network_table = NULL;
 871 }