src/network.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  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 static unsigned int hidden_counter = 0;
  32
  33 struct connman_network {
  34         struct connman_element element;
  35         enum connman_network_type type;
  36         connman_bool_t available;
  37         connman_bool_t connected;
  38         connman_bool_t roaming;
  39         connman_bool_t hidden;
  40         connman_uint8_t strength;
  41         connman_uint16_t frequency;
  42         char *identifier;
  43         char *address;
  44         char *name;
  45         char *node;
  46         char *group;
  47
  48         struct connman_network_driver *driver;
  49         void *driver_data;
  50
  51         connman_bool_t connecting;
  52         connman_bool_t associating;
  53
  54         struct connman_device *device;
  55
  56         struct {
  57                 void *ssid;
  58                 int ssid_len;
  59                 char *mode;
  60                 unsigned short channel;
  61                 char *security;
  62                 char *passphrase;
  63                 char *eap;
  64                 char *identity;
  65                 char *ca_cert_path;
  66                 char *client_cert_path;
  67                 char *private_key_path;
  68                 char *private_key_passphrase;
  69                 char *phase2_auth;
  70                 connman_bool_t wps;
  71                 connman_bool_t use_wps;
  72                 char *pin_wps;
  73         } wifi;
  74 };
  75
  76 static const char *type2string(enum connman_network_type type)
  77 {
  78         switch (type) {
  79         case CONNMAN_NETWORK_TYPE_UNKNOWN:
  80         case CONNMAN_NETWORK_TYPE_VENDOR:
  81                 break;
  82         case CONNMAN_NETWORK_TYPE_ETHERNET:
  83                 return "ethernet";
  84         case CONNMAN_NETWORK_TYPE_WIFI:
  85                 return "wifi";
  86         case CONNMAN_NETWORK_TYPE_WIMAX:
  87                 return "wimax";
  88         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
  89         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
  90                 return "bluetooth";
  91         case CONNMAN_NETWORK_TYPE_CELLULAR:
  92                 return "cellular";
  93         }
  94
  95         return NULL;
  96 }
  97
  98 connman_bool_t __connman_network_has_driver(struct connman_network *network)
  99 {
 100         if (network == NULL || network->driver == NULL)
 101                 return FALSE;
 102
 103         return TRUE;
 104 }
 105
 106 static GSList *driver_list = NULL;
 107
 108 static gint compare_priority(gconstpointer a, gconstpointer b)
 109 {
 110         const struct connman_network_driver *driver1 = a;
 111         const struct connman_network_driver *driver2 = b;
 112
 113         return driver2->priority - driver1->priority;
 114 }
 115
 116 /**
 117  * connman_network_driver_register:
 118  * @driver: network driver definition
 119  *
 120  * Register a new network driver
 121  *
 122  * Returns: %0 on success
 123  */
 124 int connman_network_driver_register(struct connman_network_driver *driver)
 125 {
 126         GSList *list;
 127
 128         DBG("driver %p name %s", driver, driver->name);
 129
 130         for (list = driver_list; list; list = list->next) {
 131                 struct connman_network_driver *tmp = list->data;
 132
 133                 if (tmp->type == driver->type)
 134                         return -EALREADY;
 135
 136         }
 137
 138         driver_list = g_slist_insert_sorted(driver_list, driver,
 139                                                         compare_priority);
 140
 141         return 0;
 142 }
 143
 144 /**
 145  * connman_network_driver_unregister:
 146  * @driver: network driver definition
 147  *
 148  * Remove a previously registered network driver
 149  */
 150 void connman_network_driver_unregister(struct connman_network_driver *driver)
 151 {
 152         DBG("driver %p name %s", driver, driver->name);
 153
 154         driver_list = g_slist_remove(driver_list, driver);
 155 }
 156
 157 static void network_destruct(struct connman_element *element)
 158 {
 159         struct connman_network *network = element->network;
 160
 161         DBG("element %p name %s", element, element->name);
 162
 163         g_free(network->wifi.ssid);
 164         g_free(network->wifi.mode);
 165         g_free(network->wifi.security);
 166         g_free(network->wifi.passphrase);
 167         g_free(network->wifi.eap);
 168         g_free(network->wifi.identity);
 169         g_free(network->wifi.ca_cert_path);
 170         g_free(network->wifi.client_cert_path);
 171         g_free(network->wifi.private_key_path);
 172         g_free(network->wifi.private_key_passphrase);
 173         g_free(network->wifi.phase2_auth);
 174         g_free(network->wifi.pin_wps);
 175
 176         g_free(network->group);
 177         g_free(network->node);
 178         g_free(network->name);
 179         g_free(network->address);
 180         g_free(network->identifier);
 181
 182         network->device = NULL;
 183 }
 184
 185 /**
 186  * connman_network_create:
 187  * @identifier: network identifier (for example an unqiue name)
 188  *
 189  * Allocate a new network and assign the #identifier to it.
 190  *
 191  * Returns: a newly-allocated #connman_network structure
 192  */
 193 struct connman_network *connman_network_create(const char *identifier,
 194                                                 enum connman_network_type type)
 195 {
 196         struct connman_network *network;
 197         connman_uint8_t strength = 0;
 198         const char *str;
 199         char *temp;
 200
 201         DBG("identifier %s type %d", identifier, type);
 202
 203         network = g_try_new0(struct connman_network, 1);
 204         if (network == NULL)
 205                 return NULL;
 206
 207         DBG("network %p", network);
 208
 209         __connman_element_initialize(&network->element);
 210
 211         if (identifier == NULL) {
 212                 temp = g_strdup_printf("hidden_%d", hidden_counter++);
 213                 network->hidden = TRUE;
 214         } else
 215                 temp = g_strdup(identifier);
 216
 217         if (temp == NULL) {
 218                 g_free(network);
 219                 return NULL;
 220         }
 221
 222         network->element.name = temp;
 223         network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
 224
 225         network->element.network = network;
 226         network->element.destruct = network_destruct;
 227
 228         str = type2string(type);
 229         if (str != NULL)
 230                 connman_element_set_string(&network->element, "Type", str);
 231
 232         connman_element_set_uint8(&network->element, "Strength", strength);
 233
 234         network->type       = type;
 235         network->identifier = g_strdup(temp);
 236
 237         return network;
 238 }
 239
 240 /**
 241  * connman_network_ref:
 242  * @network: network structure
 243  *
 244  * Increase reference counter of  network
 245  */
 246 struct connman_network *connman_network_ref(struct connman_network *network)
 247 {
 248         if (connman_element_ref(&network->element) == NULL)
 249                 return NULL;
 250
 251         return network;
 252 }
 253
 254 /**
 255  * connman_network_unref:
 256  * @network: network structure
 257  *
 258  * Decrease reference counter of network
 259  */
 260 void connman_network_unref(struct connman_network *network)
 261 {
 262         connman_element_unref(&network->element);
 263 }
 264
 265 const char *__connman_network_get_type(struct connman_network *network)
 266 {
 267         return type2string(network->type);
 268 }
 269
 270 /**
 271  * connman_network_get_type:
 272  * @network: network structure
 273  *
 274  * Get type of network
 275  */
 276 enum connman_network_type connman_network_get_type(struct connman_network *network)
 277 {
 278         return network->type;
 279 }
 280
 281 /**
 282  * connman_network_get_identifier:
 283  * @network: network structure
 284  *
 285  * Get identifier of network
 286  */
 287 const char *connman_network_get_identifier(struct connman_network *network)
 288 {
 289         return network->identifier;
 290 }
 291
 292 /**
 293  * connman_network_set_index:
 294  * @network: network structure
 295  * @index: index number
 296  *
 297  * Set index number of network
 298  */
 299 void connman_network_set_index(struct connman_network *network, int index)
 300 {
 301         struct connman_service *service;
 302         struct connman_ipconfig *ipconfig;
 303
 304         service = __connman_service_lookup_from_network(network);
 305         if (service == NULL)
 306                 goto done;
 307
 308         ipconfig = __connman_service_get_ip4config(service);
 309
 310         DBG("index %d service %p ip4config %p", network->element.index,
 311                 service, ipconfig);
 312
 313         if (network->element.index < 0 && ipconfig == NULL) {
 314
 315                 ipconfig = __connman_service_get_ip4config(service);
 316                 if (ipconfig == NULL)
 317                         /*
 318                          * This is needed for plugins that havent set their
 319                          * ipconfig layer yet, due to not being able to get
 320                          * a network index prior to creating a service.
 321                          */
 322                         __connman_service_create_ip4config(service, index);
 323                 else
 324                         __connman_ipconfig_set_index(ipconfig, index);
 325
 326         } else {
 327                 /* If index changed, the index of ipconfig must be reset. */
 328                 if (ipconfig == NULL)
 329                         goto done;
 330
 331                 __connman_ipconfig_set_index(ipconfig, index);
 332         }
 333
 334 done:
 335         network->element.index = index;
 336 }
 337
 338 /**
 339  * connman_network_get_index:
 340  * @network: network structure
 341  *
 342  * Get index number of network
 343  */
 344 int connman_network_get_index(struct connman_network *network)
 345 {
 346         return network->element.index;
 347 }
 348
 349 /**
 350  * connman_network_get_element:
 351  * @network: network structure
 352  *
 353  * Get connman_element of network
 354  */
 355 struct connman_element *connman_network_get_element(
 356                                 struct connman_network *network)
 357 {
 358         return &network->element;
 359 }
 360
 361 /**
 362  * connman_network_set_group:
 363  * @network: network structure
 364  * @group: group name
 365  *
 366  * Set group name for automatic clustering
 367  */
 368 void connman_network_set_group(struct connman_network *network,
 369                                                         const char *group)
 370 {
 371         switch (network->type) {
 372         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 373         case CONNMAN_NETWORK_TYPE_VENDOR:
 374                 return;
 375         case CONNMAN_NETWORK_TYPE_ETHERNET:
 376         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 377         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 378         case CONNMAN_NETWORK_TYPE_CELLULAR:
 379         case CONNMAN_NETWORK_TYPE_WIFI:
 380         case CONNMAN_NETWORK_TYPE_WIMAX:
 381                 break;
 382         }
 383
 384         if (g_strcmp0(network->group, group) == 0) {
 385                 if (group != NULL)
 386                         __connman_profile_update_network(network);
 387                 return;
 388         }
 389
 390         if (network->group != NULL) {
 391                 __connman_profile_remove_network(network);
 392
 393                 g_free(network->group);
 394         }
 395
 396         network->group = g_strdup(group);
 397
 398         if (network->group != NULL)
 399                         __connman_profile_add_network(network);
 400 }
 401
 402 /**
 403  * connman_network_get_group:
 404  * @network: network structure
 405  *
 406  * Get group name for automatic clustering
 407  */
 408 const char *connman_network_get_group(struct connman_network *network)
 409 {
 410         return network->group;
 411 }
 412
 413 const char *__connman_network_get_ident(struct connman_network *network)
 414 {
 415         if (network->device == NULL)
 416                 return NULL;
 417
 418         return connman_device_get_ident(network->device);
 419 }
 420
 421 connman_bool_t __connman_network_get_weakness(struct connman_network *network)
 422 {
 423         switch (network->type) {
 424         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 425         case CONNMAN_NETWORK_TYPE_VENDOR:
 426         case CONNMAN_NETWORK_TYPE_ETHERNET:
 427         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 428         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 429         case CONNMAN_NETWORK_TYPE_CELLULAR:
 430         case CONNMAN_NETWORK_TYPE_WIMAX:
 431                 break;
 432         case CONNMAN_NETWORK_TYPE_WIFI:
 433                 if (g_strcmp0(network->wifi.mode, "adhoc") == 0)
 434                         return TRUE;
 435                 if (network->strength > 0 && network->strength < 20)
 436                         return TRUE;
 437                 break;
 438         }
 439
 440         return FALSE;
 441 }
 442
 443 connman_bool_t __connman_network_get_connecting(struct connman_network *network)
 444 {
 445         return network->connecting;
 446 }
 447
 448 /**
 449  * connman_network_set_available:
 450  * @network: network structure
 451  * @available: availability state
 452  *
 453  * Change availability state of network (in range)
 454  */
 455 int connman_network_set_available(struct connman_network *network,
 456                                                 connman_bool_t available)
 457 {
 458         DBG("network %p available %d", network, available);
 459
 460         if (network->available == available)
 461                 return -EALREADY;
 462
 463         network->available = available;
 464
 465         return 0;
 466 }
 467
 468 /**
 469  * connman_network_get_available:
 470  * @network: network structure
 471  *
 472  * Get network available setting
 473  */
 474 connman_bool_t connman_network_get_available(struct connman_network *network)
 475 {
 476         if (network->hidden == TRUE)
 477                 return TRUE;
 478
 479         return network->available;
 480 }
 481
 482 /**
 483  * connman_network_set_associating:
 484  * @network: network structure
 485  * @associating: associating state
 486  *
 487  * Change associating state of network
 488  */
 489 int connman_network_set_associating(struct connman_network *network,
 490                                                 connman_bool_t associating)
 491 {
 492         DBG("network %p associating %d", network, associating);
 493
 494         if (network->associating == associating)
 495                 return -EALREADY;
 496
 497         network->associating = associating;
 498
 499         if (associating == TRUE) {
 500                 struct connman_service *service;
 501
 502                 service = __connman_service_lookup_from_network(network);
 503                 __connman_service_indicate_state(service,
 504                                         CONNMAN_SERVICE_STATE_ASSOCIATION);
 505         }
 506
 507         return 0;
 508 }
 509
 510 static void set_associate_error(struct connman_network *network)
 511 {
 512         struct connman_service *service;
 513
 514         if (network->associating == FALSE)
 515                 return ;
 516
 517         network->associating = FALSE;
 518
 519         service = __connman_service_lookup_from_network(network);
 520
 521         __connman_service_indicate_state(service,
 522                                         CONNMAN_SERVICE_STATE_FAILURE);
 523 }
 524
 525 static void set_configure_error(struct connman_network *network)
 526 {
 527         struct connman_service *service;
 528
 529         network->connecting = FALSE;
 530
 531         service = __connman_service_lookup_from_network(network);
 532
 533         __connman_service_indicate_state(service,
 534                                         CONNMAN_SERVICE_STATE_FAILURE);
 535 }
 536
 537 static void set_invalid_key_error(struct connman_network *network)
 538 {
 539         struct connman_service *service;
 540
 541         service = __connman_service_lookup_from_network(network);
 542
 543         __connman_service_indicate_error(service,
 544                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
 545 }
 546
 547 void connman_network_set_ipv4_method(struct connman_network *network,
 548                                         enum connman_ipconfig_method method)
 549 {
 550         struct connman_service *service;
 551         struct connman_ipconfig *ipconfig;
 552
 553         network->element.ipv4.method = method;
 554
 555         service = __connman_service_lookup_from_network(network);
 556         if (service == NULL)
 557                 return;
 558
 559         ipconfig = __connman_service_get_ip4config(service);
 560         if (ipconfig == NULL)
 561                 return;
 562
 563         connman_ipconfig_set_method(ipconfig, method);
 564 }
 565
 566 void connman_network_set_ipv6_method(struct connman_network *network,
 567                                         enum connman_ipconfig_method method)
 568 {
 569         struct connman_service *service;
 570         struct connman_ipconfig *ipconfig;
 571
 572         network->element.ipv6.method = method;
 573
 574         service = __connman_service_lookup_from_network(network);
 575         if (service == NULL)
 576                 return;
 577
 578         ipconfig = __connman_service_get_ip6config(service);
 579         if (ipconfig == NULL)
 580                 return;
 581
 582         connman_ipconfig_set_method(ipconfig, method);
 583 }
 584
 585 void connman_network_set_error(struct connman_network *network,
 586                                         enum connman_network_error error)
 587 {
 588         DBG("nework %p, error %d", network, error);
 589
 590         network->connecting = FALSE;
 591
 592         switch (error) {
 593         case CONNMAN_NETWORK_ERROR_UNKNOWN:
 594                 return;
 595         case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
 596                 set_associate_error(network);
 597                 break;
 598         case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
 599                 set_configure_error(network);
 600                 break;
 601         case CONNMAN_NETWORK_ERROR_INVALID_KEY:
 602                 set_invalid_key_error(network);
 603                 break;
 604         }
 605 }
 606
 607 void connman_network_clear_error(struct connman_network *network)
 608 {
 609         struct connman_service *service;
 610
 611         DBG("network %p", network);
 612
 613         if (network == NULL)
 614                 return;
 615
 616         if (network->connecting == TRUE || network->associating == TRUE)
 617                 return;
 618
 619         service = __connman_service_lookup_from_network(network);
 620         __connman_service_clear_error(service);
 621 }
 622
 623 static void set_configuration(struct connman_network *network)
 624 {
 625         struct connman_service *service;
 626
 627         DBG("network %p", network);
 628
 629         __connman_device_increase_connections(network->device);
 630
 631         __connman_device_set_network(network->device, network);
 632
 633         connman_device_set_disconnected(network->device, FALSE);
 634
 635         service = __connman_service_lookup_from_network(network);
 636         __connman_service_indicate_state(service,
 637                                         CONNMAN_SERVICE_STATE_CONFIGURATION);
 638 }
 639
 640 static int set_connected_fixed(struct connman_network *network)
 641 {
 642         struct connman_service *service;
 643         struct connman_element *parent, *element;
 644
 645         DBG("");
 646
 647         service = __connman_service_lookup_from_network(network);
 648
 649         parent = connman_network_get_element(network);
 650
 651         set_configuration(network);
 652
 653         if (parent->ipv4.address == NULL)
 654                 return -EINVAL;
 655
 656         if (parent->ipv4.netmask == NULL)
 657                 return -EINVAL;
 658
 659         element = connman_element_create(NULL);
 660         if (element == NULL) {
 661                 connman_error("Can not create connman_element");
 662                 return -ENOMEM;
 663         }
 664
 665         element->type = CONNMAN_ELEMENT_TYPE_IPV4;
 666         element->index = parent->index;
 667
 668         if (connman_element_register(element, parent) < 0) {
 669                 connman_error("Can not register connman_element");
 670                 return -EINVAL;
 671         }
 672
 673         network->connecting = FALSE;
 674
 675         connman_network_set_associating(network, FALSE);
 676
 677         return 0;
 678 }
 679
 680 static void set_connected_manual(struct connman_network *network)
 681 {
 682         struct connman_service *service;
 683         struct connman_ipconfig *ipconfig;
 684         const char *nameserver = NULL;
 685         int err;
 686
 687         DBG("network %p", network);
 688
 689         service = __connman_service_lookup_from_network(network);
 690
 691         ipconfig = __connman_service_get_ip4config(service);
 692
 693         set_configuration(network);
 694
 695         err = __connman_ipconfig_set_address(ipconfig);
 696         if (err < 0) {
 697                 connman_network_set_error(network,
 698                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
 699                 return;
 700         }
 701
 702         connman_element_get_value(&network->element,
 703                         CONNMAN_PROPERTY_ID_IPV4_NAMESERVER, &nameserver);
 704         if (nameserver != NULL)
 705                 __connman_service_append_nameserver(service, nameserver);
 706
 707         __connman_ipconfig_set_gateway(ipconfig, &network->element);
 708
 709         network->connecting = FALSE;
 710
 711         connman_network_set_associating(network, FALSE);
 712
 713         __connman_service_indicate_state(service, CONNMAN_SERVICE_STATE_READY);
 714 }
 715
 716 static int set_connected_dhcp(struct connman_network *network)
 717 {
 718         struct connman_element *element;
 719         int error;
 720
 721         DBG("network %p", network);
 722
 723         element = connman_element_create(NULL);
 724         if (element == NULL)
 725                 return -ENOMEM;
 726
 727         element->type  = CONNMAN_ELEMENT_TYPE_DHCP;
 728         element->index = network->element.index;
 729
 730         error = connman_element_register(element, &network->element);
 731         if (error < 0) {
 732                 connman_element_unref(element);
 733                 return error;
 734         }
 735
 736         set_configuration(network);
 737
 738         return 0;
 739 }
 740
 741 static int manual_ipv6_set(struct connman_network *network,
 742                                 struct connman_ipconfig *ipconfig_ipv6)
 743 {
 744         struct connman_service *service;
 745         int err;
 746
 747         service = __connman_service_lookup_from_network(network);
 748         if (service == NULL)
 749                 return -EINVAL;
 750
 751         err = __connman_ipconfig_set_address(ipconfig_ipv6);
 752         if (err < 0) {
 753                 connman_network_set_error(network,
 754                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
 755                 return err;
 756         }
 757
 758         /*
 759          * READY state will be indicated by IPV4 setting
 760          * gateway will be set by IPV4 setting
 761          */
 762
 763         return 0;
 764 }
 765
 766 static gboolean set_connected(gpointer user_data)
 767 {
 768         struct connman_network *network = user_data;
 769         struct connman_service *service;
 770         struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
 771         enum connman_ipconfig_method ipv4_method, ipv6_method;
 772
 773         service = __connman_service_lookup_from_network(network);
 774
 775         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 776         ipconfig_ipv6 = __connman_service_get_ip6config(service);
 777
 778         DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
 779                 ipconfig_ipv6);
 780
 781         ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
 782         ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
 783
 784         DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
 785         DBG("network connected %d", network->connected);
 786
 787         if (network->connected == TRUE) {
 788                 int ret;
 789
 790                 switch (ipv6_method) {
 791                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
 792                 case CONNMAN_IPCONFIG_METHOD_OFF:
 793                 case CONNMAN_IPCONFIG_METHOD_AUTO:
 794                         break;
 795                 case CONNMAN_IPCONFIG_METHOD_FIXED:
 796                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
 797                         ret = manual_ipv6_set(network, ipconfig_ipv6);
 798                         if (ret != 0) {
 799                                 connman_network_set_error(network,
 800                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
 801                                 return FALSE;
 802                         }
 803                         break;
 804                 case CONNMAN_IPCONFIG_METHOD_DHCP:
 805                         break;
 806                 }
 807
 808                 switch (ipv4_method) {
 809                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
 810                 case CONNMAN_IPCONFIG_METHOD_OFF:
 811                 case CONNMAN_IPCONFIG_METHOD_AUTO:
 812                         return FALSE;
 813                 case CONNMAN_IPCONFIG_METHOD_FIXED:
 814                         if (set_connected_fixed(network) < 0) {
 815                                 connman_network_set_error(network,
 816                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
 817                                 return FALSE;
 818                         }
 819                         return TRUE;
 820                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
 821                         set_connected_manual(network);
 822                         return TRUE;
 823                 case CONNMAN_IPCONFIG_METHOD_DHCP:
 824                         if (set_connected_dhcp(network) < 0) {
 825                                 connman_network_set_error(network,
 826                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
 827                                 return FALSE;
 828                         }
 829                 }
 830
 831         } else {
 832                 struct connman_service *service;
 833
 834                 connman_element_unregister_children(&network->element);
 835
 836                 __connman_device_set_network(network->device, NULL);
 837                 network->hidden = FALSE;
 838
 839                 service = __connman_service_lookup_from_network(network);
 840
 841                 __connman_service_indicate_state(service,
 842                                                 CONNMAN_SERVICE_STATE_IDLE);
 843         }
 844
 845         network->connecting = FALSE;
 846
 847         connman_network_set_associating(network, FALSE);
 848
 849         return FALSE;
 850 }
 851
 852 /**
 853  * connman_network_set_connected:
 854  * @network: network structure
 855  * @connected: connected state
 856  *
 857  * Change connected state of network
 858  */
 859 int connman_network_set_connected(struct connman_network *network,
 860                                                 connman_bool_t connected)
 861 {
 862         DBG("network %p connected %d", network, connected);
 863
 864         if ((network->connecting == TRUE || network->associating == TRUE) &&
 865                                                         connected == FALSE) {
 866                 connman_element_set_error(&network->element,
 867                                         CONNMAN_ELEMENT_ERROR_CONNECT_FAILED);
 868                 __connman_network_disconnect(network);
 869         }
 870
 871         if (network->connected == connected)
 872                 return -EALREADY;
 873
 874         if (connected == FALSE)
 875                 __connman_device_decrease_connections(network->device);
 876
 877         network->connected = connected;
 878
 879         set_connected(network);
 880
 881         return 0;
 882 }
 883
 884 /**
 885  * connman_network_get_connected:
 886  * @network: network structure
 887  *
 888  * Get network connection status
 889  */
 890 connman_bool_t connman_network_get_connected(struct connman_network *network)
 891 {
 892         return network->connected;
 893 }
 894
 895 /**
 896  * connman_network_get_associating:
 897  * @network: network structure
 898  *
 899  * Get network associating status
 900  */
 901 connman_bool_t connman_network_get_associating(struct connman_network *network)
 902 {
 903         return network->associating;
 904 }
 905
 906 /**
 907  * __connman_network_connect:
 908  * @network: network structure
 909  *
 910  * Connect network
 911  */
 912 int __connman_network_connect(struct connman_network *network)
 913 {
 914         struct connman_service *service;
 915         int err;
 916
 917         DBG("network %p", network);
 918
 919         if (network->connected == TRUE)
 920                 return -EISCONN;
 921
 922         if (network->connecting == TRUE || network->associating == TRUE)
 923                 return -EALREADY;
 924
 925         if (network->driver == NULL)
 926                 return -EUNATCH;
 927
 928         if (network->driver->connect == NULL)
 929                 return -ENOSYS;
 930
 931         if (network->device == NULL)
 932                 return -ENODEV;
 933
 934         network->connecting = TRUE;
 935
 936         __connman_device_disconnect(network->device);
 937
 938         service = __connman_service_lookup_from_network(network);
 939
 940         err = network->driver->connect(network);
 941         if (err < 0) {
 942                 if (err == -EINPROGRESS)
 943                         connman_network_set_associating(network, TRUE);
 944                 else {
 945                         network->connecting = FALSE;
 946                         network->hidden = FALSE;
 947                 }
 948
 949                 return err;
 950         }
 951
 952         network->connected = TRUE;
 953         set_connected(network);
 954
 955         return err;
 956 }
 957
 958 /**
 959  * __connman_network_disconnect:
 960  * @network: network structure
 961  *
 962  * Disconnect network
 963  */
 964 int __connman_network_disconnect(struct connman_network *network)
 965 {
 966         int err;
 967
 968         DBG("network %p", network);
 969
 970         if (network->connected == FALSE && network->connecting == FALSE &&
 971                                                 network->associating == FALSE)
 972                 return -ENOTCONN;
 973
 974         if (network->driver == NULL)
 975                 return -EUNATCH;
 976
 977         if (network->driver->disconnect == NULL)
 978                 return -ENOSYS;
 979
 980         network->connecting = FALSE;
 981
 982         err = network->driver->disconnect(network);
 983         if (err == 0) {
 984                 connman_network_set_connected(network, FALSE);
 985                 set_connected(network);
 986         }
 987
 988         return err;
 989 }
 990
 991 static int dhcp_start(struct connman_network *network)
 992 {
 993         struct connman_element *element;
 994         int error;
 995
 996         element = connman_element_create(NULL);
 997         if (element == NULL)
 998                 return -ENOMEM;
 999
1000         element->type  = CONNMAN_ELEMENT_TYPE_DHCP;
1001         element->index = network->element.index;
1002
1003         error = connman_element_register(element, &network->element);
1004         if (error < 0) {
1005                 connman_element_unref(element);
1006                 return error;
1007         }
1008
1009         return 0;
1010 }
1011
1012 static int dhcp_stop(struct connman_network *network)
1013 {
1014         connman_element_unregister_children_type(&network->element,
1015                                         CONNMAN_ELEMENT_TYPE_CONNECTION);
1016         connman_element_unregister_children_type(&network->element,
1017                                                 CONNMAN_ELEMENT_TYPE_IPV4);
1018         connman_element_unregister_children_type(&network->element,
1019                                                 CONNMAN_ELEMENT_TYPE_DHCP);
1020
1021         return 0;
1022 }
1023
1024 static int manual_ipv4_set(struct connman_network *network,
1025                                 struct connman_ipconfig *ipconfig)
1026 {
1027         struct connman_service *service;
1028         int err;
1029
1030         service = __connman_service_lookup_from_network(network);
1031         if (service == NULL)
1032                 return -EINVAL;
1033
1034         err = __connman_ipconfig_set_address(ipconfig);
1035         if (err < 0) {
1036                 connman_network_set_error(network,
1037                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1038                 return err;
1039         }
1040
1041         __connman_ipconfig_set_gateway(ipconfig, &network->element);
1042
1043         __connman_service_indicate_state(service, CONNMAN_SERVICE_STATE_READY);
1044
1045         return 0;
1046 }
1047
1048 int __connman_network_clear_ipconfig(struct connman_network *network,
1049                                         struct connman_ipconfig *ipconfig)
1050 {
1051         struct connman_service *service;
1052         enum connman_ipconfig_method method;
1053
1054         service = __connman_service_lookup_from_network(network);
1055         if (service == NULL)
1056                 return -EINVAL;
1057
1058         method = __connman_ipconfig_get_method(ipconfig);
1059
1060         switch (method) {
1061         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1062         case CONNMAN_IPCONFIG_METHOD_OFF:
1063         case CONNMAN_IPCONFIG_METHOD_FIXED:
1064         case CONNMAN_IPCONFIG_METHOD_AUTO:
1065                 return -EINVAL;
1066         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1067                 connman_element_unregister_children_type(&network->element,
1068                                         CONNMAN_ELEMENT_TYPE_CONNECTION);
1069                 __connman_ipconfig_clear_address(ipconfig);
1070                 break;
1071         case CONNMAN_IPCONFIG_METHOD_DHCP:
1072                 dhcp_stop(network);
1073                 break;
1074         }
1075
1076         __connman_service_indicate_state(service,
1077                                         CONNMAN_SERVICE_STATE_CONFIGURATION);
1078
1079         return 0;
1080 }
1081
1082 int __connman_network_set_ipconfig(struct connman_network *network,
1083                                         struct connman_ipconfig *ipconfig_ipv4,
1084                                         struct connman_ipconfig *ipconfig_ipv6)
1085 {
1086         enum connman_ipconfig_method method;
1087         int ret;
1088
1089         if (ipconfig_ipv6) {
1090                 method = __connman_ipconfig_get_method(ipconfig_ipv6);
1091
1092                 switch (method) {
1093                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1094                 case CONNMAN_IPCONFIG_METHOD_OFF:
1095                 case CONNMAN_IPCONFIG_METHOD_AUTO:
1096                         break;
1097                 case CONNMAN_IPCONFIG_METHOD_FIXED:
1098                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1099                         ret = manual_ipv6_set(network, ipconfig_ipv6);
1100                         if (ret != 0) {
1101                                 connman_network_set_error(network,
1102                                         CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1103                                 return FALSE;
1104                         }
1105                         break;
1106                 case CONNMAN_IPCONFIG_METHOD_DHCP:
1107                         break;
1108                 }
1109         }
1110
1111         if (ipconfig_ipv4) {
1112                 method = __connman_ipconfig_get_method(ipconfig_ipv4);
1113
1114                 switch (method) {
1115                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1116                 case CONNMAN_IPCONFIG_METHOD_OFF:
1117                 case CONNMAN_IPCONFIG_METHOD_FIXED:
1118                 case CONNMAN_IPCONFIG_METHOD_AUTO:
1119                         return -EINVAL;
1120                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1121                         return manual_ipv4_set(network, ipconfig_ipv4);
1122                 case CONNMAN_IPCONFIG_METHOD_DHCP:
1123                         return dhcp_start(network);
1124                 }
1125         }
1126
1127         return 0;
1128 }
1129
1130 /**
1131  * connman_network_set_address:
1132  * @network: network structure
1133  * @address: binary address value
1134  * @size: binary address length
1135  *
1136  * Set unique address value for network
1137  */
1138 int connman_network_set_address(struct connman_network *network,
1139                                 const void *address, unsigned int size)
1140 {
1141         const unsigned char *addr_octet = address;
1142         char *str;
1143
1144         DBG("network %p size %d", network, size);
1145
1146         if (size != 6)
1147                 return -EINVAL;
1148
1149         str = g_strdup_printf("%02X:%02X:%02X:%02X:%02X:%02X",
1150                                 addr_octet[0], addr_octet[1], addr_octet[2],
1151                                 addr_octet[3], addr_octet[4], addr_octet[5]);
1152         if (str == NULL)
1153                 return -ENOMEM;
1154
1155         g_free(network->address);
1156         network->address = str;
1157
1158         return connman_element_set_string(&network->element,
1159                                                 "Address", network->address);
1160 }
1161
1162 /**
1163  * connman_network_set_name:
1164  * @network: network structure
1165  * @name: name value
1166  *
1167  * Set display name value for network
1168  */
1169 int connman_network_set_name(struct connman_network *network,
1170                                                         const char *name)
1171 {
1172         DBG("network %p name %s", network, name);
1173
1174         g_free(network->name);
1175         network->name = g_strdup(name);
1176
1177         return connman_element_set_string(&network->element, "Name", name);
1178 }
1179
1180 /**
1181  * connman_network_set_strength:
1182  * @network: network structure
1183  * @strength: strength value
1184  *
1185  * Set signal strength value for network
1186  */
1187 int connman_network_set_strength(struct connman_network *network,
1188                                                 connman_uint8_t strength)
1189 {
1190         DBG("network %p strengh %d", network, strength);
1191
1192         network->strength = strength;
1193
1194         return connman_element_set_uint8(&network->element,
1195                                                 "Strength", strength);
1196 }
1197
1198 /**
1199  * connman_network_set_roaming:
1200  * @network: network structure
1201  * @roaming: roaming state
1202  *
1203  * Set roaming state for network
1204  */
1205 int connman_network_set_roaming(struct connman_network *network,
1206                                                 connman_bool_t roaming)
1207 {
1208         DBG("network %p roaming %d", network, roaming);
1209
1210         network->roaming = roaming;
1211
1212         return connman_element_set_bool(&network->element,
1213                                                 "Roaming", roaming);
1214 }
1215
1216 /**
1217  * connman_network_set_string:
1218  * @network: network structure
1219  * @key: unique identifier
1220  * @value: string value
1221  *
1222  * Set string value for specific key
1223  */
1224 int connman_network_set_string(struct connman_network *network,
1225                                         const char *key, const char *value)
1226 {
1227         int err;
1228
1229         DBG("network %p key %s value %s", network, key, value);
1230
1231         if (g_strcmp0(key, "Name") == 0)
1232                 return connman_network_set_name(network, value);
1233
1234         if (g_str_equal(key, "Address") == TRUE) {
1235                 g_free(network->address);
1236                 network->address = g_strdup(value);
1237         } else if (g_str_equal(key, "Node") == TRUE) {
1238                 g_free(network->node);
1239                 network->node = g_strdup(value);
1240         } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
1241                 g_free(network->wifi.mode);
1242                 network->wifi.mode = g_strdup(value);
1243         } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
1244                 g_free(network->wifi.security);
1245                 network->wifi.security = g_strdup(value);
1246         } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
1247                 g_free(network->wifi.passphrase);
1248                 network->wifi.passphrase = g_strdup(value);
1249         } else if (g_str_equal(key, "WiFi.EAP") == TRUE) {
1250                 g_free(network->wifi.eap);
1251                 network->wifi.eap = g_strdup(value);
1252         } else if (g_str_equal(key, "WiFi.Identity") == TRUE) {
1253                 g_free(network->wifi.identity);
1254                 network->wifi.identity = g_strdup(value);
1255         } else if (g_str_equal(key, "WiFi.CACertFile") == TRUE) {
1256                 g_free(network->wifi.ca_cert_path);
1257                 network->wifi.ca_cert_path = g_strdup(value);
1258         } else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE) {
1259                 g_free(network->wifi.client_cert_path);
1260                 network->wifi.client_cert_path = g_strdup(value);
1261         } else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE) {
1262                 g_free(network->wifi.private_key_path);
1263                 network->wifi.private_key_path = g_strdup(value);
1264         } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE) {
1265                 g_free(network->wifi.private_key_passphrase);
1266                 network->wifi.private_key_passphrase = g_strdup(value);
1267         } else if (g_str_equal(key, "WiFi.Phase2") == TRUE) {
1268                 g_free(network->wifi.phase2_auth);
1269                 network->wifi.phase2_auth = g_strdup(value);
1270         } else if (g_str_equal(key, "WiFi.PinWPS") == TRUE) {
1271                 g_free(network->wifi.pin_wps);
1272                 network->wifi.pin_wps = g_strdup(value);
1273         }
1274
1275         err = connman_element_set_string(&network->element, key, value);
1276         if (err < 0)
1277                 return err;
1278
1279         if (network->driver == NULL)
1280                 return 0;
1281
1282         if (network->driver->setup)
1283                 return network->driver->setup(network, key);
1284
1285         return 0;
1286 }
1287
1288 /**
1289  * connman_network_get_string:
1290  * @network: network structure
1291  * @key: unique identifier
1292  *
1293  * Get string value for specific key
1294  */
1295 const char *connman_network_get_string(struct connman_network *network,
1296                                                         const char *key)
1297 {
1298         DBG("network %p key %s", network, key);
1299
1300         if (g_str_equal(key, "Address") == TRUE)
1301                 return network->address;
1302         else if (g_str_equal(key, "Name") == TRUE)
1303                 return network->name;
1304         else if (g_str_equal(key, "Node") == TRUE)
1305                 return network->node;
1306         else if (g_str_equal(key, "WiFi.Mode") == TRUE)
1307                 return network->wifi.mode;
1308         else if (g_str_equal(key, "WiFi.Security") == TRUE)
1309                 return network->wifi.security;
1310         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
1311                 return network->wifi.passphrase;
1312         else if (g_str_equal(key, "WiFi.EAP") == TRUE)
1313                 return network->wifi.eap;
1314         else if (g_str_equal(key, "WiFi.Identity") == TRUE)
1315                 return network->wifi.identity;
1316         else if (g_str_equal(key, "WiFi.CACertFile") == TRUE)
1317                 return network->wifi.ca_cert_path;
1318         else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE)
1319                 return network->wifi.client_cert_path;
1320         else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE)
1321                 return network->wifi.private_key_path;
1322         else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE)
1323                 return network->wifi.private_key_passphrase;
1324         else if (g_str_equal(key, "WiFi.Phase2") == TRUE)
1325                 return network->wifi.phase2_auth;
1326         else if (g_str_equal(key, "WiFi.PinWPS") == TRUE)
1327                 return network->wifi.pin_wps;
1328
1329         return connman_element_get_string(&network->element, key);
1330 }
1331
1332 /**
1333  * connman_network_set_bool:
1334  * @network: network structure
1335  * @key: unique identifier
1336  * @value: boolean value
1337  *
1338  * Set boolean value for specific key
1339  */
1340 int connman_network_set_bool(struct connman_network *network,
1341                                         const char *key, connman_bool_t value)
1342 {
1343         DBG("network %p key %s value %d", network, key, value);
1344
1345         if (g_strcmp0(key, "Roaming") == 0)
1346                 return connman_network_set_roaming(network, value);
1347         else if (g_strcmp0(key, "WiFi.WPS") == 0)
1348                 network->wifi.wps = value;
1349         else if (g_strcmp0(key, "WiFi.UseWPS") == 0)
1350                 network->wifi.use_wps = value;
1351
1352         return connman_element_set_bool(&network->element, key, value);
1353 }
1354
1355 /**
1356  * connman_network_get_bool:
1357  * @network: network structure
1358  * @key: unique identifier
1359  *
1360  * Get boolean value for specific key
1361  */
1362 connman_bool_t connman_network_get_bool(struct connman_network *network,
1363                                                         const char *key)
1364 {
1365         DBG("network %p key %s", network, key);
1366
1367         if (g_str_equal(key, "Roaming") == TRUE)
1368                 return network->roaming;
1369         else if (g_str_equal(key, "WiFi.WPS") == TRUE)
1370                 return network->wifi.wps;
1371         else if (g_str_equal(key, "WiFi.UseWPS") == TRUE)
1372                 return network->wifi.use_wps;
1373
1374         return connman_element_get_bool(&network->element, key);
1375 }
1376
1377 /**
1378  * connman_network_set_uint8:
1379  * @network: network structure
1380  * @key: unique identifier
1381  * @value: integer value
1382  *
1383  * Set integer value for specific key
1384  */
1385 int connman_network_set_uint8(struct connman_network *network,
1386                                         const char *key, connman_uint8_t value)
1387 {
1388         DBG("network %p key %s value %d", network, key, value);
1389
1390         if (g_strcmp0(key, "Strength") == 0)
1391                 return connman_network_set_strength(network, value);
1392
1393         return connman_element_set_uint8(&network->element, key, value);
1394 }
1395
1396 /**
1397  * connman_network_get_uint8:
1398  * @network: network structure
1399  * @key: unique identifier
1400  *
1401  * Get integer value for specific key
1402  */
1403 connman_uint8_t connman_network_get_uint8(struct connman_network *network,
1404                                                         const char *key)
1405 {
1406         DBG("network %p key %s", network, key);
1407
1408         if (g_str_equal(key, "Strength") == TRUE)
1409                 return network->strength;
1410
1411         return connman_element_get_uint8(&network->element, key);
1412 }
1413
1414 /**
1415  * connman_network_set_uint16:
1416  * @network: network structure
1417  * @key: unique identifier
1418  * @value: integer value
1419  *
1420  * Set integer value for specific key
1421  */
1422 int connman_network_set_uint16(struct connman_network *network,
1423                                 const char *key, connman_uint16_t value)
1424 {
1425         DBG("network %p key %s value %d", network, key, value);
1426
1427         if (g_str_equal(key, "Frequency") == TRUE)
1428                 network->frequency = value;
1429         else if (g_str_equal(key, "WiFi.Channel") == TRUE)
1430                 network->wifi.channel = value;
1431
1432         return -EINVAL;
1433 }
1434
1435 /**
1436  * connman_network_get_uint16:
1437  * @network: network structure
1438  * @key: unique identifier
1439  *
1440  * Get integer value for specific key
1441  */
1442 connman_uint16_t connman_network_get_uint16(struct connman_network *network,
1443                                                         const char *key)
1444 {
1445         DBG("network %p key %s", network, key);
1446
1447         if (g_str_equal(key, "Frequency") == TRUE)
1448                 return network->frequency;
1449         else if (g_str_equal(key, "WiFi.Channel") == TRUE)
1450                 return network->wifi.channel;
1451
1452         return 0;
1453 }
1454
1455 /**
1456  * connman_network_set_blob:
1457  * @network: network structure
1458  * @key: unique identifier
1459  * @data: blob data
1460  * @size: blob size
1461  *
1462  * Set binary blob value for specific key
1463  */
1464 int connman_network_set_blob(struct connman_network *network,
1465                         const char *key, const void *data, unsigned int size)
1466 {
1467         DBG("network %p key %s size %d", network, key, size);
1468
1469         if (g_strcmp0(key, "Address") == 0)
1470                 return connman_network_set_address(network, data, size);
1471
1472         if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1473                 g_free(network->wifi.ssid);
1474                 network->wifi.ssid = g_try_malloc(size);
1475                 if (network->wifi.ssid != NULL) {
1476                         memcpy(network->wifi.ssid, data, size);
1477                         network->wifi.ssid_len = size;
1478                 } else
1479                         network->wifi.ssid_len = 0;
1480         }
1481
1482         return connman_element_set_blob(&network->element, key, data, size);
1483 }
1484
1485 /**
1486  * connman_network_get_blob:
1487  * @network: network structure
1488  * @key: unique identifier
1489  * @size: pointer to blob size
1490  *
1491  * Get binary blob value for specific key
1492  */
1493 const void *connman_network_get_blob(struct connman_network *network,
1494                                         const char *key, unsigned int *size)
1495 {
1496         DBG("network %p key %s", network, key);
1497
1498         if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1499                 if (size != NULL)
1500                         *size = network->wifi.ssid_len;
1501                 return network->wifi.ssid;
1502         }
1503
1504         return connman_element_get_blob(&network->element, key, size);
1505 }
1506
1507 void __connman_network_set_device(struct connman_network *network,
1508                                         struct connman_device *device)
1509 {
1510         network->device = device;
1511 }
1512
1513 /**
1514  * connman_network_get_device:
1515  * @network: network structure
1516  *
1517  * Get parent device of network
1518  */
1519 struct connman_device *connman_network_get_device(struct connman_network *network)
1520 {
1521         return network->device;
1522 }
1523
1524 /**
1525  * connman_network_get_data:
1526  * @network: network structure
1527  *
1528  * Get private network data pointer
1529  */
1530 void *connman_network_get_data(struct connman_network *network)
1531 {
1532         return network->driver_data;
1533 }
1534
1535 /**
1536  * connman_network_set_data:
1537  * @network: network structure
1538  * @data: data pointer
1539  *
1540  * Set private network data pointer
1541  */
1542 void connman_network_set_data(struct connman_network *network, void *data)
1543 {
1544         network->driver_data = data;
1545 }
1546
1547 void connman_network_update(struct connman_network *network)
1548 {
1549         switch (network->type) {
1550         case CONNMAN_NETWORK_TYPE_UNKNOWN:
1551         case CONNMAN_NETWORK_TYPE_VENDOR:
1552                 return;
1553         case CONNMAN_NETWORK_TYPE_ETHERNET:
1554         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1555         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1556         case CONNMAN_NETWORK_TYPE_CELLULAR:
1557         case CONNMAN_NETWORK_TYPE_WIFI:
1558         case CONNMAN_NETWORK_TYPE_WIMAX:
1559                 break;
1560         }
1561
1562         if (network->group != NULL)
1563                 __connman_service_update_from_network(network);
1564
1565         return;
1566 }
1567
1568 static gboolean match_driver(struct connman_network *network,
1569                                         struct connman_network_driver *driver)
1570 {
1571         if (network->type == driver->type ||
1572                         driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
1573                 return TRUE;
1574
1575         return FALSE;
1576 }
1577
1578 static int network_probe(struct connman_element *element)
1579 {
1580         struct connman_network *network = element->network;
1581         GSList *list;
1582
1583         DBG("element %p name %s", element, element->name);
1584
1585         if (network == NULL)
1586                 return -ENODEV;
1587
1588         for (list = driver_list; list; list = list->next) {
1589                 struct connman_network_driver *driver = list->data;
1590
1591                 if (match_driver(network, driver) == FALSE)
1592                         continue;
1593
1594                 DBG("driver %p name %s", driver, driver->name);
1595
1596                 if (driver->probe(network) == 0) {
1597                         network->driver = driver;
1598                         break;
1599                 }
1600         }
1601
1602         if (network->driver == NULL)
1603                 return -ENODEV;
1604
1605         switch (network->type) {
1606         case CONNMAN_NETWORK_TYPE_UNKNOWN:
1607         case CONNMAN_NETWORK_TYPE_VENDOR:
1608                 break;
1609         case CONNMAN_NETWORK_TYPE_ETHERNET:
1610         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1611         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1612         case CONNMAN_NETWORK_TYPE_CELLULAR:
1613         case CONNMAN_NETWORK_TYPE_WIFI:
1614         case CONNMAN_NETWORK_TYPE_WIMAX:
1615                 if (network->group != NULL)
1616                         __connman_profile_add_network(network);
1617                 break;
1618         }
1619
1620         return 0;
1621 }
1622
1623 static void network_remove(struct connman_element *element)
1624 {
1625         struct connman_network *network = element->network;
1626
1627         DBG("element %p name %s", element, element->name);
1628
1629         if (network == NULL)
1630                 return;
1631
1632         if (network->driver == NULL)
1633                 return;
1634
1635         switch (network->type) {
1636         case CONNMAN_NETWORK_TYPE_UNKNOWN:
1637         case CONNMAN_NETWORK_TYPE_VENDOR:
1638                 break;
1639         case CONNMAN_NETWORK_TYPE_ETHERNET:
1640         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1641         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1642         case CONNMAN_NETWORK_TYPE_CELLULAR:
1643         case CONNMAN_NETWORK_TYPE_WIFI:
1644         case CONNMAN_NETWORK_TYPE_WIMAX:
1645                 if (network->group != NULL) {
1646                         __connman_profile_remove_network(network);
1647
1648                         g_free(network->group);
1649                         network->group = NULL;
1650                 }
1651                 break;
1652         }
1653
1654         if (network->driver->remove)
1655                 network->driver->remove(network);
1656 }
1657
1658 static void network_change(struct connman_element *element)
1659 {
1660         struct connman_network *network = element->network;
1661
1662         DBG("element %p name %s", element, element->name);
1663
1664         if (element->state != CONNMAN_ELEMENT_STATE_ERROR)
1665                 return;
1666
1667         if (element->error != CONNMAN_ELEMENT_ERROR_DHCP_FAILED)
1668                 return;
1669
1670         if (network->connected == FALSE)
1671                 return;
1672
1673         connman_element_unregister_children(element);
1674
1675         connman_device_set_disconnected(network->device, TRUE);
1676
1677         if (network->driver && network->driver->disconnect) {
1678                 network->driver->disconnect(network);
1679                 return;
1680         }
1681
1682         network->connected = FALSE;
1683 }
1684
1685 static struct connman_driver network_driver = {
1686         .name           = "network",
1687         .type           = CONNMAN_ELEMENT_TYPE_NETWORK,
1688         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
1689         .probe          = network_probe,
1690         .remove         = network_remove,
1691         .change         = network_change,
1692 };
1693
1694 int __connman_network_init(void)
1695 {
1696         DBG("");
1697
1698         return connman_driver_register(&network_driver);
1699 }
1700
1701 void __connman_network_cleanup(void)
1702 {
1703         DBG("");
1704
1705         connman_driver_unregister(&network_driver);
1706 }