src/network.c

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