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