src/network.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2009  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 <string.h>
  27
  28 #include <gdbus.h>
  29
  30 #include "connman.h"
  31
  32 struct connman_network {
  33         struct connman_element element;
  34         enum connman_network_type type;
  35         enum connman_network_protocol protocol;
  36         connman_bool_t available;
  37         connman_bool_t connected;
  38         connman_bool_t remember;
  39         connman_uint8_t priority;
  40         connman_uint8_t strength;
  41         char *identifier;
  42         char *name;
  43         char *node;
  44
  45         struct connman_network_driver *driver;
  46         void *driver_data;
  47
  48         connman_bool_t registered;
  49
  50         struct connman_device *device;
  51
  52         struct {
  53                 void *ssid;
  54                 int ssid_len;
  55                 char *mode;
  56                 char *security;
  57                 char *passphrase;
  58         } wifi;
  59 };
  60
  61 static const char *type2string(enum connman_network_type type)
  62 {
  63         switch (type) {
  64         case CONNMAN_NETWORK_TYPE_UNKNOWN:
  65         case CONNMAN_NETWORK_TYPE_VENDOR:
  66                 break;
  67         case CONNMAN_NETWORK_TYPE_WIFI:
  68                 return "wifi";
  69         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
  70         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
  71                 return "bluetooth";
  72         case CONNMAN_NETWORK_TYPE_HSO:
  73                 return "cellular";
  74         }
  75
  76         return NULL;
  77 }
  78
  79 static DBusMessage *get_properties(DBusConnection *conn,
  80                                         DBusMessage *msg, void *data)
  81 {
  82         struct connman_network *network = data;
  83         DBusMessage *reply;
  84         DBusMessageIter array, dict;
  85
  86         DBG("conn %p", conn);
  87
  88         if (__connman_security_check_privilege(msg,
  89                                         CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
  90                 return __connman_error_permission_denied(msg);
  91
  92         reply = dbus_message_new_method_return(msg);
  93         if (reply == NULL)
  94                 return NULL;
  95
  96         dbus_message_iter_init_append(reply, &array);
  97
  98         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
  99                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 100                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 101                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 102
 103         if (network->device) {
 104                 const char *path = connman_device_get_path(network->device);
 105                 if (path != NULL)
 106                         connman_dbus_dict_append_variant(&dict, "Device",
 107                                                 DBUS_TYPE_OBJECT_PATH, &path);
 108         }
 109
 110         if (network->name != NULL)
 111                 connman_dbus_dict_append_variant(&dict, "Name",
 112                                         DBUS_TYPE_STRING, &network->name);
 113
 114         connman_dbus_dict_append_variant(&dict, "Available",
 115                                 DBUS_TYPE_BOOLEAN, &network->available);
 116
 117         connman_dbus_dict_append_variant(&dict, "Connected",
 118                                 DBUS_TYPE_BOOLEAN, &network->connected);
 119
 120         connman_dbus_dict_append_variant(&dict, "Remember",
 121                                 DBUS_TYPE_BOOLEAN, &network->remember);
 122
 123         if (network->priority > 0)
 124                 connman_dbus_dict_append_variant(&dict, "Priority",
 125                                         DBUS_TYPE_BYTE, &network->priority);
 126
 127         if (network->strength > 0)
 128                 connman_dbus_dict_append_variant(&dict, "Strength",
 129                                         DBUS_TYPE_BYTE, &network->strength);
 130
 131         if (network->wifi.ssid != NULL && network->wifi.ssid_len > 0)
 132                 connman_dbus_dict_append_array(&dict, "WiFi.SSID",
 133                                 DBUS_TYPE_BYTE, &network->wifi.ssid,
 134                                                 network->wifi.ssid_len);
 135
 136         if (network->wifi.mode != NULL)
 137                 connman_dbus_dict_append_variant(&dict, "WiFi.Mode",
 138                                 DBUS_TYPE_STRING, &network->wifi.mode);
 139
 140         if (network->wifi.security != NULL)
 141                 connman_dbus_dict_append_variant(&dict, "WiFi.Security",
 142                                 DBUS_TYPE_STRING, &network->wifi.security);
 143
 144         if (network->wifi.passphrase != NULL &&
 145                         __connman_security_check_privilege(msg,
 146                                 CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
 147                 connman_dbus_dict_append_variant(&dict, "WiFi.Passphrase",
 148                                 DBUS_TYPE_STRING, &network->wifi.passphrase);
 149
 150         dbus_message_iter_close_container(&array, &dict);
 151
 152         return reply;
 153 }
 154
 155 static DBusMessage *set_property(DBusConnection *conn,
 156                                         DBusMessage *msg, void *data)
 157 {
 158         struct connman_network *network = data;
 159         DBusMessageIter iter, value;
 160         const char *name;
 161         int type;
 162
 163         DBG("conn %p", conn);
 164
 165         if (dbus_message_iter_init(msg, &iter) == FALSE)
 166                 return __connman_error_invalid_arguments(msg);
 167
 168         dbus_message_iter_get_basic(&iter, &name);
 169         dbus_message_iter_next(&iter);
 170         dbus_message_iter_recurse(&iter, &value);
 171
 172         if (__connman_security_check_privilege(msg,
 173                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 174                 return __connman_error_permission_denied(msg);
 175
 176         type = dbus_message_iter_get_arg_type(&value);
 177
 178         if (g_str_equal(name, "Remember") == TRUE) {
 179                 connman_bool_t remember;
 180
 181                 if (type != DBUS_TYPE_BOOLEAN)
 182                         return __connman_error_invalid_arguments(msg);
 183
 184                 dbus_message_iter_get_basic(&value, &remember);
 185
 186                 if (network->remember == remember)
 187                         return __connman_error_invalid_arguments(msg);
 188
 189                 network->remember = remember;
 190         } else if (g_str_equal(name, "WiFi.Passphrase") == TRUE) {
 191                 const char *passphrase;
 192
 193                 if (type != DBUS_TYPE_STRING)
 194                         return __connman_error_invalid_arguments(msg);
 195
 196                 if (__connman_security_check_privilege(msg,
 197                                         CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
 198                         return __connman_error_permission_denied(msg);
 199
 200                 dbus_message_iter_get_basic(&value, &passphrase);
 201
 202                 g_free(network->wifi.passphrase);
 203                 network->wifi.passphrase = g_strdup(passphrase);
 204         } else if (g_str_equal(name, "Priority") == TRUE) {
 205                 connman_uint8_t priority;
 206
 207                 if (type != DBUS_TYPE_BYTE)
 208                         return __connman_error_invalid_arguments(msg);
 209
 210                 dbus_message_iter_get_basic(&value, &priority);
 211
 212                 network->priority = priority;
 213         }
 214
 215         __connman_storage_save_network(network);
 216
 217         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 218 }
 219
 220 static DBusMessage *do_connect(DBusConnection *conn,
 221                                         DBusMessage *msg, void *data)
 222 {
 223         struct connman_network *network = data;
 224         int err;
 225
 226         DBG("conn %p", conn);
 227
 228         if (__connman_security_check_privilege(msg,
 229                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 230                 return __connman_error_permission_denied(msg);
 231
 232         if (network->connected == TRUE)
 233                 return __connman_error_failed(msg);
 234
 235         if (network->driver && network->driver->connect) {
 236                 err = network->driver->connect(network);
 237                 if (err < 0 && err != -EINPROGRESS)
 238                         return __connman_error_failed(msg);
 239         } else
 240                 network->connected = TRUE;
 241
 242         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 243 }
 244
 245 static DBusMessage *do_disconnect(DBusConnection *conn,
 246                                         DBusMessage *msg, void *data)
 247 {
 248         struct connman_network *network = data;
 249         int err;
 250
 251         DBG("conn %p", conn);
 252
 253         if (__connman_security_check_privilege(msg,
 254                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 255                 return __connman_error_permission_denied(msg);
 256
 257         if (network->connected == FALSE)
 258                 return __connman_error_failed(msg);
 259
 260         connman_element_unregister_children(&network->element);
 261
 262         if (network->driver && network->driver->disconnect) {
 263                 err = network->driver->disconnect(network);
 264                 if (err < 0 && err != -EINPROGRESS)
 265                         return __connman_error_failed(msg);
 266         } else
 267                 network->connected = FALSE;
 268
 269         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 270 }
 271
 272 static GDBusMethodTable network_methods[] = {
 273         { "GetProperties", "",   "a{sv}", get_properties },
 274         { "SetProperty",   "sv", "",      set_property   },
 275         { "Connect",       "",   "",      do_connect     },
 276         { "Disconnect",    "",   "",      do_disconnect  },
 277         { },
 278 };
 279
 280 static GDBusSignalTable network_signals[] = {
 281         { "PropertyChanged", "sv" },
 282         { },
 283 };
 284
 285 static DBusConnection *connection;
 286
 287 static void append_networks(struct connman_device *device,
 288                                                 DBusMessageIter *entry)
 289 {
 290         DBusMessageIter value, iter;
 291         const char *key = "Networks";
 292
 293         dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
 294
 295         dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
 296                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
 297                                                                 &value);
 298
 299         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 300                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
 301         __connman_element_list((struct connman_element *) device,
 302                                         CONNMAN_ELEMENT_TYPE_NETWORK, &iter);
 303         dbus_message_iter_close_container(&value, &iter);
 304
 305         dbus_message_iter_close_container(entry, &value);
 306 }
 307
 308 static void emit_networks_signal(struct connman_device *device)
 309 {
 310         const char *path = connman_device_get_path(device);
 311         DBusMessage *signal;
 312         DBusMessageIter entry;
 313
 314         signal = dbus_message_new_signal(path,
 315                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 316         if (signal == NULL)
 317                 return;
 318
 319         dbus_message_iter_init_append(signal, &entry);
 320
 321         append_networks(device, &entry);
 322
 323         g_dbus_send_message(connection, signal);
 324 }
 325
 326 static int register_interface(struct connman_element *element)
 327 {
 328         struct connman_network *network = element->network;
 329
 330         DBG("element %p name %s", element, element->name);
 331
 332         if (g_dbus_register_interface(connection, element->path,
 333                                         CONNMAN_NETWORK_INTERFACE,
 334                                         network_methods, network_signals,
 335                                         NULL, network, NULL) == FALSE) {
 336                 connman_error("Failed to register %s network", element->path);
 337                 return -EIO;
 338         }
 339
 340         network->registered = TRUE;
 341
 342         emit_networks_signal(network->device);
 343
 344         return 0;
 345 }
 346
 347 static void unregister_interface(struct connman_element *element)
 348 {
 349         struct connman_network * network = element->network;
 350
 351         DBG("element %p name %s", element, element->name);
 352
 353         network->registered = FALSE;
 354
 355         emit_networks_signal(network->device);
 356
 357         g_dbus_unregister_interface(connection, element->path,
 358                                                 CONNMAN_NETWORK_INTERFACE);
 359 }
 360
 361 connman_bool_t __connman_network_has_driver(struct connman_network *network)
 362 {
 363         if (network == NULL || network->driver == NULL)
 364                 return FALSE;
 365
 366         return network->registered;
 367 }
 368
 369 static GSList *driver_list = NULL;
 370
 371 static gint compare_priority(gconstpointer a, gconstpointer b)
 372 {
 373         const struct connman_network_driver *driver1 = a;
 374         const struct connman_network_driver *driver2 = b;
 375
 376         return driver2->priority - driver1->priority;
 377 }
 378
 379 /**
 380  * connman_network_driver_register:
 381  * @driver: network driver definition
 382  *
 383  * Register a new network driver
 384  *
 385  * Returns: %0 on success
 386  */
 387 int connman_network_driver_register(struct connman_network_driver *driver)
 388 {
 389         DBG("driver %p name %s", driver, driver->name);
 390
 391         driver_list = g_slist_insert_sorted(driver_list, driver,
 392                                                         compare_priority);
 393
 394         return 0;
 395 }
 396
 397 /**
 398  * connman_network_driver_unregister:
 399  * @driver: network driver definition
 400  *
 401  * Remove a previously registered network driver
 402  */
 403 void connman_network_driver_unregister(struct connman_network_driver *driver)
 404 {
 405         DBG("driver %p name %s", driver, driver->name);
 406
 407         driver_list = g_slist_remove(driver_list, driver);
 408 }
 409
 410 static void network_destruct(struct connman_element *element)
 411 {
 412         struct connman_network *network = element->network;
 413
 414         DBG("element %p name %s", element, element->name);
 415
 416         g_free(network->wifi.ssid);
 417         g_free(network->wifi.mode);
 418         g_free(network->wifi.security);
 419         g_free(network->wifi.passphrase);
 420
 421         g_free(network->node);
 422         g_free(network->name);
 423         g_free(network->identifier);
 424 }
 425
 426 /**
 427  * connman_network_create:
 428  * @identifier: network identifier (for example an unqiue name)
 429  *
 430  * Allocate a new network and assign the #identifier to it.
 431  *
 432  * Returns: a newly-allocated #connman_network structure
 433  */
 434 struct connman_network *connman_network_create(const char *identifier,
 435                                                 enum connman_network_type type)
 436 {
 437         struct connman_network *network;
 438         connman_uint8_t strength = 0;
 439         const char *str;
 440
 441         DBG("identifier %s type %d", identifier, type);
 442
 443         network = g_try_new0(struct connman_network, 1);
 444         if (network == NULL)
 445                 return NULL;
 446
 447         DBG("network %p", network);
 448
 449         __connman_element_initialize(&network->element);
 450
 451         network->element.name = g_strdup(identifier);
 452         network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
 453
 454         network->element.network = network;
 455         network->element.destruct = network_destruct;
 456
 457         str = type2string(type);
 458         if (str != NULL)
 459                 connman_element_add_static_property(&network->element,
 460                                         "Type", DBUS_TYPE_STRING, &str);
 461
 462         connman_element_add_static_property(&network->element,
 463                                         "Strength", DBUS_TYPE_BYTE, &strength);
 464
 465         network->type = type;
 466         network->identifier = g_strdup(identifier);
 467
 468         return network;
 469 }
 470
 471 /**
 472  * connman_network_ref:
 473  * @network: network structure
 474  *
 475  * Increase reference counter of  network
 476  */
 477 struct connman_network *connman_network_ref(struct connman_network *network)
 478 {
 479         if (connman_element_ref(&network->element) == NULL)
 480                 return NULL;
 481
 482         return network;
 483 }
 484
 485 /**
 486  * connman_network_unref:
 487  * @network: network structure
 488  *
 489  * Decrease reference counter of network
 490  */
 491 void connman_network_unref(struct connman_network *network)
 492 {
 493         connman_element_unref(&network->element);
 494 }
 495
 496 /**
 497  * connman_network_get_identifier:
 498  * @network: network structure
 499  *
 500  * Get identifier of network
 501  */
 502 const char *connman_network_get_identifier(struct connman_network *network)
 503 {
 504         return network->identifier;
 505 }
 506
 507 /**
 508  * connman_network_get_path:
 509  * @network: network structure
 510  *
 511  * Get path name of network
 512  */
 513 const char *connman_network_get_path(struct connman_network *network)
 514 {
 515         return network->element.path;
 516 }
 517
 518 /**
 519  * connman_network_set_index:
 520  * @network: network structure
 521  * @index: index number
 522  *
 523  * Set index number of network
 524  */
 525 void connman_network_set_index(struct connman_network *network, int index)
 526 {
 527         network->element.index = index;
 528 }
 529
 530 /**
 531  * connman_network_get_index:
 532  * @network: network structure
 533  *
 534  * Get index number of network
 535  */
 536 int connman_network_get_index(struct connman_network *network)
 537 {
 538         return network->element.index;
 539 }
 540
 541 /**
 542  * connman_network_set_protocol:
 543  * @network: network structure
 544  * @protocol: network protocol
 545  *
 546  * Change protocol of network
 547  */
 548 void connman_network_set_protocol(struct connman_network *network,
 549                                         enum connman_network_protocol protocol)
 550 {
 551         network->protocol = protocol;
 552 }
 553
 554 /**
 555  * connman_network_set_available:
 556  * @network: network structure
 557  * @available: availability state
 558  *
 559  * Change availability state of network (in range)
 560  */
 561 int connman_network_set_available(struct connman_network *network,
 562                                                 connman_bool_t available)
 563 {
 564         DBusMessage *signal;
 565         DBusMessageIter entry, value;
 566         const char *key = "Available";
 567
 568         DBG("network %p available %d", network, available);
 569
 570         if (network->available == available)
 571                 return -EALREADY;
 572
 573         network->available = available;
 574
 575         if (network->registered == FALSE)
 576                 return 0;
 577
 578         if (network->connected == FALSE && network->remember == FALSE)
 579                 return 0;
 580
 581         signal = dbus_message_new_signal(network->element.path,
 582                                 CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
 583         if (signal == NULL)
 584                 return 0;
 585
 586         dbus_message_iter_init_append(signal, &entry);
 587
 588         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 589
 590         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 591                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 592         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &available);
 593         dbus_message_iter_close_container(&entry, &value);
 594
 595         g_dbus_send_message(connection, signal);
 596
 597         return 0;
 598 }
 599
 600 /**
 601  * connman_network_get_available:
 602  * @network: network structure
 603  *
 604  * Get network available setting
 605  */
 606 connman_bool_t connman_network_get_available(struct connman_network *network)
 607 {
 608         return network->available;
 609 }
 610
 611 /**
 612  * connman_network_set_connected:
 613  * @network: network structure
 614  * @connected: connected state
 615  *
 616  * Change connected state of network
 617  */
 618 int connman_network_set_connected(struct connman_network *network,
 619                                                 connman_bool_t connected)
 620 {
 621         DBusMessage *signal;
 622         DBusMessageIter entry, value;
 623         const char *key = "Connected";
 624
 625         DBG("network %p connected %d", network, connected);
 626
 627         if (network->connected == connected)
 628                 return -EALREADY;
 629
 630         network->connected = connected;
 631
 632         if (network->registered == FALSE)
 633                 return 0;
 634
 635         signal = dbus_message_new_signal(network->element.path,
 636                                 CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
 637         if (signal == NULL)
 638                 return 0;
 639
 640         dbus_message_iter_init_append(signal, &entry);
 641
 642         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 643
 644         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 645                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 646         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &connected);
 647         dbus_message_iter_close_container(&entry, &value);
 648
 649         g_dbus_send_message(connection, signal);
 650
 651         if (connected == TRUE) {
 652                 struct connman_element *element;
 653                 enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
 654
 655                 switch (network->protocol) {
 656                 case CONNMAN_NETWORK_PROTOCOL_UNKNOWN:
 657                         return 0;
 658                 case CONNMAN_NETWORK_PROTOCOL_IP:
 659                         type = CONNMAN_ELEMENT_TYPE_DHCP;
 660                         break;
 661                 case CONNMAN_NETWORK_PROTOCOL_PPP:
 662                         type = CONNMAN_ELEMENT_TYPE_PPP;
 663                         break;
 664                 }
 665
 666                 __connman_device_increase_connections(network->device);
 667
 668                 element = connman_element_create(NULL);
 669                 if (element != NULL) {
 670                         element->type  = type;
 671                         element->index = network->element.index;
 672
 673                         if (connman_element_register(element,
 674                                                 &network->element) < 0)
 675                                 connman_element_unref(element);
 676                 }
 677         } else {
 678                 connman_element_unregister_children(&network->element);
 679
 680                 __connman_device_decrease_connections(network->device);
 681         }
 682
 683         return 0;
 684 }
 685
 686 /**
 687  * connman_network_set_remember:
 688  * @network: network structure
 689  * @remember: remember state
 690  *
 691  * Change remember state of network (known networks)
 692  */
 693 int connman_network_set_remember(struct connman_network *network,
 694                                                 connman_bool_t remember)
 695 {
 696         DBusMessage *signal;
 697         DBusMessageIter entry, value;
 698         const char *key = "Remember";
 699
 700         DBG("network %p remember %d", network, remember);
 701
 702         if (network->remember == remember)
 703                 return -EALREADY;
 704
 705         network->remember = remember;
 706
 707         if (network->registered == FALSE)
 708                 return 0;
 709
 710         signal = dbus_message_new_signal(network->element.path,
 711                                 CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
 712         if (signal == NULL)
 713                 return 0;
 714
 715         dbus_message_iter_init_append(signal, &entry);
 716
 717         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 718
 719         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 720                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 721         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &remember);
 722         dbus_message_iter_close_container(&entry, &value);
 723
 724         g_dbus_send_message(connection, signal);
 725
 726         return 0;
 727 }
 728
 729 /**
 730  * connman_network_get_remember:
 731  * @network: network structure
 732  *
 733  * Get network remember setting
 734  */
 735 connman_bool_t connman_network_get_remember(struct connman_network *network)
 736 {
 737         return network->remember;
 738 }
 739
 740 /**
 741  * connman_network_connect:
 742  * @network: network structure
 743  *
 744  * Connect network
 745  */
 746 int connman_network_connect(struct connman_network *network)
 747 {
 748         if (network->connected == TRUE)
 749                 return -EALREADY;
 750
 751         if (network->driver && network->driver->connect)
 752                 return network->driver->connect(network);
 753
 754         network->connected = TRUE;
 755
 756         return 0;
 757 }
 758
 759 /**
 760  * connman_network_set_string:
 761  * @network: network structure
 762  * @key: unique identifier
 763  * @value: string value
 764  *
 765  * Set string value for specific key
 766  */
 767 int connman_network_set_string(struct connman_network *network,
 768                                         const char *key, const char *value)
 769 {
 770         DBG("network %p key %s value %s", network, key, value);
 771
 772         if (g_str_equal(key, "Name") == TRUE) {
 773                 g_free(network->name);
 774                 network->name = g_strdup(value);
 775         } else if (g_str_equal(key, "Node") == TRUE) {
 776                 g_free(network->node);
 777                 network->node = g_strdup(value);
 778         } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
 779                 g_free(network->wifi.mode);
 780                 network->wifi.mode = g_strdup(value);
 781         } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
 782                 g_free(network->wifi.security);
 783                 network->wifi.security = g_strdup(value);
 784         } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
 785                 g_free(network->wifi.passphrase);
 786                 network->wifi.passphrase = g_strdup(value);
 787         }
 788
 789         return 0;
 790 }
 791
 792 /**
 793  * connman_network_get_string:
 794  * @network: network structure
 795  * @key: unique identifier
 796  *
 797  * Get string value for specific key
 798  */
 799 const char *connman_network_get_string(struct connman_network *network,
 800                                                         const char *key)
 801 {
 802         DBG("network %p key %s", network, key);
 803
 804         if (g_str_equal(key, "Name") == TRUE)
 805                 return network->name;
 806         else if (g_str_equal(key, "Node") == TRUE)
 807                 return network->node;
 808         else if (g_str_equal(key, "WiFi.Mode") == TRUE)
 809                 return network->wifi.mode;
 810         else if (g_str_equal(key, "WiFi.Security") == TRUE)
 811                 return network->wifi.security;
 812         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
 813                 return network->wifi.passphrase;
 814
 815         return NULL;
 816 }
 817
 818 /**
 819  * connman_network_set_uint8:
 820  * @network: network structure
 821  * @key: unique identifier
 822  * @value: integer value
 823  *
 824  * Set integer value for specific key
 825  */
 826 int connman_network_set_uint8(struct connman_network *network,
 827                                         const char *key, connman_uint8_t value)
 828 {
 829         DBG("network %p key %s value %d", network, key, value);
 830
 831         if (g_str_equal(key, "Priority") == TRUE)
 832                 network->priority = value;
 833         else if (g_str_equal(key, "Strength") == TRUE) {
 834                 network->strength = value;
 835                 connman_element_set_static_property(&network->element,
 836                                         "Strength", DBUS_TYPE_BYTE, &value);
 837         }
 838
 839         return 0;
 840 }
 841
 842 /**
 843  * connman_network_get_uint8:
 844  * @network: network structure
 845  * @key: unique identifier
 846  *
 847  * Get integer value for specific key
 848  */
 849 connman_uint8_t connman_network_get_uint8(struct connman_network *network,
 850                                                         const char *key)
 851 {
 852         DBG("network %p key %s", network, key);
 853
 854         if (g_str_equal(key, "Priority") == TRUE)
 855                 return network->priority;
 856         else if (g_str_equal(key, "Strength") == TRUE)
 857                 return network->strength;
 858
 859         return 0;
 860 }
 861
 862 /**
 863  * connman_network_set_blob:
 864  * @network: network structure
 865  * @key: unique identifier
 866  * @data: blob data
 867  * @size: blob size
 868  *
 869  * Set binary blob value for specific key
 870  */
 871 int connman_network_set_blob(struct connman_network *network,
 872                         const char *key, const void *data, unsigned int size)
 873 {
 874         DBG("network %p key %s size %d", network, key, size);
 875
 876         if (g_str_equal(key, "WiFi.SSID") == TRUE) {
 877                 g_free(network->wifi.ssid);
 878                 network->wifi.ssid = g_try_malloc(size);
 879                 if (network->wifi.ssid != NULL) {
 880                         memcpy(network->wifi.ssid, data, size);
 881                         network->wifi.ssid_len = size;
 882                 } else
 883                         network->wifi.ssid_len = 0;
 884         }
 885
 886         return 0;
 887 }
 888
 889 /**
 890  * connman_network_get_blob:
 891  * @network: network structure
 892  * @key: unique identifier
 893  * @size: pointer to blob size
 894  *
 895  * Get binary blob value for specific key
 896  */
 897 const void *connman_network_get_blob(struct connman_network *network,
 898                                         const char *key, unsigned int *size)
 899 {
 900         DBG("network %p key %s", network, key);
 901
 902         if (g_str_equal(key, "WiFi.SSID") == TRUE) {
 903                 if (size != NULL)
 904                         *size = network->wifi.ssid_len;
 905                 return network->wifi.ssid;
 906         }
 907
 908         return NULL;
 909 }
 910
 911 void __connman_network_set_device(struct connman_network *network,
 912                                         struct connman_device *device)
 913 {
 914         network->device = device;
 915 }
 916
 917 /**
 918  * connman_network_get_device:
 919  * @network: network structure
 920  *
 921  * Get parent device of network
 922  */
 923 struct connman_device *connman_network_get_device(struct connman_network *network)
 924 {
 925         return network->device;
 926 }
 927
 928 /**
 929  * connman_network_get_data:
 930  * @network: network structure
 931  *
 932  * Get private network data pointer
 933  */
 934 void *connman_network_get_data(struct connman_network *network)
 935 {
 936         return network->driver_data;
 937 }
 938
 939 /**
 940  * connman_network_set_data:
 941  * @network: network structure
 942  * @data: data pointer
 943  *
 944  * Set private network data pointer
 945  */
 946 void connman_network_set_data(struct connman_network *network, void *data)
 947 {
 948         network->driver_data = data;
 949 }
 950
 951 static gboolean match_driver(struct connman_network *network,
 952                                         struct connman_network_driver *driver)
 953 {
 954         if (network->type == driver->type ||
 955                         driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
 956                 return TRUE;
 957
 958         return FALSE;
 959 }
 960
 961 static int network_probe(struct connman_element *element)
 962 {
 963         struct connman_network *network = element->network;
 964         GSList *list;
 965         int err;
 966
 967         DBG("element %p name %s", element, element->name);
 968
 969         if (network == NULL)
 970                 return -ENODEV;
 971
 972         for (list = driver_list; list; list = list->next) {
 973                 struct connman_network_driver *driver = list->data;
 974
 975                 if (match_driver(network, driver) == FALSE)
 976                         continue;
 977
 978                 DBG("driver %p name %s", driver, driver->name);
 979
 980                 if (driver->probe(network) == 0) {
 981                         network->driver = driver;
 982                         break;
 983                 }
 984         }
 985
 986         if (network->driver == NULL)
 987                 return -ENODEV;
 988
 989         err = register_interface(element);
 990         if (err < 0) {
 991                 if (network->driver->remove)
 992                         network->driver->remove(network);
 993                 return err;
 994         }
 995
 996         return 0;
 997 }
 998
 999 static void network_remove(struct connman_element *element)
1000 {
1001         struct connman_network *network = element->network;
1002
1003         DBG("element %p name %s", element, element->name);
1004
1005         if (network == NULL)
1006                 return;
1007
1008         if (network->driver == NULL)
1009                 return;
1010
1011         unregister_interface(element);
1012
1013         if (network->driver->remove)
1014                 network->driver->remove(network);
1015 }
1016
1017 static struct connman_driver network_driver = {
1018         .name           = "network",
1019         .type           = CONNMAN_ELEMENT_TYPE_NETWORK,
1020         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
1021         .probe          = network_probe,
1022         .remove         = network_remove,
1023 };
1024
1025 static int network_init(struct connman_device *device)
1026 {
1027         DBG("device %p", device);
1028
1029         return 0;
1030 }
1031
1032 static int network_load(struct connman_network *network)
1033 {
1034         GKeyFile *keyfile;
1035         gchar *pathname, *data = NULL;
1036         gsize length;
1037         const char *name;
1038         int val;
1039
1040         DBG("network %p", network);
1041
1042         name = connman_device_get_name(network->device);
1043         if (name == NULL)
1044                 return -EINVAL;
1045
1046         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, name);
1047         if (pathname == NULL)
1048                 return -ENOMEM;
1049
1050         keyfile = g_key_file_new();
1051
1052         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1053                 g_free(pathname);
1054                 return -ENOENT;
1055         }
1056
1057         g_free(pathname);
1058
1059         if (g_key_file_load_from_data(keyfile, data, length,
1060                                                         0, NULL) == FALSE) {
1061                 g_free(data);
1062                 return -EILSEQ;
1063         }
1064
1065         g_free(data);
1066
1067         network->remember = g_key_file_get_boolean(keyfile,
1068                                         network->identifier, "Remember", NULL);
1069
1070         val = g_key_file_get_integer(keyfile, network->identifier,
1071                                                         "Priority", NULL);
1072         if (val > 0)
1073                 network->priority = val;
1074
1075         if (network->remember == TRUE) {
1076                 g_free(network->wifi.security);
1077                 network->wifi.security = g_key_file_get_string(keyfile,
1078                                 network->identifier, "WiFi.Security", NULL);
1079
1080                 g_free(network->wifi.passphrase);
1081                 network->wifi.passphrase = g_key_file_get_string(keyfile,
1082                                 network->identifier, "WiFi.Passphrase", NULL);
1083         }
1084
1085         g_key_file_free(keyfile);
1086
1087         return 0;
1088 }
1089
1090 static int network_save(struct connman_network *network)
1091 {
1092         GKeyFile *keyfile;
1093         gchar *pathname, *data = NULL;
1094         gsize length;
1095         const char *name;
1096
1097         DBG("network %p", network);
1098
1099         name = connman_device_get_name(network->device);
1100         if (name == NULL)
1101                 return -EINVAL;
1102
1103         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, name);
1104         if (pathname == NULL)
1105                 return -ENOMEM;
1106
1107         keyfile = g_key_file_new();
1108
1109         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1110                 goto update;
1111
1112         if (length > 0) {
1113                 if (g_key_file_load_from_data(keyfile, data, length,
1114                                                         0, NULL) == FALSE)
1115                         goto done;
1116         }
1117
1118         g_free(data);
1119
1120 update:
1121         g_key_file_set_boolean(keyfile, network->identifier,
1122                                         "Remember", network->remember);
1123
1124         if (network->priority > 0)
1125                 g_key_file_set_integer(keyfile, network->identifier,
1126                                                 "Priority", network->priority);
1127
1128         if (network->remember == TRUE) {
1129                 if (network->wifi.security != NULL)
1130                         g_key_file_set_string(keyfile, network->identifier,
1131                                 "WiFi.Security", network->wifi.security);
1132
1133                 if (network->wifi.passphrase != NULL)
1134                         g_key_file_set_string(keyfile, network->identifier,
1135                                 "WiFi.Passphrase", network->wifi.passphrase);
1136         }
1137
1138         data = g_key_file_to_data(keyfile, &length, NULL);
1139
1140         g_file_set_contents(pathname, data, length, NULL);
1141
1142 done:
1143         g_free(data);
1144
1145         g_key_file_free(keyfile);
1146
1147         g_free(pathname);
1148
1149         return 0;
1150 }
1151
1152 static struct connman_storage network_storage = {
1153         .name           = "network",
1154         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1155         .network_init   = network_init,
1156         .network_load   = network_load,
1157         .network_save   = network_save,
1158 };
1159
1160 int __connman_network_init(void)
1161 {
1162         DBG("");
1163
1164         connection = connman_dbus_get_connection();
1165
1166         if (connman_storage_register(&network_storage) < 0)
1167                 connman_error("Failed to register network storage");
1168
1169         return connman_driver_register(&network_driver);
1170 }
1171
1172 void __connman_network_cleanup(void)
1173 {
1174         DBG("");
1175
1176         connman_driver_unregister(&network_driver);
1177
1178         connman_storage_unregister(&network_storage);
1179
1180         dbus_connection_unref(connection);
1181 }