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