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