src/network.c

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