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_service_ipconfig_indicate_state(service,
1316                                                         CONNMAN_SERVICE_STATE_IDLE,
1317                                                         CONNMAN_IPCONFIG_TYPE_IPV4);
1318
1319                 __connman_service_ipconfig_indicate_state(service,
1320                                                         CONNMAN_SERVICE_STATE_IDLE,
1321                                                         CONNMAN_IPCONFIG_TYPE_IPV6);
1322         }
1323
1324         return FALSE;
1325 }
1326 #endif
1327
1328 /**
1329  * connman_network_set_associating:
1330  * @network: network structure
1331  * @associating: associating state
1332  *
1333  * Change associating state of network
1334  */
1335 int connman_network_set_associating(struct connman_network *network,
1336                                                 bool associating)
1337 {
1338         DBG("network %p associating %d", network, associating);
1339
1340         if (network->associating == associating)
1341                 return -EALREADY;
1342
1343         network->associating = associating;
1344
1345         if (associating) {
1346                 struct connman_service *service;
1347
1348                 service = connman_service_lookup_from_network(network);
1349                 __connman_service_ipconfig_indicate_state(service,
1350                                         CONNMAN_SERVICE_STATE_ASSOCIATION,
1351                                         CONNMAN_IPCONFIG_TYPE_IPV4);
1352                 __connman_service_ipconfig_indicate_state(service,
1353                                         CONNMAN_SERVICE_STATE_ASSOCIATION,
1354                                         CONNMAN_IPCONFIG_TYPE_IPV6);
1355         }
1356
1357 #if defined TIZEN_EXT
1358         if (associating == FALSE)
1359                 g_timeout_add_seconds(1,
1360                                 __connman_network_clear_associating_delayed,
1361                                 network);
1362 #endif
1363
1364         return 0;
1365 }
1366
1367 static void set_associate_error(struct connman_network *network)
1368 {
1369         struct connman_service *service;
1370
1371         service = connman_service_lookup_from_network(network);
1372
1373         __connman_service_indicate_error(service,
1374                                         CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
1375 }
1376
1377 static void set_configure_error(struct connman_network *network)
1378 {
1379         struct connman_service *service;
1380
1381         service = connman_service_lookup_from_network(network);
1382
1383         __connman_service_indicate_error(service,
1384                                         CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
1385 }
1386
1387 static void set_invalid_key_error(struct connman_network *network)
1388 {
1389         struct connman_service *service;
1390
1391         service = connman_service_lookup_from_network(network);
1392
1393         __connman_service_indicate_error(service,
1394                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
1395 }
1396
1397 static void set_connect_error(struct connman_network *network)
1398 {
1399         struct connman_service *service;
1400
1401         service = connman_service_lookup_from_network(network);
1402
1403         __connman_service_indicate_error(service,
1404                                         CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
1405 }
1406
1407 void connman_network_set_ipv4_method(struct connman_network *network,
1408                                         enum connman_ipconfig_method method)
1409 {
1410         struct connman_service *service;
1411         struct connman_ipconfig *ipconfig;
1412
1413         service = connman_service_lookup_from_network(network);
1414         if (!service)
1415                 return;
1416
1417         ipconfig = __connman_service_get_ip4config(service);
1418         if (!ipconfig)
1419                 return;
1420
1421         __connman_ipconfig_set_method(ipconfig, method);
1422 }
1423
1424 void connman_network_set_ipv6_method(struct connman_network *network,
1425                                         enum connman_ipconfig_method method)
1426 {
1427         struct connman_service *service;
1428         struct connman_ipconfig *ipconfig;
1429
1430         service = connman_service_lookup_from_network(network);
1431         if (!service)
1432                 return;
1433
1434         ipconfig = __connman_service_get_ip6config(service);
1435         if (!ipconfig)
1436                 return;
1437
1438         __connman_ipconfig_set_method(ipconfig, method);
1439 }
1440
1441 void connman_network_set_error(struct connman_network *network,
1442                                         enum connman_network_error error)
1443 {
1444         DBG("network %p error %d", network, error);
1445
1446         network->connecting = false;
1447         network->associating = false;
1448
1449         switch (error) {
1450         case CONNMAN_NETWORK_ERROR_UNKNOWN:
1451                 return;
1452         case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
1453                 set_associate_error(network);
1454                 break;
1455         case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
1456                 set_configure_error(network);
1457                 break;
1458         case CONNMAN_NETWORK_ERROR_INVALID_KEY:
1459                 set_invalid_key_error(network);
1460                 break;
1461         case CONNMAN_NETWORK_ERROR_CONNECT_FAIL:
1462                 set_connect_error(network);
1463                 break;
1464         }
1465
1466         network_change(network);
1467 }
1468
1469 /**
1470  * connman_network_set_connected:
1471  * @network: network structure
1472  * @connected: connected state
1473  *
1474  * Change connected state of network
1475  */
1476 int connman_network_set_connected(struct connman_network *network,
1477                                                 bool connected)
1478 {
1479         DBG("network %p connected %d/%d connecting %d associating %d",
1480                 network, network->connected, connected, network->connecting,
1481                 network->associating);
1482
1483         if ((network->connecting || network->associating) &&
1484                                                         !connected) {
1485                 connman_network_set_error(network,
1486                                         CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
1487                 if (__connman_network_disconnect(network) == 0)
1488                         return 0;
1489         }
1490
1491         if (network->connected == connected)
1492                 return -EALREADY;
1493
1494         if (!connected)
1495                 set_disconnected(network);
1496         else
1497                 set_connected(network);
1498
1499         return 0;
1500 }
1501
1502 /**
1503  * connman_network_get_connected:
1504  * @network: network structure
1505  *
1506  * Get network connection status
1507  */
1508 bool connman_network_get_connected(struct connman_network *network)
1509 {
1510         return network->connected;
1511 }
1512
1513 /**
1514  * connman_network_get_associating:
1515  * @network: network structure
1516  *
1517  * Get network associating status
1518  */
1519 bool connman_network_get_associating(struct connman_network *network)
1520 {
1521         return network->associating;
1522 }
1523
1524 void connman_network_clear_hidden(void *user_data)
1525 {
1526         if (!user_data)
1527                 return;
1528
1529         DBG("user_data %p", user_data);
1530
1531         /*
1532          * Hidden service does not have a connect timeout so
1533          * we do not need to remove it. We can just return
1534          * error to the caller telling that we could not find
1535          * any network that we could connect to.
1536          */
1537         connman_dbus_reply_pending(user_data, EIO, NULL);
1538 }
1539
1540 int connman_network_connect_hidden(struct connman_network *network,
1541                         char *identity, char *passphrase, void *user_data)
1542 {
1543         int err = 0;
1544         struct connman_service *service;
1545
1546         service = connman_service_lookup_from_network(network);
1547
1548         DBG("network %p service %p user_data %p", network, service, user_data);
1549
1550         if (!service)
1551                 return -EINVAL;
1552
1553         if (identity)
1554                 __connman_service_set_agent_identity(service, identity);
1555
1556         if (passphrase)
1557                 err = __connman_service_set_passphrase(service, passphrase);
1558
1559         if (err == -ENOKEY) {
1560                 __connman_service_indicate_error(service,
1561                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
1562                 goto out;
1563         } else {
1564                 __connman_service_set_hidden(service);
1565                 __connman_service_set_hidden_data(service, user_data);
1566                 return __connman_service_connect(service,
1567                                         CONNMAN_SERVICE_CONNECT_REASON_USER);
1568         }
1569
1570 out:
1571         __connman_service_return_error(service, -err, user_data);
1572         return err;
1573 }
1574
1575 /**
1576  * __connman_network_connect:
1577  * @network: network structure
1578  *
1579  * Connect network
1580  */
1581 int __connman_network_connect(struct connman_network *network)
1582 {
1583         int err;
1584
1585         DBG("network %p", network);
1586
1587         if (network->connected)
1588                 return -EISCONN;
1589
1590         if (network->connecting || network->associating)
1591                 return -EALREADY;
1592
1593         if (!network->driver)
1594                 return -EUNATCH;
1595
1596         if (!network->driver->connect)
1597                 return -ENOSYS;
1598
1599         if (!network->device)
1600                 return -ENODEV;
1601
1602         network->connecting = true;
1603
1604 #if defined TIZEN_EXT
1605         if (network->type != CONNMAN_NETWORK_TYPE_CELLULAR)
1606 #endif
1607         __connman_device_disconnect(network->device);
1608
1609         err = network->driver->connect(network);
1610         if (err < 0) {
1611                 if (err == -EINPROGRESS) {
1612 #if defined TIZEN_EXT
1613                         if (network->type != CONNMAN_NETWORK_TYPE_CELLULAR)
1614 #endif
1615                         connman_network_set_associating(network, true);
1616                 } else
1617                         network->connecting = false;
1618
1619                 return err;
1620         }
1621
1622         set_connected(network);
1623
1624         return err;
1625 }
1626
1627 /**
1628  * __connman_network_disconnect:
1629  * @network: network structure
1630  *
1631  * Disconnect network
1632  */
1633 int __connman_network_disconnect(struct connman_network *network)
1634 {
1635         int err = 0;
1636
1637         DBG("network %p", network);
1638
1639         if (!network->connected && !network->connecting &&
1640                                                 !network->associating)
1641                 return -ENOTCONN;
1642
1643         if (!network->driver)
1644                 return -EUNATCH;
1645
1646         network->connecting = false;
1647
1648         if (network->driver->disconnect)
1649                 err = network->driver->disconnect(network);
1650
1651         if (err != -EINPROGRESS)
1652                 set_disconnected(network);
1653
1654         return err;
1655 }
1656
1657 int __connman_network_clear_ipconfig(struct connman_network *network,
1658                                         struct connman_ipconfig *ipconfig)
1659 {
1660         struct connman_service *service;
1661         struct connman_ipconfig *ipconfig_ipv4;
1662         enum connman_ipconfig_method method;
1663         enum connman_ipconfig_type type;
1664
1665         service = connman_service_lookup_from_network(network);
1666         if (!service)
1667                 return -EINVAL;
1668
1669         ipconfig_ipv4 = __connman_service_get_ip4config(service);
1670         method = __connman_ipconfig_get_method(ipconfig);
1671         type = __connman_ipconfig_get_config_type(ipconfig);
1672
1673         switch (method) {
1674         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1675         case CONNMAN_IPCONFIG_METHOD_OFF:
1676         case CONNMAN_IPCONFIG_METHOD_FIXED:
1677                 return -EINVAL;
1678         case CONNMAN_IPCONFIG_METHOD_AUTO:
1679                 release_dhcpv6(network);
1680                 break;
1681         case CONNMAN_IPCONFIG_METHOD_MANUAL:
1682                 __connman_ipconfig_address_remove(ipconfig);
1683                 break;
1684         case CONNMAN_IPCONFIG_METHOD_DHCP:
1685                 __connman_dhcp_stop(ipconfig_ipv4);
1686                 break;
1687         }
1688
1689         if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1690                 __connman_service_ipconfig_indicate_state(service,
1691                                         CONNMAN_SERVICE_STATE_CONFIGURATION,
1692                                         CONNMAN_IPCONFIG_TYPE_IPV6);
1693         else if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1694                 __connman_service_ipconfig_indicate_state(service,
1695                                         CONNMAN_SERVICE_STATE_CONFIGURATION,
1696                                         CONNMAN_IPCONFIG_TYPE_IPV4);
1697
1698         return 0;
1699 }
1700
1701 int __connman_network_enable_ipconfig(struct connman_network *network,
1702                                 struct connman_ipconfig *ipconfig)
1703 {
1704         int r = 0;
1705         enum connman_ipconfig_type type;
1706         enum connman_ipconfig_method method;
1707 #if defined TIZEN_EXT
1708         struct connman_service *service;
1709 #endif
1710
1711         if (!network || !ipconfig)
1712                 return -EINVAL;
1713
1714         type = __connman_ipconfig_get_config_type(ipconfig);
1715
1716         switch (type) {
1717         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
1718         case CONNMAN_IPCONFIG_TYPE_ALL:
1719                 return -ENOSYS;
1720
1721         case CONNMAN_IPCONFIG_TYPE_IPV6:
1722                 set_configuration(network, type);
1723
1724                 method = __connman_ipconfig_get_method(ipconfig);
1725
1726                 DBG("ipv6 ipconfig method %d", method);
1727
1728                 switch (method) {
1729                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1730                         break;
1731
1732                 case CONNMAN_IPCONFIG_METHOD_OFF:
1733                         __connman_ipconfig_disable_ipv6(ipconfig);
1734                         break;
1735
1736                 case CONNMAN_IPCONFIG_METHOD_AUTO:
1737 #if defined TIZEN_EXT
1738                 service = connman_service_lookup_from_network(network);
1739
1740                 if(network->type == CONNMAN_NETWORK_TYPE_CELLULAR)
1741                         __connman_service_ipconfig_indicate_state(service,
1742                                 CONNMAN_SERVICE_STATE_CONFIGURATION,
1743                                         CONNMAN_IPCONFIG_TYPE_IPV6);
1744 #endif
1745                         autoconf_ipv6_set(network);
1746                         break;
1747
1748                 case CONNMAN_IPCONFIG_METHOD_FIXED:
1749                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1750                         r = manual_ipv6_set(network, ipconfig);
1751                         break;
1752
1753                 case CONNMAN_IPCONFIG_METHOD_DHCP:
1754                         r = -ENOSYS;
1755                         break;
1756                 }
1757
1758                 break;
1759
1760         case CONNMAN_IPCONFIG_TYPE_IPV4:
1761                 set_configuration(network, type);
1762
1763                 method = __connman_ipconfig_get_method(ipconfig);
1764
1765                 DBG("ipv4 ipconfig method %d", method);
1766
1767                 switch (method) {
1768                 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1769                 case CONNMAN_IPCONFIG_METHOD_OFF:
1770                         break;
1771
1772                 case CONNMAN_IPCONFIG_METHOD_AUTO:
1773                         r = -ENOSYS;
1774                         break;
1775
1776                 case CONNMAN_IPCONFIG_METHOD_FIXED:
1777                 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1778                         r = set_connected_manual(network);
1779                         break;
1780
1781                 case CONNMAN_IPCONFIG_METHOD_DHCP:
1782                         r = set_connected_dhcp(network);
1783                         break;
1784                 }
1785
1786                 break;
1787         }
1788
1789         if (r < 0)
1790                 connman_network_set_error(network,
1791                                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1792
1793         return r;
1794 }
1795
1796 int connman_network_set_ipaddress(struct connman_network *network,
1797                                         struct connman_ipaddress *ipaddress)
1798 {
1799         struct connman_service *service;
1800         struct connman_ipconfig *ipconfig = NULL;
1801
1802         DBG("network %p", network);
1803
1804         service = connman_service_lookup_from_network(network);
1805         if (!service)
1806                 return -EINVAL;
1807
1808         ipconfig = __connman_service_get_ipconfig(service, ipaddress->family);
1809         if (!ipconfig)
1810                 return -EINVAL;
1811
1812         __connman_ipconfig_set_local(ipconfig, ipaddress->local);
1813         __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
1814         __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
1815         __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
1816         __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
1817
1818         return 0;
1819 }
1820
1821 #if defined TIZEN_EXT
1822 /*
1823  * Description: Network client requires additional wifi specific info
1824  */
1825 int connman_network_set_bssid(struct connman_network *network,
1826                                 const unsigned char *bssid)
1827 {
1828         int i = 0;
1829
1830         if (bssid == NULL)
1831                 return -EINVAL;
1832
1833         DBG("network %p bssid %02x:%02x:%02x:%02x:%02x:%02x", network,
1834                         bssid[0], bssid[1], bssid[2],
1835                         bssid[3], bssid[4], bssid[5]);
1836
1837         for (;i < WIFI_BSSID_LEN_MAX;i++)
1838                 network->wifi.bssid[i] = bssid[i];
1839
1840         return 0;
1841 }
1842
1843 unsigned char *connman_network_get_bssid(struct connman_network *network)
1844 {
1845         return (unsigned char *)network->wifi.bssid;
1846 }
1847
1848 int connman_network_set_maxrate(struct connman_network *network,
1849                                 unsigned int maxrate)
1850 {
1851 #if !defined TIZEN_EXT
1852         DBG("network %p maxrate %d", network, maxrate);
1853 #endif
1854
1855         network->wifi.maxrate = maxrate;
1856
1857         return 0;
1858 }
1859
1860 unsigned int connman_network_get_maxrate(struct connman_network *network)
1861 {
1862         return network->wifi.maxrate;
1863 }
1864
1865 int connman_network_set_enc_mode(struct connman_network *network,
1866                                 const char *encryption_mode)
1867 {
1868         if (encryption_mode == NULL)
1869                 return -EINVAL;
1870
1871         DBG("network %p encryption mode %s", network, encryption_mode);
1872
1873         g_strlcpy(network->wifi.encryption_mode, encryption_mode,
1874                                         WIFI_ENCYPTION_MODE_LEN_MAX);
1875
1876         return 0;
1877 }
1878
1879 const char *connman_network_get_enc_mode(struct connman_network *network)
1880 {
1881         return (const char *)network->wifi.encryption_mode;
1882 }
1883
1884 int connman_network_set_proxy(struct connman_network *network,
1885                                 const char *proxies)
1886 {
1887         struct connman_service *service;
1888
1889         DBG("network %p proxies %s", network, proxies);
1890
1891         service = connman_service_lookup_from_network(network);
1892         if (service == NULL)
1893                 return -EINVAL;
1894
1895         __connman_service_set_proxy(service, proxies);
1896
1897         connman_service_set_proxy_method(service,
1898                                 CONNMAN_SERVICE_PROXY_METHOD_MANUAL);
1899
1900         return 0;
1901 }
1902
1903 int connman_network_set_is_hs20AP(struct connman_network *network,
1904                                 unsigned int isHS20AP)
1905 {
1906         if (!network)
1907                 return 0;
1908
1909         network->wifi.isHS20AP = isHS20AP;
1910
1911         return 0;
1912 }
1913
1914 unsigned int connman_network_get_is_hs20AP(struct connman_network *network)
1915 {
1916         if (!network)
1917                 return 0;
1918
1919         return network->wifi.isHS20AP;
1920 }
1921 #endif
1922
1923 int connman_network_set_nameservers(struct connman_network *network,
1924                                 const char *nameservers)
1925 {
1926         struct connman_service *service;
1927         char **nameservers_array;
1928         int i;
1929
1930         DBG("network %p nameservers %s", network, nameservers);
1931
1932         service = connman_service_lookup_from_network(network);
1933         if (!service)
1934                 return -EINVAL;
1935
1936         __connman_service_nameserver_clear(service);
1937
1938         if (!nameservers)
1939                 return 0;
1940
1941         nameservers_array = g_strsplit(nameservers, " ", 0);
1942
1943         for (i = 0; nameservers_array[i]; i++) {
1944                 __connman_service_nameserver_append(service,
1945                                                 nameservers_array[i], false);
1946         }
1947
1948         g_strfreev(nameservers_array);
1949
1950         return 0;
1951 }
1952
1953 int connman_network_set_domain(struct connman_network *network,
1954                                 const char *domain)
1955 {
1956         struct connman_service *service;
1957
1958         DBG("network %p domain %s", network, domain);
1959
1960         service = connman_service_lookup_from_network(network);
1961         if (!service)
1962                 return -EINVAL;
1963
1964         __connman_service_set_domainname(service, domain);
1965
1966         return 0;
1967 }
1968
1969 /**
1970  * connman_network_set_name:
1971  * @network: network structure
1972  * @name: name value
1973  *
1974  * Set display name value for network
1975  */
1976 int connman_network_set_name(struct connman_network *network,
1977                                                         const char *name)
1978 {
1979         DBG("network %p name %s", network, name);
1980
1981         g_free(network->name);
1982         network->name = g_strdup(name);
1983
1984         return 0;
1985 }
1986
1987 /**
1988  * connman_network_set_strength:
1989  * @network: network structure
1990  * @strength: strength value
1991  *
1992  * Set signal strength value for network
1993  */
1994
1995 int connman_network_set_strength(struct connman_network *network,
1996                                                 uint8_t strength)
1997 {
1998 #if !defined TIZEN_EXT
1999         DBG("network %p strengh %d", network, strength);
2000 #endif
2001
2002         network->strength = strength;
2003
2004         return 0;
2005 }
2006
2007 uint8_t connman_network_get_strength(struct connman_network *network)
2008 {
2009         return network->strength;
2010 }
2011
2012 int connman_network_set_frequency(struct connman_network *network,
2013                                                 uint16_t frequency)
2014 {
2015 #if !defined TIZEN_EXT
2016         DBG("network %p frequency %d", network, frequency);
2017 #endif
2018
2019         network->frequency = frequency;
2020
2021         return 0;
2022 }
2023
2024 uint16_t connman_network_get_frequency(struct connman_network *network)
2025 {
2026         return network->frequency;
2027 }
2028
2029 int connman_network_set_wifi_channel(struct connman_network *network,
2030                                                 uint16_t channel)
2031 {
2032         DBG("network %p wifi channel %d", network, channel);
2033
2034         network->wifi.channel = channel;
2035
2036         return 0;
2037 }
2038
2039 uint16_t connman_network_get_wifi_channel(struct connman_network *network)
2040 {
2041         return network->wifi.channel;
2042 }
2043
2044 /**
2045  * connman_network_set_string:
2046  * @network: network structure
2047  * @key: unique identifier
2048  * @value: string value
2049  *
2050  * Set string value for specific key
2051  */
2052 int connman_network_set_string(struct connman_network *network,
2053                                         const char *key, const char *value)
2054 {
2055 #if !defined TIZEN_EXT
2056         DBG("network %p key %s value %s", network, key, value);
2057 #endif
2058
2059         if (g_strcmp0(key, "Name") == 0)
2060                 return connman_network_set_name(network, value);
2061
2062         if (g_str_equal(key, "Path")) {
2063                 g_free(network->path);
2064                 network->path = g_strdup(value);
2065         } else if (g_str_equal(key, "Node")) {
2066                 g_free(network->node);
2067                 network->node = g_strdup(value);
2068         } else if (g_str_equal(key, "WiFi.Mode")) {
2069                 g_free(network->wifi.mode);
2070                 network->wifi.mode = g_strdup(value);
2071         } else if (g_str_equal(key, "WiFi.Security")) {
2072                 g_free(network->wifi.security);
2073                 network->wifi.security = g_strdup(value);
2074         } else if (g_str_equal(key, "WiFi.Passphrase")) {
2075                 g_free(network->wifi.passphrase);
2076                 network->wifi.passphrase = g_strdup(value);
2077         } else if (g_str_equal(key, "WiFi.EAP")) {
2078                 g_free(network->wifi.eap);
2079                 network->wifi.eap = g_strdup(value);
2080         } else if (g_str_equal(key, "WiFi.Identity")) {
2081                 g_free(network->wifi.identity);
2082                 network->wifi.identity = g_strdup(value);
2083         } else if (g_str_equal(key, "WiFi.AgentIdentity")) {
2084                 g_free(network->wifi.agent_identity);
2085                 network->wifi.agent_identity = g_strdup(value);
2086         } else if (g_str_equal(key, "WiFi.CACertFile")) {
2087                 g_free(network->wifi.ca_cert_path);
2088                 network->wifi.ca_cert_path = g_strdup(value);
2089         } else if (g_str_equal(key, "WiFi.ClientCertFile")) {
2090                 g_free(network->wifi.client_cert_path);
2091                 network->wifi.client_cert_path = g_strdup(value);
2092         } else if (g_str_equal(key, "WiFi.PrivateKeyFile")) {
2093                 g_free(network->wifi.private_key_path);
2094                 network->wifi.private_key_path = g_strdup(value);
2095         } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase")) {
2096                 g_free(network->wifi.private_key_passphrase);
2097                 network->wifi.private_key_passphrase = g_strdup(value);
2098         } else if (g_str_equal(key, "WiFi.Phase2")) {
2099                 g_free(network->wifi.phase2_auth);
2100                 network->wifi.phase2_auth = g_strdup(value);
2101         } else if (g_str_equal(key, "WiFi.PinWPS")) {
2102                 g_free(network->wifi.pin_wps);
2103                 network->wifi.pin_wps = g_strdup(value);
2104         } else {
2105                 return -EINVAL;
2106         }
2107
2108         return 0;
2109 }
2110
2111 /**
2112  * connman_network_get_string:
2113  * @network: network structure
2114  * @key: unique identifier
2115  *
2116  * Get string value for specific key
2117  */
2118 const char *connman_network_get_string(struct connman_network *network,
2119                                                         const char *key)
2120 {
2121 #if !defined TIZEN_EXT
2122         DBG("network %p key %s", network, key);
2123 #endif
2124
2125         if (g_str_equal(key, "Path"))
2126                 return network->path;
2127         else if (g_str_equal(key, "Name"))
2128                 return network->name;
2129         else if (g_str_equal(key, "Node"))
2130                 return network->node;
2131         else if (g_str_equal(key, "WiFi.Mode"))
2132                 return network->wifi.mode;
2133         else if (g_str_equal(key, "WiFi.Security"))
2134                 return network->wifi.security;
2135         else if (g_str_equal(key, "WiFi.Passphrase"))
2136                 return network->wifi.passphrase;
2137         else if (g_str_equal(key, "WiFi.EAP"))
2138                 return network->wifi.eap;
2139         else if (g_str_equal(key, "WiFi.Identity"))
2140                 return network->wifi.identity;
2141         else if (g_str_equal(key, "WiFi.AgentIdentity"))
2142                 return network->wifi.agent_identity;
2143         else if (g_str_equal(key, "WiFi.CACertFile"))
2144                 return network->wifi.ca_cert_path;
2145         else if (g_str_equal(key, "WiFi.ClientCertFile"))
2146                 return network->wifi.client_cert_path;
2147         else if (g_str_equal(key, "WiFi.PrivateKeyFile"))
2148                 return network->wifi.private_key_path;
2149         else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase"))
2150                 return network->wifi.private_key_passphrase;
2151         else if (g_str_equal(key, "WiFi.Phase2"))
2152                 return network->wifi.phase2_auth;
2153         else if (g_str_equal(key, "WiFi.PinWPS"))
2154                 return network->wifi.pin_wps;
2155
2156         return NULL;
2157 }
2158
2159 /**
2160  * connman_network_set_bool:
2161  * @network: network structure
2162  * @key: unique identifier
2163  * @value: boolean value
2164  *
2165  * Set boolean value for specific key
2166  */
2167 int connman_network_set_bool(struct connman_network *network,
2168                                         const char *key, bool value)
2169 {
2170 #if !defined TIZEN_EXT
2171         DBG("network %p key %s value %d", network, key, value);
2172 #endif
2173
2174         if (g_strcmp0(key, "Roaming") == 0)
2175                 network->roaming = value;
2176         else if (g_strcmp0(key, "WiFi.WPS") == 0)
2177                 network->wifi.wps = value;
2178         else if (g_strcmp0(key, "WiFi.UseWPS") == 0)
2179                 network->wifi.use_wps = value;
2180 #if defined TIZEN_EXT
2181         else if (g_strcmp0(key, "DefaultInternet") == 0)
2182                 network->default_internet = value;
2183 #endif
2184
2185         return -EINVAL;
2186 }
2187
2188 /**
2189  * connman_network_get_bool:
2190  * @network: network structure
2191  * @key: unique identifier
2192  *
2193  * Get boolean value for specific key
2194  */
2195 bool connman_network_get_bool(struct connman_network *network,
2196                                                         const char *key)
2197 {
2198 #if !defined TIZEN_EXT
2199         DBG("network %p key %s", network, key);
2200 #endif
2201
2202         if (g_str_equal(key, "Roaming"))
2203                 return network->roaming;
2204         else if (g_str_equal(key, "WiFi.WPS"))
2205                 return network->wifi.wps;
2206         else if (g_str_equal(key, "WiFi.UseWPS"))
2207                 return network->wifi.use_wps;
2208 #if defined TIZEN_EXT
2209         else if (g_str_equal(key, "DefaultInternet"))
2210                 return network->default_internet;
2211 #endif
2212
2213         return false;
2214 }
2215
2216 /**
2217  * connman_network_set_blob:
2218  * @network: network structure
2219  * @key: unique identifier
2220  * @data: blob data
2221  * @size: blob size
2222  *
2223  * Set binary blob value for specific key
2224  */
2225 int connman_network_set_blob(struct connman_network *network,
2226                         const char *key, const void *data, unsigned int size)
2227 {
2228 #if !defined TIZEN_EXT
2229         DBG("network %p key %s size %d", network, key, size);
2230 #endif
2231
2232         if (g_str_equal(key, "WiFi.SSID")) {
2233                 g_free(network->wifi.ssid);
2234                 network->wifi.ssid = g_try_malloc(size);
2235                 if (network->wifi.ssid) {
2236                         memcpy(network->wifi.ssid, data, size);
2237                         network->wifi.ssid_len = size;
2238                 } else
2239                         network->wifi.ssid_len = 0;
2240         } else {
2241                 return -EINVAL;
2242         }
2243
2244         return 0;
2245 }
2246
2247 /**
2248  * connman_network_get_blob:
2249  * @network: network structure
2250  * @key: unique identifier
2251  * @size: pointer to blob size
2252  *
2253  * Get binary blob value for specific key
2254  */
2255 const void *connman_network_get_blob(struct connman_network *network,
2256                                         const char *key, unsigned int *size)
2257 {
2258         DBG("network %p key %s", network, key);
2259
2260         if (g_str_equal(key, "WiFi.SSID")) {
2261                 if (size)
2262                         *size = network->wifi.ssid_len;
2263                 return network->wifi.ssid;
2264         }
2265
2266         return NULL;
2267 }
2268
2269 void __connman_network_set_device(struct connman_network *network,
2270                                         struct connman_device *device)
2271 {
2272         if (network->device == device)
2273                 return;
2274
2275         if (network->device)
2276                 network_remove(network);
2277
2278         network->device = device;
2279
2280         if (network->device)
2281                 network_probe(network);
2282 }
2283
2284 /**
2285  * connman_network_get_device:
2286  * @network: network structure
2287  *
2288  * Get parent device of network
2289  */
2290 struct connman_device *connman_network_get_device(struct connman_network *network)
2291 {
2292         return network->device;
2293 }
2294
2295 /**
2296  * connman_network_get_data:
2297  * @network: network structure
2298  *
2299  * Get private network data pointer
2300  */
2301 void *connman_network_get_data(struct connman_network *network)
2302 {
2303         return network->driver_data;
2304 }
2305
2306 /**
2307  * connman_network_set_data:
2308  * @network: network structure
2309  * @data: data pointer
2310  *
2311  * Set private network data pointer
2312  */
2313 void connman_network_set_data(struct connman_network *network, void *data)
2314 {
2315         network->driver_data = data;
2316 }
2317
2318 void connman_network_update(struct connman_network *network)
2319 {
2320         switch (network->type) {
2321         case CONNMAN_NETWORK_TYPE_UNKNOWN:
2322         case CONNMAN_NETWORK_TYPE_VENDOR:
2323                 return;
2324         case CONNMAN_NETWORK_TYPE_ETHERNET:
2325         case CONNMAN_NETWORK_TYPE_GADGET:
2326         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2327         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2328         case CONNMAN_NETWORK_TYPE_CELLULAR:
2329         case CONNMAN_NETWORK_TYPE_WIFI:
2330                 break;
2331         }
2332
2333         if (network->group)
2334                 __connman_service_update_from_network(network);
2335 }
2336
2337 int __connman_network_init(void)
2338 {
2339         DBG("");
2340
2341         return 0;
2342 }
2343
2344 void __connman_network_cleanup(void)
2345 {
2346         DBG("");
2347 }