git.maemo.org Git - connman/blob - src/device.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 <errno.h>
  27 #include <string.h>
  28
  29 #include <gdbus.h>
  30
  31 #include "connman.h"
  32
  33 struct connman_device {
  34         struct connman_element element;
  35         enum connman_device_type type;
  36         enum connman_device_mode mode;
  37         enum connman_device_policy policy;
  38         connman_bool_t powered;
  39         connman_bool_t carrier;
  40         connman_bool_t scanning;
  41         connman_bool_t disconnected;
  42         connman_uint8_t priority;
  43         connman_uint16_t scan_interval;
  44         char *name;
  45         char *node;
  46         char *address;
  47         char *interface;
  48         unsigned int connections;
  49         guint scan_timeout;
  50
  51         struct connman_device_driver *driver;
  52         void *driver_data;
  53
  54         connman_bool_t registered;
  55
  56         char *last_network;
  57         struct connman_network *network;
  58         GHashTable *networks;
  59 };
  60
  61 static gboolean device_scan_trigger(gpointer user_data)
  62 {
  63         struct connman_device *device = user_data;
  64
  65         DBG("device %p", device);
  66
  67         if (device->driver == NULL) {
  68                 device->scan_timeout = 0;
  69                 return FALSE;
  70         }
  71
  72         if (device->driver->scan)
  73                 device->driver->scan(device);
  74
  75         return TRUE;
  76 }
  77
  78 static const char *type2description(enum connman_device_type type)
  79 {
  80         switch (type) {
  81         case CONNMAN_DEVICE_TYPE_UNKNOWN:
  82         case CONNMAN_DEVICE_TYPE_VENDOR:
  83                 break;
  84         case CONNMAN_DEVICE_TYPE_ETHERNET:
  85                 return "Ethernet";
  86         case CONNMAN_DEVICE_TYPE_WIFI:
  87                 return "Wireless";
  88         case CONNMAN_DEVICE_TYPE_WIMAX:
  89                 return "WiMAX";
  90         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
  91                 return "Bluetooth";
  92         case CONNMAN_DEVICE_TYPE_GPS:
  93                 return "GPS";
  94         case CONNMAN_DEVICE_TYPE_HSO:
  95         case CONNMAN_DEVICE_TYPE_NOZOMI:
  96         case CONNMAN_DEVICE_TYPE_HUAWEI:
  97         case CONNMAN_DEVICE_TYPE_NOVATEL:
  98                 return "Cellular";
  99         }
 100
 101         return NULL;
 102 }
 103
 104 static const char *type2string(enum connman_device_type type)
 105 {
 106         switch (type) {
 107         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 108         case CONNMAN_DEVICE_TYPE_VENDOR:
 109                 break;
 110         case CONNMAN_DEVICE_TYPE_ETHERNET:
 111                 return "ethernet";
 112         case CONNMAN_DEVICE_TYPE_WIFI:
 113                 return "wifi";
 114         case CONNMAN_DEVICE_TYPE_WIMAX:
 115                 return "wimax";
 116         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 117                 return "bluetooth";
 118         case CONNMAN_DEVICE_TYPE_GPS:
 119                 return "gps";
 120         case CONNMAN_DEVICE_TYPE_HSO:
 121         case CONNMAN_DEVICE_TYPE_HUAWEI:
 122         case CONNMAN_DEVICE_TYPE_NOZOMI:
 123         case CONNMAN_DEVICE_TYPE_NOVATEL:
 124                 return "cellular";
 125         }
 126
 127         return NULL;
 128 }
 129
 130 static const char *policy2string(enum connman_device_policy policy)
 131 {
 132         switch (policy) {
 133         case CONNMAN_DEVICE_POLICY_UNKNOWN:
 134                 break;
 135         case CONNMAN_DEVICE_POLICY_IGNORE:
 136                 return "ignore";
 137         case CONNMAN_DEVICE_POLICY_OFF:
 138                 return "off";
 139         case CONNMAN_DEVICE_POLICY_AUTO:
 140                 return "auto";
 141         case CONNMAN_DEVICE_POLICY_MANUAL:
 142                 return "manual";
 143         }
 144
 145         return NULL;
 146 }
 147
 148 static enum connman_device_policy string2policy(const char *policy)
 149 {
 150         if (g_str_equal(policy, "ignore") == TRUE)
 151                 return CONNMAN_DEVICE_POLICY_IGNORE;
 152         else if (g_str_equal(policy, "off") == TRUE)
 153                 return CONNMAN_DEVICE_POLICY_OFF;
 154         else if (g_str_equal(policy, "auto") == TRUE)
 155                 return CONNMAN_DEVICE_POLICY_AUTO;
 156         else if (g_str_equal(policy, "manual") == TRUE)
 157                 return CONNMAN_DEVICE_POLICY_MANUAL;
 158         else
 159                 return CONNMAN_DEVICE_POLICY_UNKNOWN;
 160 }
 161
 162 static int set_powered(struct connman_device *device, connman_bool_t powered)
 163 {
 164         struct connman_device_driver *driver = device->driver;
 165         int err;
 166
 167         DBG("device %p powered %d", device, powered);
 168
 169         if (!driver)
 170                 return -EINVAL;
 171
 172         if (powered == TRUE) {
 173                 if (driver->enable) {
 174                         err = driver->enable(device);
 175                         __connman_notifier_device_type_increase(device->type);
 176                 } else
 177                         err = -EINVAL;
 178         } else {
 179                 g_hash_table_remove_all(device->networks);
 180
 181                 if (driver->disable) {
 182                         err = driver->disable(device);
 183                         __connman_notifier_device_type_decrease(device->type);
 184                 } else
 185                         err = -EINVAL;
 186         }
 187
 188         return err;
 189 }
 190
 191 static int set_policy(DBusConnection *connection,
 192                                 struct connman_device *device,
 193                                         enum connman_device_policy policy)
 194 {
 195         DBusMessage *signal;
 196         DBusMessageIter entry, value;
 197         const char *str, *key = "Policy";
 198         int err = 0;
 199
 200         DBG("device %p policy %d", device, policy);
 201
 202         if (device->policy == policy)
 203                 return 0;
 204
 205         switch (policy) {
 206         case CONNMAN_DEVICE_POLICY_UNKNOWN:
 207                 return -EINVAL;
 208         case CONNMAN_DEVICE_POLICY_IGNORE:
 209                 break;
 210         case CONNMAN_DEVICE_POLICY_OFF:
 211                 if (device->powered == TRUE)
 212                         err = set_powered(device, FALSE);
 213                 break;
 214         case CONNMAN_DEVICE_POLICY_AUTO:
 215         case CONNMAN_DEVICE_POLICY_MANUAL:
 216                 if (device->powered == FALSE)
 217                         err = set_powered(device, TRUE);
 218                 break;
 219         }
 220
 221         if (err < 0)
 222                 return err;
 223
 224         device->policy = policy;
 225
 226         signal = dbus_message_new_signal(device->element.path,
 227                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 228         if (signal == NULL)
 229                 return 0;
 230
 231         dbus_message_iter_init_append(signal, &entry);
 232
 233         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 234
 235         str = policy2string(policy);
 236
 237         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 238                                         DBUS_TYPE_STRING_AS_STRING, &value);
 239         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
 240         dbus_message_iter_close_container(&entry, &value);
 241
 242         g_dbus_send_message(connection, signal);
 243
 244         return 0;
 245 }
 246
 247 static void append_path(gpointer key, gpointer value, gpointer user_data)
 248 {
 249         struct connman_element *element = value;
 250         DBusMessageIter *iter = user_data;
 251
 252         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
 253                                                         &element->path);
 254 }
 255
 256 static void append_networks(struct connman_device *device,
 257                                                 DBusMessageIter *entry)
 258 {
 259         DBusMessageIter value, iter;
 260         const char *key = "Networks";
 261
 262         dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
 263
 264         dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
 265                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
 266                                                                 &value);
 267
 268         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 269                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
 270         g_hash_table_foreach(device->networks, append_path, &iter);
 271         dbus_message_iter_close_container(&value, &iter);
 272
 273         dbus_message_iter_close_container(entry, &value);
 274 }
 275
 276 static DBusMessage *get_properties(DBusConnection *conn,
 277                                         DBusMessage *msg, void *data)
 278 {
 279         struct connman_device *device = data;
 280         DBusMessage *reply;
 281         DBusMessageIter array, dict, entry;
 282         const char *str;
 283
 284         DBG("conn %p", conn);
 285
 286         if (__connman_security_check_privilege(msg,
 287                                         CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
 288                 return __connman_error_permission_denied(msg);
 289
 290         reply = dbus_message_new_method_return(msg);
 291         if (reply == NULL)
 292                 return NULL;
 293
 294         dbus_message_iter_init_append(reply, &array);
 295
 296         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
 297                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 298                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 299                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 300
 301         str = type2description(device->type);
 302         if (str != NULL && device->interface != NULL) {
 303                 char *name = g_strdup_printf("%s (%s)", str, device->interface);
 304                 if (name != NULL)
 305                         connman_dbus_dict_append_variant(&dict, "Name",
 306                                                 DBUS_TYPE_STRING, &name);
 307                 g_free(name);
 308         }
 309
 310         str = type2string(device->type);
 311         if (str != NULL)
 312                 connman_dbus_dict_append_variant(&dict, "Type",
 313                                                 DBUS_TYPE_STRING, &str);
 314
 315         if (device->address != NULL)
 316                 connman_dbus_dict_append_variant(&dict, "Address",
 317                                         DBUS_TYPE_STRING, &device->address);
 318
 319         if (device->interface != NULL)
 320                 connman_dbus_dict_append_variant(&dict, "Interface",
 321                                         DBUS_TYPE_STRING, &device->interface);
 322
 323         str = policy2string(device->policy);
 324         if (str != NULL)
 325                 connman_dbus_dict_append_variant(&dict, "Policy",
 326                                                 DBUS_TYPE_STRING, &str);
 327
 328         if (device->priority > 0)
 329                 connman_dbus_dict_append_variant(&dict, "Priority",
 330                                         DBUS_TYPE_BYTE, &device->priority);
 331
 332         connman_dbus_dict_append_variant(&dict, "Powered",
 333                                         DBUS_TYPE_BOOLEAN, &device->powered);
 334
 335         if (device->driver && device->driver->scan)
 336                 connman_dbus_dict_append_variant(&dict, "Scanning",
 337                                         DBUS_TYPE_BOOLEAN, &device->scanning);
 338
 339         switch (device->mode) {
 340         case CONNMAN_DEVICE_MODE_UNKNOWN:
 341                 break;
 342         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 343                 __connman_element_append_ipv4(&device->element, &dict);
 344                 break;
 345         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 346         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 347                 if (device->scan_interval > 0)
 348                         connman_dbus_dict_append_variant(&dict, "ScanInterval",
 349                                 DBUS_TYPE_UINT16, &device->scan_interval);
 350
 351                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
 352                                                                 NULL, &entry);
 353                 append_networks(device, &entry);
 354                 dbus_message_iter_close_container(&dict, &entry);
 355                 break;
 356         }
 357
 358         dbus_message_iter_close_container(&array, &dict);
 359
 360         return reply;
 361 }
 362
 363 static DBusMessage *set_property(DBusConnection *conn,
 364                                         DBusMessage *msg, void *data)
 365 {
 366         struct connman_device *device = data;
 367         DBusMessageIter iter, value;
 368         const char *name;
 369         int type;
 370
 371         DBG("conn %p", conn);
 372
 373         if (dbus_message_iter_init(msg, &iter) == FALSE)
 374                 return __connman_error_invalid_arguments(msg);
 375
 376         dbus_message_iter_get_basic(&iter, &name);
 377         dbus_message_iter_next(&iter);
 378         dbus_message_iter_recurse(&iter, &value);
 379
 380         if (__connman_security_check_privilege(msg,
 381                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 382                 return __connman_error_permission_denied(msg);
 383
 384         type = dbus_message_iter_get_arg_type(&value);
 385
 386         if (g_str_equal(name, "Powered") == TRUE) {
 387                 connman_bool_t powered;
 388                 int err;
 389
 390                 if (type != DBUS_TYPE_BOOLEAN)
 391                         return __connman_error_invalid_arguments(msg);
 392
 393                 dbus_message_iter_get_basic(&value, &powered);
 394
 395                 if (device->powered == powered)
 396                         return __connman_error_invalid_arguments(msg);
 397
 398                 err = set_powered(device, powered);
 399                 if (err < 0 && err != -EINPROGRESS)
 400                         return __connman_error_failed(msg);
 401         } else if (g_str_equal(name, "Policy") == TRUE) {
 402                 enum connman_device_policy policy;
 403                 const char *str;
 404                 int err;
 405
 406                 if (type != DBUS_TYPE_STRING)
 407                         return __connman_error_invalid_arguments(msg);
 408
 409                 dbus_message_iter_get_basic(&value, &str);
 410                 policy = string2policy(str);
 411                 if (policy == CONNMAN_DEVICE_POLICY_UNKNOWN)
 412                         return __connman_error_invalid_arguments(msg);
 413
 414                 err = set_policy(conn, device, policy);
 415                 if (err < 0)
 416                         return __connman_error_failed(msg);
 417         } else if (g_str_equal(name, "Priority") == TRUE) {
 418                 connman_uint8_t priority;
 419
 420                 if (type != DBUS_TYPE_BYTE)
 421                         return __connman_error_invalid_arguments(msg);
 422
 423                 dbus_message_iter_get_basic(&value, &priority);
 424
 425                 device->priority = priority;
 426         } else if (g_str_equal(name, "ScanInterval") == TRUE) {
 427                 connman_uint16_t interval;
 428
 429                 switch (device->mode) {
 430                 case CONNMAN_DEVICE_MODE_UNKNOWN:
 431                 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 432                         return __connman_error_invalid_arguments(msg);
 433                 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 434                 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 435                         break;
 436                 }
 437
 438                 if (type != DBUS_TYPE_UINT16)
 439                         return __connman_error_invalid_arguments(msg);
 440
 441                 dbus_message_iter_get_basic(&value, &interval);
 442
 443                 device->scan_interval = interval;
 444
 445                 if (device->scan_timeout > 0) {
 446                         g_source_remove(device->scan_timeout);
 447                         device->scan_timeout = 0;
 448                 }
 449
 450                 if (device->scan_interval > 0) {
 451                         guint interval = device->scan_interval;
 452                         device->scan_timeout = g_timeout_add_seconds(interval,
 453                                                 device_scan_trigger, device);
 454                 }
 455         } else if (g_str_has_prefix(name, "IPv4") == TRUE) {
 456                 switch (device->mode) {
 457                 case CONNMAN_DEVICE_MODE_UNKNOWN:
 458                 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 459                 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 460                         return __connman_error_invalid_arguments(msg);
 461                 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 462                         __connman_element_set_ipv4(&device->element,
 463                                                                 name, &value);
 464                         break;
 465                 }
 466         }
 467
 468         __connman_storage_save_device(device);
 469
 470         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 471 }
 472
 473 static DBusMessage *create_network(DBusConnection *conn,
 474                                         DBusMessage *msg, void *data)
 475 {
 476         DBG("conn %p", conn);
 477
 478         if (__connman_security_check_privilege(msg,
 479                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 480                 return __connman_error_permission_denied(msg);
 481
 482         return __connman_error_invalid_arguments(msg);
 483 }
 484
 485 static DBusMessage *remove_network(DBusConnection *conn,
 486                                         DBusMessage *msg, void *data)
 487 {
 488         DBG("conn %p", conn);
 489
 490         if (__connman_security_check_privilege(msg,
 491                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 492                 return __connman_error_permission_denied(msg);
 493
 494         return __connman_error_invalid_arguments(msg);
 495 }
 496
 497 static DBusMessage *propose_scan(DBusConnection *conn,
 498                                         DBusMessage *msg, void *data)
 499 {
 500         struct connman_device *device = data;
 501         int err;
 502
 503         DBG("conn %p", conn);
 504
 505         switch (device->mode) {
 506         case CONNMAN_DEVICE_MODE_UNKNOWN:
 507         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 508                 return __connman_error_not_supported(msg);
 509         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 510         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 511                 break;
 512         }
 513
 514         if (!device->driver || !device->driver->scan)
 515                 return __connman_error_not_supported(msg);
 516
 517         if (device->powered == FALSE)
 518                 return __connman_error_failed(msg);
 519
 520         err = device->driver->scan(device);
 521         if (err < 0)
 522                 return __connman_error_failed(msg);
 523
 524         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 525 }
 526
 527 static GDBusMethodTable device_methods[] = {
 528         { "GetProperties", "",      "a{sv}", get_properties },
 529         { "SetProperty",   "sv",    "",      set_property   },
 530         { "CreateNetwork", "a{sv}", "o",     create_network },
 531         { "RemoveNetwork", "o",     "",      remove_network },
 532         { "ProposeScan",   "",      "",      propose_scan   },
 533         { },
 534 };
 535
 536 static GDBusSignalTable device_signals[] = {
 537         { "PropertyChanged", "sv" },
 538         { },
 539 };
 540
 541 static DBusConnection *connection;
 542
 543 static void append_devices(DBusMessageIter *entry)
 544 {
 545         DBusMessageIter value, iter;
 546         const char *key = "Devices";
 547
 548         dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
 549
 550         dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
 551                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
 552                                                                 &value);
 553
 554         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 555                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
 556         __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
 557         dbus_message_iter_close_container(&value, &iter);
 558
 559         dbus_message_iter_close_container(entry, &value);
 560 }
 561
 562 static void emit_devices_signal(void)
 563 {
 564         DBusMessage *signal;
 565         DBusMessageIter entry;
 566
 567         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
 568                                 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
 569         if (signal == NULL)
 570                 return;
 571
 572         dbus_message_iter_init_append(signal, &entry);
 573
 574         append_devices(&entry);
 575
 576         g_dbus_send_message(connection, signal);
 577 }
 578
 579 static int register_interface(struct connman_element *element)
 580 {
 581         struct connman_device *device = element->device;
 582
 583         DBG("element %p name %s", element, element->name);
 584
 585         if (g_dbus_register_interface(connection, element->path,
 586                                         CONNMAN_DEVICE_INTERFACE,
 587                                         device_methods, device_signals,
 588                                         NULL, device, NULL) == FALSE) {
 589                 connman_error("Failed to register %s device", element->path);
 590                 return -EIO;
 591         }
 592
 593         device->registered = TRUE;
 594
 595         emit_devices_signal();
 596
 597         return 0;
 598 }
 599
 600 static void unregister_interface(struct connman_element *element)
 601 {
 602         struct connman_device *device = element->device;
 603
 604         DBG("element %p name %s", element, element->name);
 605
 606         device->registered = FALSE;
 607
 608         emit_devices_signal();
 609
 610         g_dbus_unregister_interface(connection, element->path,
 611                                                 CONNMAN_DEVICE_INTERFACE);
 612 }
 613
 614 static void device_enable(struct connman_device *device)
 615 {
 616         DBG("device %p", device);
 617
 618         if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE ||
 619                                 device->policy == CONNMAN_DEVICE_POLICY_OFF)
 620                 return;
 621
 622         if (device->powered == TRUE)
 623                 return;
 624
 625         if (device->driver->enable) {
 626                 device->driver->enable(device);
 627                 __connman_notifier_device_type_increase(device->type);
 628         }
 629 }
 630
 631 static void device_disable(struct connman_device *device)
 632 {
 633         DBG("device %p", device);
 634
 635         if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE)
 636                 return;
 637
 638         if (device->powered == FALSE)
 639                 return;
 640
 641         g_hash_table_remove_all(device->networks);
 642
 643         if (device->driver->disable) {
 644                 device->driver->disable(device);
 645                 __connman_notifier_device_type_decrease(device->type);
 646         }
 647 }
 648
 649 static int setup_device(struct connman_device *device)
 650 {
 651         int err;
 652
 653         DBG("device %p", device);
 654
 655         err = register_interface(&device->element);
 656         if (err < 0) {
 657                 if (device->driver->remove)
 658                         device->driver->remove(device);
 659                 device->driver = NULL;
 660                 return err;
 661         }
 662
 663         switch (device->mode) {
 664         case CONNMAN_DEVICE_MODE_UNKNOWN:
 665         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 666         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 667                 break;
 668         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 669                 __connman_profile_add_device(device);
 670                 break;
 671         }
 672
 673         device_enable(device);
 674
 675         return 0;
 676 }
 677
 678 static void probe_driver(struct connman_element *element, gpointer user_data)
 679 {
 680         struct connman_device_driver *driver = user_data;
 681
 682         DBG("element %p name %s", element, element->name);
 683
 684         if (element->device == NULL)
 685                 return;
 686
 687         if (element->device->driver != NULL)
 688                 return;
 689
 690         if (driver->type != element->device->type)
 691                 return;
 692
 693         if (driver->probe(element->device) < 0)
 694                 return;
 695
 696         element->device->driver = driver;
 697
 698         setup_device(element->device);
 699 }
 700
 701 static void remove_device(struct connman_device *device)
 702 {
 703         DBG("device %p", device);
 704
 705         device_disable(device);
 706
 707         switch (device->mode) {
 708         case CONNMAN_DEVICE_MODE_UNKNOWN:
 709         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 710         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 711                 break;
 712         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 713                 __connman_profile_remove_device(device);
 714                 break;
 715         }
 716
 717         unregister_interface(&device->element);
 718
 719         if (device->driver->remove)
 720                 device->driver->remove(device);
 721
 722         device->driver = NULL;
 723 }
 724
 725 static void remove_driver(struct connman_element *element, gpointer user_data)
 726 {
 727         struct connman_device_driver *driver = user_data;
 728
 729         DBG("element %p name %s", element, element->name);
 730
 731         if (element->device == NULL)
 732                 return;
 733
 734         if (element->device->driver == driver)
 735                 remove_device(element->device);
 736 }
 737
 738 connman_bool_t __connman_device_has_driver(struct connman_device *device)
 739 {
 740         if (device == NULL || device->driver == NULL)
 741                 return FALSE;
 742
 743         return device->registered;
 744 }
 745
 746 static GSList *driver_list = NULL;
 747
 748 static gint compare_priority(gconstpointer a, gconstpointer b)
 749 {
 750         const struct connman_device_driver *driver1 = a;
 751         const struct connman_device_driver *driver2 = b;
 752
 753         return driver2->priority - driver1->priority;
 754 }
 755
 756 /**
 757  * connman_device_driver_register:
 758  * @driver: device driver definition
 759  *
 760  * Register a new device driver
 761  *
 762  * Returns: %0 on success
 763  */
 764 int connman_device_driver_register(struct connman_device_driver *driver)
 765 {
 766         DBG("driver %p name %s", driver, driver->name);
 767
 768         driver_list = g_slist_insert_sorted(driver_list, driver,
 769                                                         compare_priority);
 770
 771         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
 772                                                 probe_driver, driver);
 773
 774         return 0;
 775 }
 776
 777 /**
 778  * connman_device_driver_unregister:
 779  * @driver: device driver definition
 780  *
 781  * Remove a previously registered device driver
 782  */
 783 void connman_device_driver_unregister(struct connman_device_driver *driver)
 784 {
 785         DBG("driver %p name %s", driver, driver->name);
 786
 787         driver_list = g_slist_remove(driver_list, driver);
 788
 789         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
 790                                                 remove_driver, driver);
 791 }
 792
 793 static void unregister_network(gpointer data)
 794 {
 795         struct connman_network *network = data;
 796
 797         DBG("network %p", network);
 798
 799         connman_element_unregister((struct connman_element *) network);
 800
 801         connman_network_unref(network);
 802 }
 803
 804 static void device_destruct(struct connman_element *element)
 805 {
 806         struct connman_device *device = element->device;
 807
 808         DBG("element %p name %s", element, element->name);
 809
 810         g_free(device->node);
 811         g_free(device->name);
 812         g_free(device->address);
 813         g_free(device->interface);
 814
 815         g_free(device->last_network);
 816
 817         g_hash_table_destroy(device->networks);
 818         device->networks = NULL;
 819 }
 820
 821 /**
 822  * connman_device_create:
 823  * @node: device node name (for example an address)
 824  * @type: device type
 825  *
 826  * Allocate a new device of given #type and assign the #node name to it.
 827  *
 828  * Returns: a newly-allocated #connman_device structure
 829  */
 830 struct connman_device *connman_device_create(const char *node,
 831                                                 enum connman_device_type type)
 832 {
 833         struct connman_device *device;
 834         const char *str;
 835
 836         DBG("node %s type %d", node, type);
 837
 838         device = g_try_new0(struct connman_device, 1);
 839         if (device == NULL)
 840                 return NULL;
 841
 842         DBG("device %p", device);
 843
 844         __connman_element_initialize(&device->element);
 845
 846         device->element.name = g_strdup(node);
 847         device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
 848
 849         device->element.device = device;
 850         device->element.destruct = device_destruct;
 851
 852         str = type2string(type);
 853         if (str != NULL)
 854                 connman_element_set_string(&device->element,
 855                                         CONNMAN_PROPERTY_ID_TYPE, str);
 856
 857         device->element.ipv4.method = CONNMAN_IPV4_METHOD_DHCP;
 858
 859         device->type   = type;
 860         device->mode   = CONNMAN_DEVICE_MODE_UNKNOWN;
 861         device->policy = CONNMAN_DEVICE_POLICY_AUTO;
 862
 863         switch (type) {
 864         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 865         case CONNMAN_DEVICE_TYPE_VENDOR:
 866                 device->priority = 0;
 867                 device->scan_interval = 0;
 868                 break;
 869         case CONNMAN_DEVICE_TYPE_ETHERNET:
 870         case CONNMAN_DEVICE_TYPE_WIFI:
 871                 device->priority = 100;
 872                 device->scan_interval = 300;
 873                 break;
 874         case CONNMAN_DEVICE_TYPE_WIMAX:
 875                 device->priority = 20;
 876                 device->scan_interval = 0;
 877                 break;
 878         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 879                 device->priority = 50;
 880                 device->scan_interval = 0;
 881                 break;
 882         case CONNMAN_DEVICE_TYPE_GPS:
 883                 device->priority = 0;
 884                 device->scan_interval = 0;
 885                 break;
 886         case CONNMAN_DEVICE_TYPE_HSO:
 887         case CONNMAN_DEVICE_TYPE_NOZOMI:
 888         case CONNMAN_DEVICE_TYPE_HUAWEI:
 889         case CONNMAN_DEVICE_TYPE_NOVATEL:
 890                 device->priority = 60;
 891                 device->scan_interval = 0;
 892                 break;
 893         }
 894
 895         device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
 896                                                 g_free, unregister_network);
 897
 898         return device;
 899 }
 900
 901 /**
 902  * connman_device_ref:
 903  * @device: device structure
 904  *
 905  * Increase reference counter of device
 906  */
 907 struct connman_device *connman_device_ref(struct connman_device *device)
 908 {
 909         if (connman_element_ref(&device->element) == NULL)
 910                 return NULL;
 911
 912         return device;
 913 }
 914
 915 /**
 916  * connman_device_unref:
 917  * @device: device structure
 918  *
 919  * Decrease reference counter of device
 920  */
 921 void connman_device_unref(struct connman_device *device)
 922 {
 923         connman_element_unref(&device->element);
 924 }
 925
 926 /**
 927  * connman_device_get_name:
 928  * @device: device structure
 929  *
 930  * Get unique name of device
 931  */
 932 const char *connman_device_get_name(struct connman_device *device)
 933 {
 934         return device->element.name;
 935 }
 936
 937 /**
 938  * connman_device_get_path:
 939  * @device: device structure
 940  *
 941  * Get path name of device
 942  */
 943 const char *connman_device_get_path(struct connman_device *device)
 944 {
 945         return device->element.path;
 946 }
 947
 948 /**
 949  * connman_device_set_index:
 950  * @device: device structure
 951  * @index: index number
 952  *
 953  * Set index number of device
 954  */
 955 void connman_device_set_index(struct connman_device *device, int index)
 956 {
 957         device->element.index = index;
 958 }
 959
 960 /**
 961  * connman_device_get_index:
 962  * @device: device structure
 963  *
 964  * Get index number of device
 965  */
 966 int connman_device_get_index(struct connman_device *device)
 967 {
 968         return device->element.index;
 969 }
 970
 971 /**
 972  * connman_device_set_interface:
 973  * @device: device structure
 974  * @interface: interface name
 975  *
 976  * Set interface name of device
 977  */
 978 void connman_device_set_interface(struct connman_device *device,
 979                                                         const char *interface)
 980 {
 981         g_free(device->element.devname);
 982         device->element.devname = g_strdup(interface);
 983
 984         g_free(device->interface);
 985         device->interface = g_strdup(interface);
 986 }
 987
 988 /**
 989  * connman_device_get_interface:
 990  * @device: device structure
 991  *
 992  * Get interface name of device
 993  */
 994 const char *connman_device_get_interface(struct connman_device *device)
 995 {
 996         return device->interface;
 997 }
 998
 999 /**
1000  * connman_device_set_policy:
1001  * @device: device structure
1002  * @policy: power and connection policy
1003  *
1004  * Change power and connection policy of device
1005  */
1006 void connman_device_set_policy(struct connman_device *device,
1007                                         enum connman_device_policy policy)
1008 {
1009         device->policy = policy;
1010 }
1011
1012 /**
1013  * connman_device_set_mode:
1014  * @device: device structure
1015  * @mode: network mode
1016  *
1017  * Change network mode of device
1018  */
1019 void connman_device_set_mode(struct connman_device *device,
1020                                                 enum connman_device_mode mode)
1021 {
1022         device->mode = mode;
1023 }
1024
1025 /**
1026  * connman_device_get_mode:
1027  * @device: device structure
1028  *
1029  * Get network mode of device
1030  */
1031 enum connman_device_mode connman_device_get_mode(struct connman_device *device)
1032 {
1033         return device->mode;
1034 }
1035
1036 /**
1037  * connman_device_set_powered:
1038  * @device: device structure
1039  * @powered: powered state
1040  *
1041  * Change power state of device
1042  */
1043 int connman_device_set_powered(struct connman_device *device,
1044                                                 connman_bool_t powered)
1045 {
1046         DBusMessage *signal;
1047         DBusMessageIter entry, value;
1048         const char *key = "Powered";
1049
1050         DBG("driver %p powered %d", device, powered);
1051
1052         if (device->powered == powered)
1053                 return -EALREADY;
1054
1055         device->powered = powered;
1056
1057         if (device->registered == FALSE)
1058                 return 0;
1059
1060         signal = dbus_message_new_signal(device->element.path,
1061                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
1062         if (signal == NULL)
1063                 return 0;
1064
1065         dbus_message_iter_init_append(signal, &entry);
1066
1067         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
1068
1069         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
1070                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
1071         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
1072         dbus_message_iter_close_container(&entry, &value);
1073
1074         g_dbus_send_message(connection, signal);
1075
1076         if (powered == FALSE)
1077                 return 0;
1078
1079         if (device->policy != CONNMAN_DEVICE_POLICY_AUTO)
1080                 return 0;
1081
1082         if (device->scan_timeout > 0) {
1083                 g_source_remove(device->scan_timeout);
1084                 device->scan_timeout = 0;
1085         }
1086
1087         if (device->scan_interval > 0) {
1088                 guint interval = device->scan_interval;
1089                 device->scan_timeout = g_timeout_add_seconds(interval,
1090                                         device_scan_trigger, device);
1091         }
1092
1093         if (device->driver->scan)
1094                 device->driver->scan(device);
1095
1096         return 0;
1097 }
1098
1099 /**
1100  * connman_device_set_carrier:
1101  * @device: device structure
1102  * @carrier: carrier state
1103  *
1104  * Change carrier state of device (only for device without scanning)
1105  */
1106 int connman_device_set_carrier(struct connman_device *device,
1107                                                 connman_bool_t carrier)
1108 {
1109         DBG("driver %p carrier %d", device, carrier);
1110
1111         switch (device->mode) {
1112         case CONNMAN_DEVICE_MODE_UNKNOWN:
1113         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1114         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1115                 return -EINVAL;
1116         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1117                 break;
1118         }
1119
1120         if (device->carrier == carrier)
1121                 return -EALREADY;
1122
1123         device->carrier = carrier;
1124
1125         if (carrier == TRUE) {
1126                 enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
1127                 struct connman_element *element;
1128
1129                 switch (device->element.ipv4.method) {
1130                 case CONNMAN_IPV4_METHOD_UNKNOWN:
1131                 case CONNMAN_IPV4_METHOD_OFF:
1132                         return 0;
1133                 case CONNMAN_IPV4_METHOD_STATIC:
1134                         type = CONNMAN_ELEMENT_TYPE_IPV4;
1135                         break;
1136                 case CONNMAN_IPV4_METHOD_DHCP:
1137                         type = CONNMAN_ELEMENT_TYPE_DHCP;
1138                         break;
1139                 }
1140
1141                 element = connman_element_create(NULL);
1142                 if (element != NULL) {
1143                         element->type  = type;
1144                         element->index = device->element.index;
1145
1146                         if (connman_element_register(element,
1147                                                         &device->element) < 0)
1148                                 connman_element_unref(element);
1149                 }
1150         } else
1151                 connman_element_unregister_children(&device->element);
1152
1153         return 0;
1154 }
1155
1156 void __connman_device_disconnect(struct connman_device *device)
1157 {
1158         GHashTableIter iter;
1159         gpointer key, value;
1160
1161         DBG("device %p", device);
1162
1163         connman_device_set_disconnected(device, TRUE);
1164
1165         g_hash_table_iter_init(&iter, device->networks);
1166
1167         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1168                 struct connman_network *network = value;
1169
1170                 if (connman_network_get_connected(network) == TRUE)
1171                         __connman_network_disconnect(network);
1172         }
1173 }
1174
1175 static void connect_known_network(struct connman_device *device)
1176 {
1177         struct connman_network *network = NULL;
1178         GHashTableIter iter;
1179         gpointer key, value;
1180         unsigned int count = 0;
1181
1182         DBG("device %p", device);
1183
1184         g_hash_table_iter_init(&iter, device->networks);
1185
1186         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1187                 connman_uint8_t old_priority, new_priority;
1188                 connman_uint8_t old_strength, new_strength;
1189                 const char *name;
1190
1191                 count++;
1192
1193                 if (connman_network_get_available(value) == FALSE)
1194                         continue;
1195
1196                 name = connman_network_get_string(value,
1197                                                 CONNMAN_PROPERTY_ID_NAME);
1198                 if (name != NULL && device->last_network != NULL) {
1199                         if (g_str_equal(name, device->last_network) == TRUE) {
1200                                 network = value;
1201                                 break;
1202                         }
1203                 }
1204
1205                 if (connman_network_get_remember(value) == FALSE)
1206                         continue;
1207
1208                 if (network == NULL) {
1209                         network = value;
1210                         continue;
1211                 }
1212
1213                 old_priority = connman_network_get_uint8(network,
1214                                                 CONNMAN_PROPERTY_ID_PRIORITY);
1215                 new_priority = connman_network_get_uint8(value,
1216                                                 CONNMAN_PROPERTY_ID_PRIORITY);
1217
1218                 if (new_priority != old_priority) {
1219                         if (new_priority > old_priority)
1220                                 network = value;
1221                         continue;
1222                 }
1223
1224                 old_strength = connman_network_get_uint8(network,
1225                                                 CONNMAN_PROPERTY_ID_STRENGTH);
1226                 new_strength = connman_network_get_uint8(value,
1227                                                 CONNMAN_PROPERTY_ID_STRENGTH);
1228
1229                 if (new_strength > old_strength)
1230                         network = value;
1231         }
1232
1233         if (network != NULL) {
1234                 int err;
1235
1236                 err = connman_network_connect(network);
1237                 if (err == 0 || err == -EINPROGRESS)
1238                         return;
1239         }
1240
1241         if (count > 0)
1242                 return;
1243
1244         if (device->driver && device->driver->scan)
1245                 device->driver->scan(device);
1246 }
1247
1248 static void mark_network_unavailable(gpointer key, gpointer value,
1249                                                         gpointer user_data)
1250 {
1251         struct connman_network *network = value;
1252
1253         if (connman_network_get_connected(network) == TRUE)
1254                 return;
1255
1256         connman_network_set_available(network, FALSE);
1257 }
1258
1259 static gboolean remove_unavailable_network(gpointer key, gpointer value,
1260                                                         gpointer user_data)
1261 {
1262         struct connman_network *network = value;
1263
1264         if (connman_network_get_connected(network) == TRUE)
1265                 return FALSE;
1266
1267         if (connman_network_get_remember(network) == TRUE)
1268                 return FALSE;
1269
1270         if (connman_network_get_available(network) == TRUE)
1271                 return FALSE;
1272
1273         return TRUE;
1274 }
1275
1276 /**
1277  * connman_device_set_scanning:
1278  * @device: device structure
1279  * @scanning: scanning state
1280  *
1281  * Change scanning state of device
1282  */
1283 int connman_device_set_scanning(struct connman_device *device,
1284                                                 connman_bool_t scanning)
1285 {
1286         DBusMessage *signal;
1287         DBusMessageIter entry, value;
1288         const char *key = "Scanning";
1289
1290         DBG("driver %p scanning %d", device, scanning);
1291
1292         if (!device->driver || !device->driver->scan)
1293                 return -EINVAL;
1294
1295         if (device->scanning == scanning)
1296                 return -EALREADY;
1297
1298         device->scanning = scanning;
1299
1300         signal = dbus_message_new_signal(device->element.path,
1301                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
1302         if (signal == NULL)
1303                 return 0;
1304
1305         dbus_message_iter_init_append(signal, &entry);
1306
1307         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
1308
1309         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
1310                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
1311         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
1312         dbus_message_iter_close_container(&entry, &value);
1313
1314         g_dbus_send_message(connection, signal);
1315
1316         if (scanning == TRUE) {
1317                 if (device->scan_timeout > 0) {
1318                         g_source_remove(device->scan_timeout);
1319                         device->scan_timeout = 0;
1320                 }
1321
1322                 if (device->scan_interval > 0) {
1323                         guint interval = device->scan_interval;
1324                         device->scan_timeout = g_timeout_add_seconds(interval,
1325                                                 device_scan_trigger, device);
1326                 }
1327
1328                 g_hash_table_foreach(device->networks,
1329                                         mark_network_unavailable, NULL);
1330                 return 0;
1331         }
1332
1333         g_hash_table_foreach_remove(device->networks,
1334                                         remove_unavailable_network, NULL);
1335
1336         if (device->connections > 0)
1337                 return 0;
1338
1339         if (device->disconnected == TRUE)
1340                 return 0;
1341
1342         if (device->policy != CONNMAN_DEVICE_POLICY_AUTO)
1343                 return 0;
1344
1345         connect_known_network(device);
1346
1347         return 0;
1348 }
1349
1350 /**
1351  * connman_device_set_disconnected:
1352  * @device: device structure
1353  * @disconnected: disconnected state
1354  *
1355  * Change disconnected state of device (only for device with networks)
1356  */
1357 int connman_device_set_disconnected(struct connman_device *device,
1358                                                 connman_bool_t disconnected)
1359 {
1360         DBG("driver %p disconnected %d", device, disconnected);
1361
1362         switch (device->mode) {
1363         case CONNMAN_DEVICE_MODE_UNKNOWN:
1364         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1365                 return -EINVAL;
1366         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1367         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1368                 break;
1369         }
1370
1371         if (device->disconnected == disconnected)
1372                 return -EALREADY;
1373
1374         device->disconnected = disconnected;
1375
1376         return 0;
1377 }
1378
1379 /**
1380  * connman_device_set_string:
1381  * @device: device structure
1382  * @key: unique identifier
1383  * @value: string value
1384  *
1385  * Set string value for specific key
1386  */
1387 int connman_device_set_string(struct connman_device *device,
1388                                         const char *key, const char *value)
1389 {
1390         DBG("device %p key %s value %s", device, key, value);
1391
1392         if (g_str_equal(key, "Address") == TRUE) {
1393                 g_free(device->address);
1394                 device->address = g_strdup(value);
1395         } else if (g_str_equal(key, "Name") == TRUE) {
1396                 g_free(device->name);
1397                 device->name = g_strdup(value);
1398         } else if (g_str_equal(key, "Node") == TRUE) {
1399                 g_free(device->node);
1400                 device->node = g_strdup(value);
1401         }
1402
1403         return connman_element_set_string(&device->element, key, value);
1404 }
1405
1406 /**
1407  * connman_device_get_string:
1408  * @device: device structure
1409  * @key: unique identifier
1410  *
1411  * Get string value for specific key
1412  */
1413 const char *connman_device_get_string(struct connman_device *device,
1414                                                         const char *key)
1415 {
1416         DBG("device %p key %s", device, key);
1417
1418         if (g_str_equal(key, "Address") == TRUE)
1419                 return device->address;
1420         else if (g_str_equal(key, "Name") == TRUE)
1421                 return device->name;
1422         else if (g_str_equal(key, "Node") == TRUE)
1423                 return device->node;
1424
1425         return connman_element_get_string(&device->element, key);
1426 }
1427
1428 static void set_offlinemode(struct connman_element *element, gpointer user_data)
1429 {
1430         struct connman_device *device = element->device;
1431         connman_bool_t offlinemode = GPOINTER_TO_UINT(user_data);
1432         connman_bool_t powered;
1433
1434         DBG("element %p name %s", element, element->name);
1435
1436         if (device == NULL)
1437                 return;
1438
1439         powered = (offlinemode == TRUE) ? FALSE : TRUE;
1440
1441         if (device->powered == powered)
1442                 return;
1443
1444         set_powered(device, powered);
1445 }
1446
1447 int __connman_device_set_offlinemode(connman_bool_t offlinemode)
1448 {
1449         DBG("offlinmode %d", offlinemode);
1450
1451         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
1452                         set_offlinemode, GUINT_TO_POINTER(offlinemode));
1453
1454         __connman_notifier_offline_mode(offlinemode);
1455
1456         return 0;
1457 }
1458
1459 void __connman_device_increase_connections(struct connman_device *device)
1460 {
1461         device->connections++;
1462 }
1463
1464 void __connman_device_decrease_connections(struct connman_device *device)
1465 {
1466         device->connections--;
1467 }
1468
1469 /**
1470  * connman_device_add_network:
1471  * @device: device structure
1472  * @network: network structure
1473  *
1474  * Add new network to the device
1475  */
1476 int connman_device_add_network(struct connman_device *device,
1477                                         struct connman_network *network)
1478 {
1479         const char *identifier = connman_network_get_identifier(network);
1480         int err;
1481
1482         DBG("device %p network %p", device, network);
1483
1484         switch (device->mode) {
1485         case CONNMAN_DEVICE_MODE_UNKNOWN:
1486         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1487                 return -EINVAL;
1488         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1489         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1490                 break;
1491         }
1492
1493         __connman_network_set_device(network, device);
1494
1495         __connman_storage_load_network(network);
1496
1497         err = connman_element_register((struct connman_element *) network,
1498                                                         &device->element);
1499         if (err < 0) {
1500                 __connman_network_set_device(network, NULL);
1501                 return err;
1502         }
1503
1504         g_hash_table_insert(device->networks, g_strdup(identifier),
1505                                                                 network);
1506
1507         return 0;
1508 }
1509
1510 /**
1511  * connman_device_get_network:
1512  * @device: device structure
1513  * @identifier: network identifier
1514  *
1515  * Get network for given identifier
1516  */
1517 struct connman_network *connman_device_get_network(struct connman_device *device,
1518                                                         const char *identifier)
1519 {
1520         DBG("device %p identifier %s", device, identifier);
1521
1522         return g_hash_table_lookup(device->networks, identifier);
1523 }
1524
1525 /**
1526  * connman_device_remove_network:
1527  * @device: device structure
1528  * @identifier: network identifier
1529  *
1530  * Remove network for given identifier
1531  */
1532 int connman_device_remove_network(struct connman_device *device,
1533                                                         const char *identifier)
1534 {
1535         DBG("device %p identifier %s", device, identifier);
1536
1537         g_hash_table_remove(device->networks, identifier);
1538
1539         return 0;
1540 }
1541
1542 void __connman_device_set_network(struct connman_device *device,
1543                                         struct connman_network *network)
1544 {
1545         const char *name;
1546
1547         if (network != NULL) {
1548                 name = connman_network_get_string(network,
1549                                                 CONNMAN_PROPERTY_ID_NAME);
1550                 device->last_network = g_strdup(name);
1551         }
1552
1553         device->network = network;
1554 }
1555
1556 /**
1557  * connman_device_register:
1558  * @device: device structure
1559  *
1560  * Register device with the system
1561  */
1562 int connman_device_register(struct connman_device *device)
1563 {
1564         __connman_storage_load_device(device);
1565
1566         switch (device->mode) {
1567         case CONNMAN_DEVICE_MODE_UNKNOWN:
1568         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1569                 break;
1570         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1571         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1572                 __connman_storage_init_network(device);
1573                 break;
1574         }
1575
1576         return connman_element_register(&device->element, NULL);
1577 }
1578
1579 /**
1580  * connman_device_unregister:
1581  * @device: device structure
1582  *
1583  * Unregister device with the system
1584  */
1585 void connman_device_unregister(struct connman_device *device)
1586 {
1587         __connman_storage_save_device(device);
1588
1589         connman_element_unregister(&device->element);
1590 }
1591
1592 /**
1593  * connman_device_get_data:
1594  * @device: device structure
1595  *
1596  * Get private device data pointer
1597  */
1598 void *connman_device_get_data(struct connman_device *device)
1599 {
1600         return device->driver_data;
1601 }
1602
1603 /**
1604  * connman_device_set_data:
1605  * @device: device structure
1606  * @data: data pointer
1607  *
1608  * Set private device data pointer
1609  */
1610 void connman_device_set_data(struct connman_device *device, void *data)
1611 {
1612         device->driver_data = data;
1613 }
1614
1615 static gboolean match_driver(struct connman_device *device,
1616                                         struct connman_device_driver *driver)
1617 {
1618         if (device->type == driver->type ||
1619                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1620                 return TRUE;
1621
1622         return FALSE;
1623 }
1624
1625 static int device_probe(struct connman_element *element)
1626 {
1627         struct connman_device *device = element->device;
1628         GSList *list;
1629
1630         DBG("element %p name %s", element, element->name);
1631
1632         if (device == NULL)
1633                 return -ENODEV;
1634
1635         if (device->driver != NULL)
1636                 return -EALREADY;
1637
1638         for (list = driver_list; list; list = list->next) {
1639                 struct connman_device_driver *driver = list->data;
1640
1641                 if (match_driver(device, driver) == FALSE)
1642                         continue;
1643
1644                 DBG("driver %p name %s", driver, driver->name);
1645
1646                 if (driver->probe(device) == 0) {
1647                         device->driver = driver;
1648                         break;
1649                 }
1650         }
1651
1652         if (device->driver == NULL)
1653                 return -ENODEV;
1654
1655         return setup_device(device);
1656 }
1657
1658 static void device_remove(struct connman_element *element)
1659 {
1660         struct connman_device *device = element->device;
1661
1662         DBG("element %p name %s", element, element->name);
1663
1664         if (device == NULL)
1665                 return;
1666
1667         if (device->driver == NULL)
1668                 return;
1669
1670         remove_device(device);
1671 }
1672
1673 static struct connman_driver device_driver = {
1674         .name           = "device",
1675         .type           = CONNMAN_ELEMENT_TYPE_DEVICE,
1676         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
1677         .probe          = device_probe,
1678         .remove         = device_remove,
1679 };
1680
1681 static int device_load(struct connman_device *device)
1682 {
1683         GKeyFile *keyfile;
1684         gchar *pathname, *data = NULL;
1685         gsize length;
1686         char *str;
1687         int val;
1688
1689         DBG("device %p", device);
1690
1691         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1692                                                         device->element.name);
1693         if (pathname == NULL)
1694                 return -ENOMEM;
1695
1696         keyfile = g_key_file_new();
1697
1698         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1699                 g_free(pathname);
1700                 return -ENOENT;
1701         }
1702
1703         g_free(pathname);
1704
1705         if (g_key_file_load_from_data(keyfile, data, length,
1706                                                         0, NULL) == FALSE) {
1707                 g_free(data);
1708                 return -EILSEQ;
1709         }
1710
1711         g_free(data);
1712
1713         str = g_key_file_get_string(keyfile, "Configuration", "Policy", NULL);
1714         if (str != NULL) {
1715                 device->policy = string2policy(str);
1716                 g_free(str);
1717         }
1718
1719         val = g_key_file_get_integer(keyfile, "Configuration",
1720                                                         "Priority", NULL);
1721         if (val > 0)
1722                 device->priority = val;
1723
1724         switch (device->mode) {
1725         case CONNMAN_DEVICE_MODE_UNKNOWN:
1726         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1727                 break;
1728         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1729         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1730                 val = g_key_file_get_integer(keyfile, "Configuration",
1731                                                         "ScanInterval", NULL);
1732                 if (val > 0)
1733                         device->scan_interval = val;
1734                 break;
1735         }
1736
1737 #if 0
1738         str = g_key_file_get_string(keyfile, "Configuration",
1739                                                         "LastNetwork", NULL);
1740         if (str != NULL)
1741                 device->last_network = str;
1742 #endif
1743
1744         g_key_file_free(keyfile);
1745
1746         return 0;
1747 }
1748
1749 static int device_save(struct connman_device *device)
1750 {
1751         GKeyFile *keyfile;
1752         gchar *pathname, *data = NULL;
1753         gsize length;
1754         const char *str;
1755
1756         DBG("device %p", device);
1757
1758         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1759                                                         device->element.name);
1760         if (pathname == NULL)
1761                 return -ENOMEM;
1762
1763         keyfile = g_key_file_new();
1764
1765         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1766                 goto update;
1767
1768         if (length > 0) {
1769                 if (g_key_file_load_from_data(keyfile, data, length,
1770                                                         0, NULL) == FALSE)
1771                         goto done;
1772         }
1773
1774         g_free(data);
1775
1776 update:
1777         str = policy2string(device->policy);
1778         if (str != NULL)
1779                 g_key_file_set_string(keyfile, "Configuration", "Policy", str);
1780
1781         if (device->priority > 0)
1782                 g_key_file_set_integer(keyfile, "Configuration",
1783                                                 "Priority", device->priority);
1784
1785         switch (device->mode) {
1786         case CONNMAN_DEVICE_MODE_UNKNOWN:
1787         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1788                 break;
1789         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1790         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1791                 if (device->scan_interval > 0)
1792                         g_key_file_set_integer(keyfile, "Configuration",
1793                                         "ScanInterval", device->scan_interval);
1794                 break;
1795         }
1796
1797         if (device->last_network != NULL)
1798                 g_key_file_set_string(keyfile, "Configuration",
1799                                         "LastNetwork", device->last_network);
1800
1801         data = g_key_file_to_data(keyfile, &length, NULL);
1802
1803         g_file_set_contents(pathname, data, length, NULL);
1804
1805 done:
1806         g_free(data);
1807
1808         g_key_file_free(keyfile);
1809
1810         g_free(pathname);
1811
1812         if (device->network != NULL)
1813                 __connman_storage_save_network(device->network);
1814
1815         return 0;
1816 }
1817
1818 static struct connman_storage device_storage = {
1819         .name           = "device",
1820         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1821         .device_load    = device_load,
1822         .device_save    = device_save,
1823 };
1824
1825 int __connman_device_init(void)
1826 {
1827         DBG("");
1828
1829         connection = connman_dbus_get_connection();
1830
1831         if (connman_storage_register(&device_storage) < 0)
1832                 connman_error("Failed to register device storage");
1833
1834         return connman_driver_register(&device_driver);
1835 }
1836
1837 void __connman_device_cleanup(void)
1838 {
1839         DBG("");
1840
1841         connman_driver_unregister(&device_driver);
1842
1843         connman_storage_unregister(&device_storage);
1844
1845         dbus_connection_unref(connection);
1846 }