src/network.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2012  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
  26 #include <errno.h>
  27 #include <string.h>
  28
  29 #include "connman.h"
  30
  31 /*
  32  * How many times to send RS with the purpose of
  33  * refreshing RDNSS entries before they actually expire.
  34  * With a value of 1, one RS will be sent, with no retries.
  35  */
  36 #define RS_REFRESH_COUNT        1
  37
  38 /*
  39  * Value in seconds to wait for RA after RS was sent.
  40  * After this time elapsed, we can send another RS.
  41  */
  42 #define RS_REFRESH_TIMEOUT      3
  43
  44 static GSList *network_list = NULL;
  45 static GSList *driver_list = NULL;
  46
  47 struct connman_network {
  48         int refcount;
  49         enum connman_network_type type;
  50         connman_bool_t available;
  51         connman_bool_t connected;
  52         connman_bool_t roaming;
  53         connman_uint8_t strength;
  54         connman_uint16_t frequency;
  55         char *identifier;
  56         char *name;
  57         char *node;
  58         char *group;
  59         char *path;
  60         int index;
  61         int router_solicit_count;
  62         int router_solicit_refresh_count;
  63
  64         struct connman_network_driver *driver;
  65         void *driver_data;
  66
  67         connman_bool_t connecting;
  68         connman_bool_t associating;
  69
  70         struct connman_device *device;
  71
  72         struct {
  73                 void *ssid;
  74                 int ssid_len;
  75                 char *mode;
  76                 unsigned short channel;
  77                 char *security;
  78                 char *passphrase;
  79                 char *agent_passphrase;
  80                 char *eap;
  81                 char *identity;
  82                 char *agent_identity;
  83                 char *ca_cert_path;
  84                 char *client_cert_path;
  85                 char *private_key_path;
  86                 char *private_key_passphrase;
  87                 char *phase2_auth;
  88                 connman_bool_t wps;
  89                 connman_bool_t use_wps;
  90                 char *pin_wps;
  91         } wifi;
  92
  93 };
  94
  95 static const char *type2string(enum connman_network_type type)
  96 {
  97         switch (type) {
  98         case CONNMAN_NETWORK_TYPE_UNKNOWN:
  99         case CONNMAN_NETWORK_TYPE_VENDOR:
 100                 break;
 101         case CONNMAN_NETWORK_TYPE_ETHERNET:
 102                 return "ethernet";
 103         case CONNMAN_NETWORK_TYPE_WIFI:
 104                 return "wifi";
 105         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 106         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 107                 return "bluetooth";
 108         case CONNMAN_NETWORK_TYPE_CELLULAR:
 109                 return "cellular";
 110         }
 111
 112         return NULL;
 113 }
 114
 115 static gboolean match_driver(struct connman_network *network,
 116                                         struct connman_network_driver *driver)
 117 {
 118         if (network->type == driver->type ||
 119                         driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
 120                 return TRUE;
 121
 122         return FALSE;
 123 }
 124
 125 static int network_probe(struct connman_network *network)
 126 {
 127         GSList *list;
 128         struct connman_network_driver *driver = NULL;
 129
 130         DBG("network %p name %s", network, network->name);
 131
 132         if (network->driver != NULL)
 133                 return -EALREADY;
 134
 135         for (list = driver_list; list; list = list->next) {
 136                 driver = list->data;
 137
 138                 if (match_driver(network, driver) == FALSE)
 139                         continue;
 140
 141                 DBG("driver %p name %s", driver, driver->name);
 142
 143                 if (driver->probe(network) == 0)
 144                         break;
 145
 146                 driver = NULL;
 147         }
 148
 149         if (driver == NULL)
 150                 return -ENODEV;
 151
 152         if (network->group == NULL)
 153                 return -EINVAL;
 154
 155         switch (network->type) {
 156         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 157         case CONNMAN_NETWORK_TYPE_VENDOR:
 158                 return 0;
 159         case CONNMAN_NETWORK_TYPE_ETHERNET:
 160         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 161         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 162         case CONNMAN_NETWORK_TYPE_CELLULAR:
 163         case CONNMAN_NETWORK_TYPE_WIFI:
 164                 network->driver = driver;
 165                 if (__connman_service_create_from_network(network) == NULL) {
 166                         network->driver = NULL;
 167                         return -EINVAL;
 168                 }
 169         }
 170
 171         return 0;
 172 }
 173
 174 static void network_remove(struct connman_network *network)
 175 {
 176         DBG("network %p name %s", network, network->name);
 177
 178         if (network->driver == NULL)
 179                 return;
 180
 181         connman_network_set_connected(network, FALSE);
 182
 183         switch (network->type) {
 184         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 185         case CONNMAN_NETWORK_TYPE_VENDOR:
 186                 break;
 187         case CONNMAN_NETWORK_TYPE_ETHERNET:
 188         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 189         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 190         case CONNMAN_NETWORK_TYPE_CELLULAR:
 191         case CONNMAN_NETWORK_TYPE_WIFI:
 192                 if (network->group != NULL) {
 193                         __connman_service_remove_from_network(network);
 194
 195                         g_free(network->group);
 196                         network->group = NULL;
 197                 }
 198                 break;
 199         }
 200
 201         if (network->driver->remove)
 202                 network->driver->remove(network);
 203
 204         network->driver = NULL;
 205 }
 206
 207 static void network_change(struct connman_network *network)
 208 {
 209         DBG("network %p name %s", network, network->name);
 210
 211         if (network->connected == FALSE)
 212                 return;
 213
 214         connman_device_set_disconnected(network->device, TRUE);
 215
 216         if (network->driver && network->driver->disconnect) {
 217                 network->driver->disconnect(network);
 218                 return;
 219         }
 220
 221         network->connected = FALSE;
 222 }
 223
 224 static void probe_driver(struct connman_network_driver *driver)
 225 {
 226         GSList *list;
 227
 228         DBG("driver %p name %s", driver, driver->name);
 229
 230         for (list = network_list; list != NULL; list = list->next) {
 231                 struct connman_network *network = list->data;
 232
 233                 if (network->driver != NULL)
 234                         continue;
 235
 236                 if (driver->type != network->type)
 237                         continue;
 238
 239                 if (driver->probe(network) < 0)
 240                         continue;
 241
 242                 network->driver = driver;
 243         }
 244 }
 245
 246 static void remove_driver(struct connman_network_driver *driver)
 247 {
 248         GSList *list;
 249
 250         DBG("driver %p name %s", driver, driver->name);
 251
 252         for (list = network_list; list != NULL; list = list->next) {
 253                 struct connman_network *network = list->data;
 254
 255                 if (network->driver == driver)
 256                         network_remove(network);
 257         }
 258 }
 259
 260 static gint compare_priority(gconstpointer a, gconstpointer b)
 261 {
 262         const struct connman_network_driver *driver1 = a;
 263         const struct connman_network_driver *driver2 = b;
 264
 265         return driver2->priority - driver1->priority;
 266 }
 267
 268 /**
 269  * connman_network_driver_register:
 270  * @driver: network driver definition
 271  *
 272  * Register a new network driver
 273  *
 274  * Returns: %0 on success
 275  */
 276 int connman_network_driver_register(struct connman_network_driver *driver)
 277 {
 278         GSList *list;
 279
 280         DBG("driver %p name %s", driver, driver->name);
 281
 282         for (list = driver_list; list; list = list->next) {
 283                 struct connman_network_driver *tmp = list->data;
 284
 285                 if (tmp->type == driver->type)
 286                         return -EALREADY;
 287
 288         }
 289
 290         driver_list = g_slist_insert_sorted(driver_list, driver,
 291                                                         compare_priority);
 292
 293         probe_driver(driver);
 294
 295         return 0;
 296 }
 297
 298 /**
 299  * connman_network_driver_unregister:
 300  * @driver: network driver definition
 301  *
 302  * Remove a previously registered network driver
 303  */
 304 void connman_network_driver_unregister(struct connman_network_driver *driver)
 305 {
 306         DBG("driver %p name %s", driver, driver->name);
 307
 308         driver_list = g_slist_remove(driver_list, driver);
 309
 310         remove_driver(driver);
 311 }
 312
 313 static void network_destruct(struct connman_network *network)
 314 {
 315         DBG("network %p name %s", network, network->name);
 316
 317         g_free(network->wifi.ssid);
 318         g_free(network->wifi.mode);
 319         g_free(network->wifi.security);
 320         g_free(network->wifi.passphrase);
 321         g_free(network->wifi.agent_passphrase);
 322         g_free(network->wifi.eap);
 323         g_free(network->wifi.identity);
 324         g_free(network->wifi.agent_identity);
 325         g_free(network->wifi.ca_cert_path);
 326         g_free(network->wifi.client_cert_path);
 327         g_free(network->wifi.private_key_path);
 328         g_free(network->wifi.private_key_passphrase);
 329         g_free(network->wifi.phase2_auth);
 330         g_free(network->wifi.pin_wps);
 331
 332         g_free(network->path);
 333         g_free(network->group);
 334         g_free(network->node);
 335         g_free(network->name);
 336         g_free(network->identifier);
 337
 338         network->device = NULL;
 339
 340         g_free(network);
 341 }
 342
 343 /**
 344  * connman_network_create:
 345  * @identifier: network identifier (for example an unqiue name)
 346  *
 347  * Allocate a new network and assign the #identifier to it.
 348  *
 349  * Returns: a newly-allocated #connman_network structure
 350  */
 351 struct connman_network *connman_network_create(const char *identifier,
 352                                                 enum connman_network_type type)
 353 {
 354         struct connman_network *network;
 355         char *ident;
 356
 357         DBG("identifier %s type %d", identifier, type);
 358
 359         network = g_try_new0(struct connman_network, 1);
 360         if (network == NULL)
 361                 return NULL;
 362
 363         DBG("network %p", network);
 364
 365         network->refcount = 1;
 366
 367         ident = g_strdup(identifier);
 368
 369         if (ident == NULL) {
 370                 g_free(network);
 371                 return NULL;
 372         }
 373
 374         network->type       = type;
 375         network->identifier = ident;
 376
 377         network_list = g_slist_prepend(network_list, network);
 378
 379         return network;
 380 }
 381
 382 /**
 383  * connman_network_ref:
 384  * @network: network structure
 385  *
 386  * Increase reference counter of  network
 387  */
 388 struct connman_network *
 389 connman_network_ref_debug(struct connman_network *network,
 390                         const char *file, int line, const char *caller)
 391 {
 392         DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
 393                 network->refcount + 1, file, line, caller);
 394
 395         __sync_fetch_and_add(&network->refcount, 1);
 396
 397         return network;
 398 }
 399
 400 /**
 401  * connman_network_unref:
 402  * @network: network structure
 403  *
 404  * Decrease reference counter of network
 405  */
 406 void connman_network_unref_debug(struct connman_network *network,
 407                                 const char *file, int line, const char *caller)
 408 {
 409         DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
 410                 network->refcount - 1, file, line, caller);
 411
 412         if (__sync_fetch_and_sub(&network->refcount, 1) != 1)
 413                 return;
 414
 415         network_list = g_slist_remove(network_list, network);
 416
 417         network_destruct(network);
 418 }
 419
 420 const char *__connman_network_get_type(struct connman_network *network)
 421 {
 422         return type2string(network->type);
 423 }
 424
 425 /**
 426  * connman_network_get_type:
 427  * @network: network structure
 428  *
 429  * Get type of network
 430  */
 431 enum connman_network_type connman_network_get_type(struct connman_network *network)
 432 {
 433         return network->type;
 434 }
 435
 436 /**
 437  * connman_network_get_identifier:
 438  * @network: network structure
 439  *
 440  * Get identifier of network
 441  */
 442 const char *connman_network_get_identifier(struct connman_network *network)
 443 {
 444         return network->identifier;
 445 }
 446
 447 /**
 448  * connman_network_set_index:
 449  * @network: network structure
 450  * @index: index number
 451  *
 452  * Set index number of network
 453  */
 454 void connman_network_set_index(struct connman_network *network, int index)
 455 {
 456         struct connman_service *service;
 457         struct connman_ipconfig *ipconfig;
 458
 459         service = connman_service_lookup_from_network(network);
 460         if (service == NULL)
 461                 goto done;
 462
 463         ipconfig = __connman_service_get_ip4config(service);
 464         if (ipconfig == NULL)
 465                 goto done;
 466
 467         /* If index changed, the index of ipconfig must be reset. */
 468         __connman_ipconfig_set_index(ipconfig, index);
 469
 470         DBG("index %d service %p ip4config %p", network->index,
 471                 service, ipconfig);
 472 done:
 473         network->index = index;
 474 }
 475
 476 /**
 477  * connman_network_get_index:
 478  * @network: network structure
 479  *
 480  * Get index number of network
 481  */
 482 int connman_network_get_index(struct connman_network *network)
 483 {
 484         return network->index;
 485 }
 486
 487 /**
 488  * connman_network_set_group:
 489  * @network: network structure
 490  * @group: group name
 491  *
 492  * Set group name for automatic clustering
 493  */
 494 void connman_network_set_group(struct connman_network *network,
 495                                                         const char *group)
 496 {
 497         switch (network->type) {
 498         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 499         case CONNMAN_NETWORK_TYPE_VENDOR:
 500                 return;
 501         case CONNMAN_NETWORK_TYPE_ETHERNET:
 502         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 503         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 504         case CONNMAN_NETWORK_TYPE_CELLULAR:
 505         case CONNMAN_NETWORK_TYPE_WIFI:
 506                 break;
 507         }
 508
 509         if (g_strcmp0(network->group, group) == 0) {
 510                 if (group != NULL)
 511                         __connman_service_update_from_network(network);
 512                 return;
 513         }
 514
 515         if (network->group != NULL) {
 516                 __connman_service_remove_from_network(network);
 517
 518                 g_free(network->group);
 519         }
 520
 521         network->group = g_strdup(group);
 522
 523         if (network->group != NULL)
 524                 network_probe(network);
 525 }
 526
 527 /**
 528  * connman_network_get_group:
 529  * @network: network structure
 530  *
 531  * Get group name for automatic clustering
 532  */
 533 const char *connman_network_get_group(struct connman_network *network)
 534 {
 535         return network->group;
 536 }
 537
 538 const char *__connman_network_get_ident(struct connman_network *network)
 539 {
 540         if (network->device == NULL)
 541                 return NULL;
 542
 543         return connman_device_get_ident(network->device);
 544 }
 545
 546 connman_bool_t __connman_network_get_weakness(struct connman_network *network)
 547 {
 548         switch (network->type) {
 549         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 550         case CONNMAN_NETWORK_TYPE_VENDOR:
 551         case CONNMAN_NETWORK_TYPE_ETHERNET:
 552         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 553         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 554         case CONNMAN_NETWORK_TYPE_CELLULAR:
 555                 break;
 556         case CONNMAN_NETWORK_TYPE_WIFI:
 557                 if (g_strcmp0(network->wifi.mode, "adhoc") == 0)
 558                         return TRUE;
 559                 if (network->strength > 0 && network->strength < 20)
 560                         return TRUE;
 561                 break;
 562         }
 563
 564         return FALSE;
 565 }
 566
 567 connman_bool_t connman_network_get_connecting(struct connman_network *network)
 568 {
 569         return network->connecting;
 570 }
 571
 572 /**
 573  * connman_network_set_available:
 574  * @network: network structure
 575  * @available: availability state
 576  *
 577  * Change availability state of network (in range)
 578  */
 579 int connman_network_set_available(struct connman_network *network,
 580                                                 connman_bool_t available)
 581 {
 582         DBG("network %p available %d", network, available);
 583
 584         if (network->available == available)
 585                 return -EALREADY;
 586
 587         network->available = available;
 588
 589         return 0;
 590 }
 591
 592 /**
 593  * connman_network_get_available:
 594  * @network: network structure
 595  *
 596  * Get network available setting
 597  */
 598 connman_bool_t connman_network_get_available(struct connman_network *network)
 599 {
 600         return network->available;
 601 }
 602
 603 /**
 604  * connman_network_set_associating:
 605  * @network: network structure
 606  * @associating: associating state
 607  *
 608  * Change associating state of network
 609  */
 610 int connman_network_set_associating(struct connman_network *network,
 611                                                 connman_bool_t associating)
 612 {
 613         DBG("network %p associating %d", network, associating);
 614
 615         if (network->associating == associating)
 616                 return -EALREADY;
 617
 618         network->associating = associating;
 619
 620         if (associating == TRUE) {
 621                 struct connman_service *service;
 622
 623                 service = connman_service_lookup_from_network(network);
 624                 __connman_service_ipconfig_indicate_state(service,
 625                                         CONNMAN_SERVICE_STATE_ASSOCIATION,
 626                                         CONNMAN_IPCONFIG_TYPE_IPV4);
 627                 __connman_service_ipconfig_indicate_state(service,
 628                                         CONNMAN_SERVICE_STATE_ASSOCIATION,
 629                                         CONNMAN_IPCONFIG_TYPE_IPV6);
 630         }
 631
 632         return 0;
 633 }
 634
 635 static void set_associate_error(struct connman_network *network)
 636 {
 637         struct connman_service *service;
 638
 639         service = connman_service_lookup_from_network(network);
 640
 641         __connman_service_indicate_error(service,
 642                                         CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
 643 }
 644
 645 static void set_configure_error(struct connman_network *network)
 646 {
 647         struct connman_service *service;
 648
 649         service = connman_service_lookup_from_network(network);
 650
 651         __connman_service_indicate_error(service,
 652                                         CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
 653 }
 654
 655 static void set_invalid_key_error(struct connman_network *network)
 656 {
 657         struct connman_service *service;
 658
 659         service = connman_service_lookup_from_network(network);
 660
 661         __connman_service_indicate_error(service,
 662                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
 663 }
 664
 665 static void set_connect_error(struct connman_network *network)
 666 {
 667         struct connman_service *service;
 668
 669         service = connman_service_lookup_from_network(network);
 670
 671         __connman_service_indicate_error(service,
 672                                         CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
 673 }
 674
 675 void connman_network_set_ipv4_method(struct connman_network *network,
 676                                         enum connman_ipconfig_method method)
 677 {
 678         struct connman_service *service;
 679         struct connman_ipconfig *ipconfig;
 680
 681         service = connman_service_lookup_from_network(network);
 682         if (service == NULL)
 683                 return;
 684
 685         ipconfig = __connman_service_get_ip4config(service);
 686         if (ipconfig == NULL)
 687                 return;
 688
 689         __connman_ipconfig_set_method(ipconfig, method);
 690 }
 691
 692 void connman_network_set_ipv6_method(struct connman_network *network,
 693                                         enum connman_ipconfig_method method)
 694 {
 695         struct connman_service *service;
 696         struct connman_ipconfig *ipconfig;
 697
 698         service = connman_service_lookup_from_network(network);
 699         if (service == NULL)
 700                 return;
 701
 702         ipconfig = __connman_service_get_ip6config(service);
 703         if (ipconfig == NULL)
 704                 return;
 705
 706         __connman_ipconfig_set_method(ipconfig, method);
 707 }
 708
 709 void connman_network_set_error(struct connman_network *network,
 710                                         enum connman_network_error error)
 711 {
 712         DBG("network %p error %d", network, error);
 713
 714         network->connecting = FALSE;
 715         network->associating = FALSE;
 716
 717         switch (error) {
 718         case CONNMAN_NETWORK_ERROR_UNKNOWN:
 719                 return;
 720         case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
 721                 set_associate_error(network);
 722                 break;
 723         case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
 724                 set_configure_error(network);
 725                 break;
 726         case CONNMAN_NETWORK_ERROR_INVALID_KEY:
 727                 set_invalid_key_error(network);
 728                 break;
 729         case CONNMAN_NETWORK_ERROR_CONNECT_FAIL:
 730                 set_connect_error(network);
 731                 break;
 732         }
 733
 734         network_change(network);
 735 }
 736
 737 void connman_network_clear_error(struct connman_network *network)
 738 {
 739         struct connman_service *service;
 740
 741         DBG("network %p", network);
 742
 743         if (network == NULL)
 744                 return;
 745
 746         if (network->connecting == TRUE || network->associating == TRUE)
 747                 return;
 748
 749         service = connman_service_lookup_from_network(network);
 750         __connman_service_clear_error(service);
 751 }
 752
 753 static void set_configuration(struct connman_network *network,
 754                         enum connman_ipconfig_type type)
 755 {
 756         struct connman_service *service;
 757
 758         DBG("network %p", network);
 759
 760         if (network->device == NULL)
 761                 return;
 762
 763         __connman_device_set_network(network->device, network);
 764
 765         connman_device_set_disconnected(network->device, FALSE);
 766
 767         service = connman_service_lookup_from_network(network);
 768         __connman_service_ipconfig_indicate_state(service,
 769                                         CONNMAN_SERVICE_STATE_CONFIGURATION,
 770                                         type);
 771 }
 772
 773 static void dhcp_success(struct connman_network *network)
 774 {
 775         struct connman_service *service;
 776         struct connman_ipconfig *ipconfig_ipv4;
 777         int err;
 778
 779         service = connman_service_lookup_from_network(network);
 780         if (service == NULL)
 781                 goto err;
 782
 783         connman_network_set_associating(network, FALSE);
 784
 785         network->connecting = FALSE;
 786
 787         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 788         err = __connman_ipconfig_address_add(ipconfig_ipv4);
 789         if (err < 0)
 790                 goto err;
 791
 792         err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
 793         if (err < 0)
 794                 goto err;
 795
 796         return;
 797
 798 err:
 799         connman_network_set_error(network,
 800                                 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
 801 }
 802
 803 static void dhcp_failure(struct connman_network *network)
 804 {
 805         struct connman_service *service;
 806
 807         service = connman_service_lookup_from_network(network);
 808         if (service == NULL)
 809                 return;
 810
 811         __connman_service_ipconfig_indicate_state(service,
 812                                         CONNMAN_SERVICE_STATE_IDLE,
 813                                         CONNMAN_IPCONFIG_TYPE_IPV4);
 814 }
 815
 816 static void dhcp_callback(struct connman_network *network,
 817                         connman_bool_t success)
 818 {
 819         DBG("success %d", success);
 820
 821         if (success == TRUE)
 822                 dhcp_success(network);
 823         else
 824                 dhcp_failure(network);
 825 }
 826
 827 static int set_connected_fixed(struct connman_network *network)
 828 {
 829         struct connman_service *service;
 830         struct connman_ipconfig *ipconfig_ipv4;
 831         int err;
 832
 833         DBG("");
 834
 835         service = connman_service_lookup_from_network(network);
 836
 837         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 838
 839         set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
 840
 841         network->connecting = FALSE;
 842
 843         connman_network_set_associating(network, FALSE);
 844
 845         err = __connman_ipconfig_address_add(ipconfig_ipv4);
 846         if (err < 0)
 847                 goto err;
 848
 849         err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
 850         if (err < 0)
 851                 goto err;
 852
 853         return 0;
 854
 855 err:
 856         connman_network_set_error(network,
 857                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
 858
 859         return err;
 860 }
 861
 862 static void set_connected_manual(struct connman_network *network)
 863 {
 864         struct connman_service *service;
 865         struct connman_ipconfig *ipconfig;
 866         int err;
 867
 868         DBG("network %p", network);
 869
 870         service = connman_service_lookup_from_network(network);
 871
 872         ipconfig = __connman_service_get_ip4config(service);
 873
 874         if (__connman_ipconfig_get_local(ipconfig) == NULL)
 875                 __connman_service_read_ip4config(service);
 876
 877         set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
 878
 879         err = __connman_ipconfig_address_add(ipconfig);
 880         if (err < 0)
 881                 goto err;
 882
 883         err = __connman_ipconfig_gateway_add(ipconfig);
 884         if (err < 0)
 885                 goto err;
 886
 887         network->connecting = FALSE;
 888
 889         connman_network_set_associating(network, FALSE);
 890
 891         return;
 892
 893 err:
 894         connman_network_set_error(network,
 895                                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
 896         return;
 897 }
 898
 899 static int set_connected_dhcp(struct connman_network *network)
 900 {
 901         int err;
 902
 903         DBG("network %p", network);
 904
 905         set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
 906
 907         err = __connman_dhcp_start(network, dhcp_callback);
 908         if (err < 0) {
 909                 connman_error("Can not request DHCP lease");
 910                 return err;
 911         }
 912
 913         return 0;
 914 }
 915
 916 static int manual_ipv6_set(struct connman_network *network,
 917                                 struct connman_ipconfig *ipconfig_ipv6)
 918 {
 919         struct connman_service *service;
 920         int err;
 921
 922         DBG("network %p ipv6 %p", network, ipconfig_ipv6);
 923
 924         service = connman_service_lookup_from_network(network);
 925         if (service == NULL)
 926                 return -EINVAL;
 927
 928         if (__connman_ipconfig_get_local(ipconfig_ipv6) == NULL)
 929                 __connman_service_read_ip6config(service);
 930
 931         __connman_ipconfig_enable_ipv6(ipconfig_ipv6);
 932
 933         err = __connman_ipconfig_address_add(ipconfig_ipv6);
 934         if (err < 0) {
 935                 connman_network_set_error(network,
 936                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
 937                 return err;
 938         }
 939
 940         err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
 941         if (err < 0)
 942                 return err;
 943
 944         __connman_connection_gateway_activate(service,
 945                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
 946
 947         __connman_device_set_network(network->device, network);
 948
 949         connman_device_set_disconnected(network->device, FALSE);
 950
 951         network->connecting = FALSE;
 952
 953         return 0;
 954 }
 955
 956 static void stop_dhcpv6(struct connman_network *network)
 957 {
 958         __connman_dhcpv6_stop(network);
 959 }
 960
 961 static void dhcpv6_release_callback(struct connman_network *network,
 962                                 connman_bool_t success)
 963 {
 964         DBG("success %d", success);
 965
 966         stop_dhcpv6(network);
 967 }
 968
 969 static void release_dhcpv6(struct connman_network *network)
 970 {
 971         __connman_dhcpv6_start_release(network, dhcpv6_release_callback);
 972         stop_dhcpv6(network);
 973 }
 974
 975 static void dhcpv6_info_callback(struct connman_network *network,
 976                                 connman_bool_t success)
 977 {
 978         DBG("success %d", success);
 979
 980         stop_dhcpv6(network);
 981 }
 982
 983 static gboolean dhcpv6_set_addresses(struct connman_network *network)
 984 {
 985         struct connman_service *service;
 986         struct connman_ipconfig *ipconfig_ipv6;
 987         int err = -EINVAL;
 988
 989         service = connman_service_lookup_from_network(network);
 990         if (service == NULL)
 991                 goto err;
 992
 993         connman_network_set_associating(network, FALSE);
 994
 995         network->connecting = FALSE;
 996
 997         ipconfig_ipv6 = __connman_service_get_ip6config(service);
 998         err = __connman_ipconfig_address_add(ipconfig_ipv6);
 999         if (err < 0)
1000                 goto err;
1001
1002         err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
1003         if (err < 0)
1004                 goto err;
1005
1006         return 0;
1007
1008 err:
1009         connman_network_set_error(network,
1010                                 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1011         return err;
1012 }
1013
1014 static void autoconf_ipv6_set(struct connman_network *network);
1015 static void dhcpv6_callback(struct connman_network *network,
1016                         connman_bool_t success);
1017
1018 /*
1019  * Have a separate callback for renew so that we do not do autoconf
1020  * in wrong phase as the dhcpv6_callback() is also called when doing
1021  * DHCPv6 solicitation.
1022  */
1023 static void dhcpv6_renew_callback(struct connman_network *network,
1024                                         connman_bool_t success)
1025 {
1026         if (success == TRUE)
1027                 dhcpv6_callback(network, success);
1028         else {
1029                 stop_dhcpv6(network);
1030
1031                 /* restart and do solicit again. */
1032                 autoconf_ipv6_set(network);
1033         }
1034 }
1035
1036 static void dhcpv6_callback(struct connman_network *network,
1037                                         connman_bool_t success)
1038 {
1039         DBG("success %d", success);
1040
1041         /* Start the renew process if necessary */
1042         if (success == TRUE) {
1043
1044                 if (dhcpv6_set_addresses(network) < 0) {
1045                         stop_dhcpv6(network);
1046                         return;
1047                 }
1048
1049                 if (__connman_dhcpv6_start_renew(network,
1050                                         dhcpv6_renew_callback) == -ETIMEDOUT)
1051                         dhcpv6_renew_callback(network, FALSE);
1052         } else
1053                 stop_dhcpv6(network);
1054 }
1055
1056 static void check_dhcpv6(struct nd_router_advert *reply,
1057                         unsigned int length, void *user_data)
1058 {
1059         struct connman_network *network = user_data;
1060         GSList *prefixes;
1061
1062         DBG("reply %p", reply);
1063
1064         if (reply == NULL) {
1065                 /*
1066                  * Router solicitation message seem to get lost easily so
1067                  * try to send it again.
1068                  */
1069                 if (network->router_solicit_count > 0) {
1070                         DBG("re-send router solicitation %d",
1071                                                 network->router_solicit_count);
1072                         network->router_solicit_count--;
1073                         __connman_inet_ipv6_send_rs(network->index, 1,
1074                                                 check_dhcpv6, network);
1075                         return;
1076                 }
1077                 connman_network_unref(network);
1078                 return;
1079         }
1080
1081         network->router_solicit_count = 0;
1082
1083         /*
1084          * If we were disconnected while waiting router advertisement,
1085          * we just quit and do not start DHCPv6
1086          */
1087         if (network->connected == FALSE) {
1088                 connman_network_unref(network);
1089                 return;
1090         }
1091
1092         prefixes = __connman_inet_ipv6_get_prefixes(reply, length);
1093
1094         /*
1095          * We do stateful/stateless DHCPv6 if router advertisement says so.
1096          */
1097         if (reply->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED)
1098                 __connman_dhcpv6_start(network, prefixes, dhcpv6_callback);
1099         else if (reply->nd_ra_flags_reserved & ND_RA_FLAG_OTHER)
1100                 __connman_dhcpv6_start_info(network, dhcpv6_info_callback);
1101
1102         connman_network_unref(network);
1103 }
1104
1105 static void receive_refresh_rs_reply(struct nd_router_advert *reply,
1106                 unsigned int length, void *user_data)
1107 {
1108         struct connman_network *network = user_data;
1109
1110         DBG("reply %p", reply);
1111
1112         if (reply == NULL) {
1113                 /*
1114                  * Router solicitation message seem to get lost easily so
1115                  * try to send it again.
1116                  */
1117                 if (network->router_solicit_refresh_count > 1) {
1118                         network->router_solicit_refresh_count--;
1119                         DBG("re-send router solicitation %d",
1120                                         network->router_solicit_refresh_count);
1121                         __connman_inet_ipv6_send_rs(network->index,
1122                                         RS_REFRESH_TIMEOUT,
1123                                         receive_refresh_rs_reply,
1124                                         network);
1125                         return;
1126                 }
1127         }
1128
1129         /* RS refresh not in progress anymore */
1130         network->router_solicit_refresh_count = 0;
1131
1132         connman_network_unref(network);
1133         return;
1134 }
1135
1136 int __connman_refresh_rs_ipv6(struct connman_network *network, int index)
1137 {
1138         int ret = 0;
1139
1140         DBG("network %p index %d", network, index);
1141
1142         /* Send only one RS for all RDNSS entries which are about to expire */
1143         if (network->router_solicit_refresh_count > 0) {
1144                 DBG("RS refresh already started");
1145                 return 0;
1146         }
1147
1148         network->router_solicit_refresh_count = RS_REFRESH_COUNT;
1149
1150         connman_network_ref(network);
1151
1152         ret = __connman_inet_ipv6_send_rs(index, RS_REFRESH_TIMEOUT,
1153                         receive_refresh_rs_reply, network);
1154         return ret;
1155 }
1156
1157 static void autoconf_ipv6_set(struct connman_network *network)
1158 {
1159         struct connman_service *service;
1160         struct connman_ipconfig *ipconfig;
1161         int index;
1162
1163         DBG("network %p", network);
1164
1165         if (network->router_solicit_count > 0) {
1166                 /*
1167                  * The autoconfiguration is already pending and we have sent
1168                  * router solicitation messages and are now waiting answers.
1169                  * There is no need to continue any further.
1170                  */
1171                 DBG("autoconfiguration already started");
1172                 return;
1173         }
1174
1175         __connman_device_set_network(network->device, network);
1176
1177         connman_device_set_disconnected(network->device, FALSE);
1178
1179         network->connecting = FALSE;
1180
1181         service = connman_service_lookup_from_network(network);
1182         if (service == NULL)
1183                 return;
1184
1185         ipconfig = __connman_service_get_ip6config(service);
1186         if (ipconfig == NULL)
1187                 return;
1188
1189         index = __connman_ipconfig_get_index(ipconfig);
1190
1191         connman_network_ref(network);
1192
1193         /* Try to get stateless DHCPv6 information, RFC 3736 */
1194         network->router_solicit_count = 3;
1195         __connman_inet_ipv6_send_rs(index, 1, check_dhcpv6, network);
1196 }
1197
1198 static void set_connected(struct connman_network *network)
1199 {
1200         struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
1201         enum connman_ipconfig_method ipv4_method, ipv6_method;
1202         struct connman_service *service;
1203         int ret;
1204
1205         if (network->connected == TRUE)
1206                 return;
1207
1208         network->connected = TRUE;
1209
1210         service = connman_service_lookup_from_network(network);
1211
1212         ipconfig_ipv4 = __connman_service_get_ip4config(service);
1213         ipconfig_ipv6 = __connman_service_get_ip6config(service);
1214
1215         DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
1216                 ipconfig_ipv6);
1217
1218         ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
1219         ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
1220
1221         DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
1222
1223         switch (ipv6_method) {
1224         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1225         case CONNMAN_IPCONFIG_METHOD_OFF:
1226                 break;
1227         case CONNMAN_IPCONFIG_METHOD_DHCP:
1228         case CONNMAN_IPCONFIG_METHOD_AUTO:
1229                 autoconf_ipv6_set(network);
1230                 break;
1231         case CONNMAN_IPCONFIG_METHOD_FIXED:
1232         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1233                 ret = manual_ipv6_set(network, ipconfig_ipv6);
1234                 if (ret != 0) {
1235                         connman_network_set_error(network,
1236                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1237                         return;
1238                 }
1239                 break;
1240         }
1241
1242         switch (ipv4_method) {
1243         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1244         case CONNMAN_IPCONFIG_METHOD_OFF:
1245         case CONNMAN_IPCONFIG_METHOD_AUTO:
1246                 return;
1247         case CONNMAN_IPCONFIG_METHOD_FIXED:
1248                 if (set_connected_fixed(network) < 0) {
1249                         connman_network_set_error(network,
1250                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1251                         return;
1252                 }
1253                 return;
1254         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1255                 set_connected_manual(network);
1256                 return;
1257         case CONNMAN_IPCONFIG_METHOD_DHCP:
1258                 if (set_connected_dhcp(network) < 0) {
1259                         connman_network_set_error(network,
1260                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1261                         return;
1262                 }
1263         }
1264
1265         network->connecting = FALSE;
1266
1267         connman_network_set_associating(network, FALSE);
1268 }
1269
1270 static void set_disconnected(struct connman_network *network)
1271 {
1272         struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
1273         enum connman_ipconfig_method ipv4_method, ipv6_method;
1274         enum connman_service_state state;
1275         struct connman_service *service;
1276
1277         if (network->connected == FALSE)
1278                 return;
1279
1280         network->connected = FALSE;
1281
1282         service = connman_service_lookup_from_network(network);
1283
1284         ipconfig_ipv4 = __connman_service_get_ip4config(service);
1285         ipconfig_ipv6 = __connman_service_get_ip6config(service);
1286
1287         DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
1288                 ipconfig_ipv6);
1289
1290         ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
1291         ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
1292
1293         DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
1294
1295         /*
1296          * Resetting solicit count here will prevent the RS resend loop
1297          * from sending packets in check_dhcpv6()
1298          */
1299         network->router_solicit_count = 0;
1300
1301         __connman_device_set_network(network->device, NULL);
1302
1303         switch (ipv6_method) {
1304         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1305         case CONNMAN_IPCONFIG_METHOD_OFF:
1306         case CONNMAN_IPCONFIG_METHOD_FIXED:
1307         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1308                 break;
1309         case CONNMAN_IPCONFIG_METHOD_DHCP:
1310         case CONNMAN_IPCONFIG_METHOD_AUTO:
1311                 release_dhcpv6(network);
1312                 break;
1313         }
1314
1315         switch (ipv4_method) {
1316         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1317         case CONNMAN_IPCONFIG_METHOD_OFF:
1318         case CONNMAN_IPCONFIG_METHOD_AUTO:
1319         case CONNMAN_IPCONFIG_METHOD_FIXED:
1320         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1321                 break;
1322         case CONNMAN_IPCONFIG_METHOD_DHCP:
1323                 __connman_dhcp_stop(network);
1324                 break;
1325         }
1326
1327         /*
1328          * We only set the disconnect state if we were not in idle
1329          * or in failure. It does not make sense to go to disconnect
1330          * state if we were not connected.
1331          */
1332         state = __connman_service_ipconfig_get_state(service,
1333                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
1334         if (state != CONNMAN_SERVICE_STATE_IDLE &&
1335                         state != CONNMAN_SERVICE_STATE_FAILURE)
1336                 __connman_service_ipconfig_indicate_state(service,
1337                                         CONNMAN_SERVICE_STATE_DISCONNECT,
1338                                         CONNMAN_IPCONFIG_TYPE_IPV4);
1339
1340         state = __connman_service_ipconfig_get_state(service,
1341                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
1342         if (state != CONNMAN_SERVICE_STATE_IDLE &&
1343                                 state != CONNMAN_SERVICE_STATE_FAILURE)
1344                 __connman_service_ipconfig_indicate_state(service,
1345                                         CONNMAN_SERVICE_STATE_DISCONNECT,
1346                                         CONNMAN_IPCONFIG_TYPE_IPV6);
1347
1348         __connman_connection_gateway_remove(service,
1349                                         CONNMAN_IPCONFIG_TYPE_ALL);
1350
1351         __connman_ipconfig_address_unset(ipconfig_ipv4);
1352         __connman_ipconfig_address_unset(ipconfig_ipv6);
1353
1354         /*
1355          * Special handling for IPv6 autoconfigured address.
1356          * The simplest way to remove autoconfigured routes is to
1357          * disable IPv6 temporarily so that kernel will do the cleanup
1358          * automagically.
1359          */
1360         if (ipv6_method == CONNMAN_IPCONFIG_METHOD_AUTO) {
1361                 __connman_ipconfig_disable_ipv6(ipconfig_ipv6);
1362                 __connman_ipconfig_enable_ipv6(ipconfig_ipv6);
1363         }
1364
1365         __connman_service_ipconfig_indicate_state(service,
1366                                                 CONNMAN_SERVICE_STATE_IDLE,
1367                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
1368
1369         __connman_service_ipconfig_indicate_state(service,
1370                                                 CONNMAN_SERVICE_STATE_IDLE,
1371                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
1372
1373         network->connecting = FALSE;
1374
1375         connman_network_set_associating(network, FALSE);
1376 }
1377
1378 /**
1379  * connman_network_set_connected:
1380  * @network: network structure
1381  * @connected: connected state
1382  *
1383  * Change connected state of network
1384  */
1385 int connman_network_set_connected(struct connman_network *network,
1386                                                 connman_bool_t connected)
1387 {
1388         DBG("network %p connected %d/%d connecting %d associating %d",
1389                 network, network->connected, connected, network->connecting,
1390                 network->associating);
1391
1392         if ((network->connecting == TRUE || network->associating == TRUE) &&
1393                                                         connected == FALSE) {
1394                 connman_network_set_error(network,
1395                                         CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
1396                 if (__connman_network_disconnect(network) == 0)
1397                         return 0;
1398         }
1399
1400         if (network->connected == connected)
1401                 return -EALREADY;
1402
1403         if (connected == FALSE)
1404                 set_disconnected(network);
1405         else
1406                 set_connected(network);
1407
1408         return 0;
1409 }
1410
1411 /**
1412  * connman_network_get_connected:
1413  * @network: network structure
1414  *
1415  * Get network connection status
1416  */
1417 connman_bool_t connman_network_get_connected(struct connman_network *network)
1418 {
1419         return network->connected;
1420 }
1421
1422 /**
1423  * connman_network_get_associating:
1424  * @network: network structure
1425  *
1426  * Get network associating status
1427  */
1428 connman_bool_t connman_network_get_associating(struct connman_network *network)
1429 {
1430         return network->associating;
1431 }
1432
1433 void connman_network_clear_hidden(void *user_data)
1434 {
1435         if (user_data == NULL)
1436                 return;
1437
1438         DBG("user_data %p", user_data);
1439
1440         /*
1441          * Hidden service does not have a connect timeout so
1442          * we do not need to remove it. We can just return
1443          * error to the caller telling that we could not find
1444          * any network that we could connect to.
1445          */
1446         __connman_service_reply_dbus_pending(user_data, EIO, NULL);
1447 }
1448
1449 int connman_network_connect_hidden(struct connman_network *network,
1450                         char *identity, char* passphrase, void *user_data)
1451 {
1452         int err = 0;
1453         struct connman_service *service;
1454
1455         service = connman_service_lookup_from_network(network);
1456
1457         DBG("network %p service %p user_data %p", network, service, user_data);
1458
1459         if (service == NULL) {
1460                 err = -EINVAL;
1461                 goto out;
1462         }
1463
1464         if (identity != NULL)
1465                 __connman_service_set_agent_identity(service, identity);
1466
1467         if (passphrase != NULL)
1468                 err = __connman_service_add_passphrase(service, passphrase);
1469
1470         if (err == -ENOKEY) {
1471                 __connman_service_indicate_error(service,
1472                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
1473                 goto out;
1474         } else {
1475                 __connman_service_set_hidden(service);
1476                 __connman_service_set_userconnect(service, TRUE);
1477                 __connman_service_set_hidden_data(service, user_data);
1478                 return __connman_service_connect(service);
1479         }
1480
1481 out:
1482         __connman_service_return_error(service, -err, user_data);
1483         return err;
1484 }
1485
1486 /**
1487  * __connman_network_connect:
1488  * @network: network structure
1489  *
1490  * Connect network
1491  */
1492 int __connman_network_connect(struct connman_network *network)
1493 {
1494         int err;
1495
1496         DBG("network %p", network);
1497
1498         if (network->connected == TRUE)
1499                 return -EISCONN;
1500
1501         if (network->connecting == TRUE || network->associating == TRUE)
1502                 return -EALREADY;
1503
1504         if (network->driver == NULL)
1505                 return -EUNATCH;
1506
1507         if (network->driver->connect == NULL)
1508                 return -ENOSYS;
1509
1510         if (network->device == NULL)
1511                 return -ENODEV;
1512
1513         network->connecting = TRUE;
1514
1515         __connman_device_disconnect(network->device);
1516
1517         err = network->driver->connect(network);
1518         if (err < 0) {
1519                 if (err == -EINPROGRESS)
1520                         connman_network_set_associating(network, TRUE);
1521                 else {
1522                         network->connecting = FALSE;
1523                 }
1524
1525                 return err;
1526         }
1527
1528         set_connected(network);
1529
1530         return err;
1531 }
1532
1533 /**
1534  * __connman_network_disconnect:
1535  * @network: network structure
1536  *
1537  * Disconnect network
1538  */
1539 int __connman_network_disconnect(struct connman_network *network)
1540 {
1541         int err;
1542
1543         DBG("network %p", network);
1544
1545         if (network->connected == FALSE && network->connecting == FALSE &&
1546                                                 network->associating == FALSE)
1547                 return -ENOTCONN;
1548
1549         if (network->driver == NULL)
1550                 return -EUNATCH;
1551
1552         if (network->driver->disconnect == NULL)
1553                 return -ENOSYS;
1554
1555         network->connecting = FALSE;
1556
1557         err = network->driver->disconnect(network);
1558         if (err == 0)
1559                 set_disconnected(network);
1560
1561         return err;
1562 }
1563
1564 static int manual_ipv4_set(struct connman_network *network,
1565                                 struct connman_ipconfig *ipconfig)
1566 {
1567         struct connman_service *service;
1568         int err;
1569
1570         service = connman_service_lookup_from_network(network);
1571         if (service == NULL)
1572                 return -EINVAL;
1573
1574         err = __connman_ipconfig_address_add(ipconfig);
1575         if (err < 0) {
1576                 connman_network_set_error(network,
1577                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1578                 return err;
1579         }
1580
1581         return __connman_ipconfig_gateway_add(ipconfig);
1582 }
1583
1584 int __connman_network_clear_ipconfig(struct connman_network *network,
1585                                         struct connman_ipconfig *ipconfig)
1586 {
1587         struct connman_service *service;
1588         enum connman_ipconfig_method method;
1589         enum connman_ipconfig_type type;
1590
1591         service = connman_service_lookup_from_network(network);
1592         if (service == NULL)
1593                 return -EINVAL;
1594
1595         method = __connman_ipconfig_get_method(ipconfig);
1596         type = __connman_ipconfig_get_config_type(ipconfig);
1597
1598         switch (method) {
1599         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1600         case CONNMAN_IPCONFIG_METHOD_OFF:
1601         case CONNMAN_IPCONFIG_METHOD_FIXED:
1602                 return -EINVAL;
1603         case CONNMAN_IPCONFIG_METHOD_AUTO:
1604                 release_dhcpv6(network);
1605                 break;
1606         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1607                 __connman_ipconfig_address_remove(ipconfig);
1608                 break;
1609         case CONNMAN_IPCONFIG_METHOD_DHCP:
1610                 __connman_dhcp_stop(network);
1611                 break;
1612         }
1613
1614         if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1615                 __connman_service_ipconfig_indicate_state(service,
1616                                         CONNMAN_SERVICE_STATE_CONFIGURATION,
1617                                         CONNMAN_IPCONFIG_TYPE_IPV6);
1618         else if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1619                 __connman_service_ipconfig_indicate_state(service,
1620                                         CONNMAN_SERVICE_STATE_CONFIGURATION,
1621                                         CONNMAN_IPCONFIG_TYPE_IPV4);
1622
1623         return 0;
1624 }
1625
1626 int __connman_network_set_ipconfig(struct connman_network *network,
1627                                         struct connman_ipconfig *ipconfig_ipv4,
1628                                         struct connman_ipconfig *ipconfig_ipv6)
1629 {
1630         enum connman_ipconfig_method method;
1631         int ret;
1632
1633         if (network == NULL)
1634                 return -EINVAL;
1635
1636         if (ipconfig_ipv6) {
1637                 method = __connman_ipconfig_get_method(ipconfig_ipv6);
1638
1639                 switch (method) {
1640                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1641                 case CONNMAN_IPCONFIG_METHOD_OFF:
1642                         break;
1643                 case CONNMAN_IPCONFIG_METHOD_AUTO:
1644                         autoconf_ipv6_set(network);
1645                         break;
1646                 case CONNMAN_IPCONFIG_METHOD_FIXED:
1647                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1648                         ret = manual_ipv6_set(network, ipconfig_ipv6);
1649                         if (ret != 0) {
1650                                 connman_network_set_error(network,
1651                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1652                                 return ret;
1653                         }
1654                         break;
1655                 case CONNMAN_IPCONFIG_METHOD_DHCP:
1656                         break;
1657                 }
1658         }
1659
1660         if (ipconfig_ipv4) {
1661                 method = __connman_ipconfig_get_method(ipconfig_ipv4);
1662
1663                 switch (method) {
1664                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1665                 case CONNMAN_IPCONFIG_METHOD_OFF:
1666                 case CONNMAN_IPCONFIG_METHOD_FIXED:
1667                 case CONNMAN_IPCONFIG_METHOD_AUTO:
1668                         return -EINVAL;
1669                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1670                         return manual_ipv4_set(network, ipconfig_ipv4);
1671                 case CONNMAN_IPCONFIG_METHOD_DHCP:
1672                         return __connman_dhcp_start(network, dhcp_callback);
1673                 }
1674         }
1675
1676         return 0;
1677 }
1678
1679 int connman_network_set_ipaddress(struct connman_network *network,
1680                                         struct connman_ipaddress *ipaddress)
1681 {
1682         struct connman_service *service;
1683         struct connman_ipconfig *ipconfig = NULL;
1684
1685         DBG("network %p", network);
1686
1687         service = connman_service_lookup_from_network(network);
1688         if (service == NULL)
1689                 return -EINVAL;
1690
1691         ipconfig = __connman_service_get_ipconfig(service, ipaddress->family);
1692         if (ipconfig == NULL)
1693                 return -EINVAL;
1694
1695         __connman_ipconfig_set_local(ipconfig, ipaddress->local);
1696         __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
1697         __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
1698         __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
1699         __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
1700
1701         return 0;
1702 }
1703
1704 int connman_network_set_nameservers(struct connman_network *network,
1705                                 const char *nameservers)
1706 {
1707         struct connman_service *service;
1708         char **nameservers_array;
1709         int i;
1710
1711         DBG("network %p nameservers %s", network, nameservers);
1712
1713         service = connman_service_lookup_from_network(network);
1714         if (service == NULL)
1715                 return -EINVAL;
1716
1717         __connman_service_nameserver_clear(service);
1718
1719         if (nameservers == NULL)
1720                 return 0;
1721
1722         nameservers_array = g_strsplit(nameservers, " ", 0);
1723
1724         for (i = 0; nameservers_array[i] != NULL; i++) {
1725                 __connman_service_nameserver_append(service,
1726                                                 nameservers_array[i], FALSE);
1727         }
1728
1729         g_strfreev(nameservers_array);
1730
1731         return 0;
1732 }
1733
1734 int connman_network_set_domain(struct connman_network *network,
1735                                 const char *domain)
1736 {
1737         struct connman_service *service;
1738
1739         DBG("network %p domain %s", network, domain);
1740
1741         service = connman_service_lookup_from_network(network);
1742         if (service == NULL)
1743                 return -EINVAL;
1744
1745         __connman_service_set_domainname(service, domain);
1746
1747         return 0;
1748 }
1749
1750 /**
1751  * connman_network_set_name:
1752  * @network: network structure
1753  * @name: name value
1754  *
1755  * Set display name value for network
1756  */
1757 int connman_network_set_name(struct connman_network *network,
1758                                                         const char *name)
1759 {
1760         DBG("network %p name %s", network, name);
1761
1762         g_free(network->name);
1763         network->name = g_strdup(name);
1764
1765         return 0;
1766 }
1767
1768 /**
1769  * connman_network_set_strength:
1770  * @network: network structure
1771  * @strength: strength value
1772  *
1773  * Set signal strength value for network
1774  */
1775
1776 int connman_network_set_strength(struct connman_network *network,
1777                                                 connman_uint8_t strength)
1778 {
1779         DBG("network %p strengh %d", network, strength);
1780
1781         network->strength = strength;
1782
1783         return 0;
1784 }
1785
1786 connman_uint8_t connman_network_get_strength(struct connman_network *network)
1787 {
1788         return network->strength;
1789 }
1790
1791 int connman_network_set_frequency(struct connman_network *network,
1792                                                 connman_uint16_t frequency)
1793 {
1794         DBG("network %p frequency %d", network, frequency);
1795
1796         network->frequency = frequency;
1797
1798         return 0;
1799 }
1800
1801 connman_uint16_t connman_network_get_frequency(struct connman_network *network)
1802 {
1803         return network->frequency;
1804 }
1805
1806 int connman_network_set_wifi_channel(struct connman_network *network,
1807                                                 connman_uint16_t channel)
1808 {
1809         DBG("network %p wifi channel %d", network, channel);
1810
1811         network->wifi.channel = channel;
1812
1813         return 0;
1814 }
1815
1816 connman_uint16_t connman_network_get_wifi_channel(struct connman_network *network)
1817 {
1818         return network->wifi.channel;
1819 }
1820
1821 /**
1822  * connman_network_set_string:
1823  * @network: network structure
1824  * @key: unique identifier
1825  * @value: string value
1826  *
1827  * Set string value for specific key
1828  */
1829 int connman_network_set_string(struct connman_network *network,
1830                                         const char *key, const char *value)
1831 {
1832         DBG("network %p key %s value %s", network, key, value);
1833
1834         if (g_strcmp0(key, "Name") == 0)
1835                 return connman_network_set_name(network, value);
1836
1837         if (g_str_equal(key, "Path") == TRUE) {
1838                 g_free(network->path);
1839                 network->path = g_strdup(value);
1840         } else if (g_str_equal(key, "Node") == TRUE) {
1841                 g_free(network->node);
1842                 network->node = g_strdup(value);
1843         } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
1844                 g_free(network->wifi.mode);
1845                 network->wifi.mode = g_strdup(value);
1846         } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
1847                 g_free(network->wifi.security);
1848                 network->wifi.security = g_strdup(value);
1849         } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
1850                 g_free(network->wifi.passphrase);
1851                 network->wifi.passphrase = g_strdup(value);
1852         } else if (g_str_equal(key, "WiFi.AgentPassphrase") == TRUE) {
1853                 g_free(network->wifi.agent_passphrase);
1854                 network->wifi.agent_passphrase = g_strdup(value);
1855         } else if (g_str_equal(key, "WiFi.EAP") == TRUE) {
1856                 g_free(network->wifi.eap);
1857                 network->wifi.eap = g_strdup(value);
1858         } else if (g_str_equal(key, "WiFi.Identity") == TRUE) {
1859                 g_free(network->wifi.identity);
1860                 network->wifi.identity = g_strdup(value);
1861         } else if (g_str_equal(key, "WiFi.AgentIdentity") == TRUE) {
1862                 g_free(network->wifi.agent_identity);
1863                 network->wifi.agent_identity = g_strdup(value);
1864         } else if (g_str_equal(key, "WiFi.CACertFile") == TRUE) {
1865                 g_free(network->wifi.ca_cert_path);
1866                 network->wifi.ca_cert_path = g_strdup(value);
1867         } else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE) {
1868                 g_free(network->wifi.client_cert_path);
1869                 network->wifi.client_cert_path = g_strdup(value);
1870         } else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE) {
1871                 g_free(network->wifi.private_key_path);
1872                 network->wifi.private_key_path = g_strdup(value);
1873         } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE) {
1874                 g_free(network->wifi.private_key_passphrase);
1875                 network->wifi.private_key_passphrase = g_strdup(value);
1876         } else if (g_str_equal(key, "WiFi.Phase2") == TRUE) {
1877                 g_free(network->wifi.phase2_auth);
1878                 network->wifi.phase2_auth = g_strdup(value);
1879         } else if (g_str_equal(key, "WiFi.PinWPS") == TRUE) {
1880                 g_free(network->wifi.pin_wps);
1881                 network->wifi.pin_wps = g_strdup(value);
1882         } else {
1883                 return -EINVAL;
1884         }
1885
1886         return 0;
1887 }
1888
1889 /**
1890  * connman_network_get_string:
1891  * @network: network structure
1892  * @key: unique identifier
1893  *
1894  * Get string value for specific key
1895  */
1896 const char *connman_network_get_string(struct connman_network *network,
1897                                                         const char *key)
1898 {
1899         DBG("network %p key %s", network, key);
1900
1901         if (g_str_equal(key, "Path") == TRUE)
1902                 return network->path;
1903         else if (g_str_equal(key, "Name") == TRUE)
1904                 return network->name;
1905         else if (g_str_equal(key, "Node") == TRUE)
1906                 return network->node;
1907         else if (g_str_equal(key, "WiFi.Mode") == TRUE)
1908                 return network->wifi.mode;
1909         else if (g_str_equal(key, "WiFi.Security") == TRUE)
1910                 return network->wifi.security;
1911         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
1912                 return network->wifi.passphrase;
1913         else if (g_str_equal(key, "WiFi.AgentPassphrase") == TRUE)
1914                 return network->wifi.agent_passphrase;
1915         else if (g_str_equal(key, "WiFi.EAP") == TRUE)
1916                 return network->wifi.eap;
1917         else if (g_str_equal(key, "WiFi.Identity") == TRUE)
1918                 return network->wifi.identity;
1919         else if (g_str_equal(key, "WiFi.AgentIdentity") == TRUE)
1920                 return network->wifi.agent_identity;
1921         else if (g_str_equal(key, "WiFi.CACertFile") == TRUE)
1922                 return network->wifi.ca_cert_path;
1923         else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE)
1924                 return network->wifi.client_cert_path;
1925         else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE)
1926                 return network->wifi.private_key_path;
1927         else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE)
1928                 return network->wifi.private_key_passphrase;
1929         else if (g_str_equal(key, "WiFi.Phase2") == TRUE)
1930                 return network->wifi.phase2_auth;
1931         else if (g_str_equal(key, "WiFi.PinWPS") == TRUE)
1932                 return network->wifi.pin_wps;
1933
1934         return NULL;
1935 }
1936
1937 /**
1938  * connman_network_set_bool:
1939  * @network: network structure
1940  * @key: unique identifier
1941  * @value: boolean value
1942  *
1943  * Set boolean value for specific key
1944  */
1945 int connman_network_set_bool(struct connman_network *network,
1946                                         const char *key, connman_bool_t value)
1947 {
1948         DBG("network %p key %s value %d", network, key, value);
1949
1950         if (g_strcmp0(key, "Roaming") == 0)
1951                 network->roaming = value;
1952         else if (g_strcmp0(key, "WiFi.WPS") == 0)
1953                 network->wifi.wps = value;
1954         else if (g_strcmp0(key, "WiFi.UseWPS") == 0)
1955                 network->wifi.use_wps = value;
1956
1957         return -EINVAL;
1958 }
1959
1960 /**
1961  * connman_network_get_bool:
1962  * @network: network structure
1963  * @key: unique identifier
1964  *
1965  * Get boolean value for specific key
1966  */
1967 connman_bool_t connman_network_get_bool(struct connman_network *network,
1968                                                         const char *key)
1969 {
1970         DBG("network %p key %s", network, key);
1971
1972         if (g_str_equal(key, "Roaming") == TRUE)
1973                 return network->roaming;
1974         else if (g_str_equal(key, "WiFi.WPS") == TRUE)
1975                 return network->wifi.wps;
1976         else if (g_str_equal(key, "WiFi.UseWPS") == TRUE)
1977                 return network->wifi.use_wps;
1978
1979         return FALSE;
1980 }
1981
1982 /**
1983  * connman_network_set_blob:
1984  * @network: network structure
1985  * @key: unique identifier
1986  * @data: blob data
1987  * @size: blob size
1988  *
1989  * Set binary blob value for specific key
1990  */
1991 int connman_network_set_blob(struct connman_network *network,
1992                         const char *key, const void *data, unsigned int size)
1993 {
1994         DBG("network %p key %s size %d", network, key, size);
1995
1996         if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1997                 g_free(network->wifi.ssid);
1998                 network->wifi.ssid = g_try_malloc(size);
1999                 if (network->wifi.ssid != NULL) {
2000                         memcpy(network->wifi.ssid, data, size);
2001                         network->wifi.ssid_len = size;
2002                 } else
2003                         network->wifi.ssid_len = 0;
2004         } else {
2005                 return -EINVAL;
2006         }
2007
2008         return 0;
2009 }
2010
2011 /**
2012  * connman_network_get_blob:
2013  * @network: network structure
2014  * @key: unique identifier
2015  * @size: pointer to blob size
2016  *
2017  * Get binary blob value for specific key
2018  */
2019 const void *connman_network_get_blob(struct connman_network *network,
2020                                         const char *key, unsigned int *size)
2021 {
2022         DBG("network %p key %s", network, key);
2023
2024         if (g_str_equal(key, "WiFi.SSID") == TRUE) {
2025                 if (size != NULL)
2026                         *size = network->wifi.ssid_len;
2027                 return network->wifi.ssid;
2028         }
2029
2030         return NULL;
2031 }
2032
2033 void __connman_network_set_device(struct connman_network *network,
2034                                         struct connman_device *device)
2035 {
2036         if (network->device == device)
2037                 return;
2038
2039         if (network->device != NULL)
2040                 network_remove(network);
2041
2042         network->device = device;
2043
2044         if (network->device != NULL)
2045                 network_probe(network);
2046 }
2047
2048 /**
2049  * connman_network_get_device:
2050  * @network: network structure
2051  *
2052  * Get parent device of network
2053  */
2054 struct connman_device *connman_network_get_device(struct connman_network *network)
2055 {
2056         return network->device;
2057 }
2058
2059 /**
2060  * connman_network_get_data:
2061  * @network: network structure
2062  *
2063  * Get private network data pointer
2064  */
2065 void *connman_network_get_data(struct connman_network *network)
2066 {
2067         return network->driver_data;
2068 }
2069
2070 /**
2071  * connman_network_set_data:
2072  * @network: network structure
2073  * @data: data pointer
2074  *
2075  * Set private network data pointer
2076  */
2077 void connman_network_set_data(struct connman_network *network, void *data)
2078 {
2079         network->driver_data = data;
2080 }
2081
2082 void connman_network_update(struct connman_network *network)
2083 {
2084         switch (network->type) {
2085         case CONNMAN_NETWORK_TYPE_UNKNOWN:
2086         case CONNMAN_NETWORK_TYPE_VENDOR:
2087                 return;
2088         case CONNMAN_NETWORK_TYPE_ETHERNET:
2089         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2090         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2091         case CONNMAN_NETWORK_TYPE_CELLULAR:
2092         case CONNMAN_NETWORK_TYPE_WIFI:
2093                 break;
2094         }
2095
2096         if (network->group != NULL)
2097                 __connman_service_update_from_network(network);
2098 }
2099
2100 int __connman_network_init(void)
2101 {
2102         DBG("");
2103
2104         return 0;
2105 }
2106
2107 void __connman_network_cleanup(void)
2108 {
2109         DBG("");
2110 }