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