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 <gdbus.h>
  28
  29 #include "connman.h"
  30
  31 struct connman_device {
  32         struct connman_element element;
  33         enum connman_device_type type;
  34         enum connman_device_mode mode;
  35         enum connman_device_policy policy;
  36         connman_bool_t powered;
  37         connman_bool_t carrier;
  38         connman_bool_t scanning;
  39         char *name;
  40         char *node;
  41         char *interface;
  42
  43         struct connman_device_driver *driver;
  44         void *driver_data;
  45
  46         connman_bool_t registered;
  47
  48         GHashTable *networks;
  49 };
  50
  51 static const char *type2description(enum connman_device_type type)
  52 {
  53         switch (type) {
  54         case CONNMAN_DEVICE_TYPE_UNKNOWN:
  55         case CONNMAN_DEVICE_TYPE_VENDOR:
  56                 break;
  57         case CONNMAN_DEVICE_TYPE_ETHERNET:
  58                 return "Ethernet";
  59         case CONNMAN_DEVICE_TYPE_WIFI:
  60                 return "Wireless";
  61         case CONNMAN_DEVICE_TYPE_WIMAX:
  62                 return "WiMAX";
  63         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
  64                 return "Bluetooth";
  65         case CONNMAN_DEVICE_TYPE_HSO:
  66         case CONNMAN_DEVICE_TYPE_NOZOMI:
  67         case CONNMAN_DEVICE_TYPE_HUAWEI:
  68         case CONNMAN_DEVICE_TYPE_NOVATEL:
  69                 return "Cellular";
  70         }
  71
  72         return NULL;
  73 }
  74
  75 static const char *type2string(enum connman_device_type type)
  76 {
  77         switch (type) {
  78         case CONNMAN_DEVICE_TYPE_UNKNOWN:
  79         case CONNMAN_DEVICE_TYPE_VENDOR:
  80                 break;
  81         case CONNMAN_DEVICE_TYPE_ETHERNET:
  82                 return "ethernet";
  83         case CONNMAN_DEVICE_TYPE_WIFI:
  84                 return "wifi";
  85         case CONNMAN_DEVICE_TYPE_WIMAX:
  86                 return "wimax";
  87         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
  88                 return "bluetooth";
  89         case CONNMAN_DEVICE_TYPE_HSO:
  90         case CONNMAN_DEVICE_TYPE_HUAWEI:
  91         case CONNMAN_DEVICE_TYPE_NOZOMI:
  92         case CONNMAN_DEVICE_TYPE_NOVATEL:
  93                 return "cellular";
  94         }
  95
  96         return NULL;
  97 }
  98
  99 static const char *policy2string(enum connman_device_policy policy)
 100 {
 101         switch (policy) {
 102         case CONNMAN_DEVICE_POLICY_UNKNOWN:
 103                 break;
 104         case CONNMAN_DEVICE_POLICY_IGNORE:
 105                 return "ignore";
 106         case CONNMAN_DEVICE_POLICY_OFF:
 107                 return "off";
 108         case CONNMAN_DEVICE_POLICY_AUTO:
 109                 return "auto";
 110         case CONNMAN_DEVICE_POLICY_MANUAL:
 111                 return "manual";
 112         }
 113
 114         return NULL;
 115 }
 116
 117 static enum connman_device_policy string2policy(const char *policy)
 118 {
 119         if (g_str_equal(policy, "ignore") == TRUE)
 120                 return CONNMAN_DEVICE_POLICY_IGNORE;
 121         else if (g_str_equal(policy, "off") == TRUE)
 122                 return CONNMAN_DEVICE_POLICY_OFF;
 123         else if (g_str_equal(policy, "auto") == TRUE)
 124                 return CONNMAN_DEVICE_POLICY_AUTO;
 125         else if (g_str_equal(policy, "manual") == TRUE)
 126                 return CONNMAN_DEVICE_POLICY_MANUAL;
 127         else
 128                 return CONNMAN_DEVICE_POLICY_UNKNOWN;
 129 }
 130
 131 static int set_powered(struct connman_device *device, connman_bool_t powered)
 132 {
 133         struct connman_device_driver *driver = device->driver;
 134         int err;
 135
 136         DBG("device %p powered %d", device, powered);
 137
 138         if (!driver)
 139                 return -EINVAL;
 140
 141         if (powered == TRUE) {
 142                 if (driver->enable)
 143                         err = driver->enable(device);
 144                 else
 145                         err = -EINVAL;
 146         } else {
 147                 g_hash_table_remove_all(device->networks);
 148
 149                 if (driver->disable)
 150                         err = driver->disable(device);
 151                 else
 152                         err = -EINVAL;
 153         }
 154
 155         return err;
 156 }
 157
 158 static int set_policy(DBusConnection *connection,
 159                                 struct connman_device *device,
 160                                         enum connman_device_policy policy)
 161 {
 162         DBusMessage *signal;
 163         DBusMessageIter entry, value;
 164         const char *str, *key = "Policy";
 165         int err = 0;
 166
 167         DBG("device %p policy %d", device, policy);
 168
 169         if (device->policy == policy)
 170                 return 0;
 171
 172         switch (policy) {
 173         case CONNMAN_DEVICE_POLICY_UNKNOWN:
 174                 return -EINVAL;
 175         case CONNMAN_DEVICE_POLICY_IGNORE:
 176                 break;
 177         case CONNMAN_DEVICE_POLICY_OFF:
 178                 if (device->powered == TRUE)
 179                         err = set_powered(device, FALSE);
 180                 break;
 181         case CONNMAN_DEVICE_POLICY_AUTO:
 182         case CONNMAN_DEVICE_POLICY_MANUAL:
 183                 if (device->powered == FALSE)
 184                         err = set_powered(device, TRUE);
 185                 break;
 186         }
 187
 188         if (err < 0)
 189                 return err;
 190
 191         device->policy = policy;
 192
 193         signal = dbus_message_new_signal(device->element.path,
 194                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 195         if (signal == NULL)
 196                 return 0;
 197
 198         dbus_message_iter_init_append(signal, &entry);
 199
 200         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 201
 202         str = policy2string(policy);
 203
 204         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 205                                         DBUS_TYPE_STRING_AS_STRING, &value);
 206         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
 207         dbus_message_iter_close_container(&entry, &value);
 208
 209         g_dbus_send_message(connection, signal);
 210
 211         return 0;
 212 }
 213
 214 static void append_networks(struct connman_device *device,
 215                                                 DBusMessageIter *entry)
 216 {
 217         DBusMessageIter value, iter;
 218         const char *key = "Networks";
 219
 220         dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
 221
 222         dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
 223                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
 224                                                                 &value);
 225
 226         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 227                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
 228         __connman_element_list((struct connman_element *) device,
 229                                         CONNMAN_ELEMENT_TYPE_NETWORK, &iter);
 230         dbus_message_iter_close_container(&value, &iter);
 231
 232         dbus_message_iter_close_container(entry, &value);
 233 }
 234
 235 static DBusMessage *get_properties(DBusConnection *conn,
 236                                         DBusMessage *msg, void *data)
 237 {
 238         struct connman_device *device = data;
 239         DBusMessage *reply;
 240         DBusMessageIter array, dict, entry;
 241         const char *str;
 242
 243         DBG("conn %p", conn);
 244
 245         reply = dbus_message_new_method_return(msg);
 246         if (reply == NULL)
 247                 return NULL;
 248
 249         dbus_message_iter_init_append(reply, &array);
 250
 251         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
 252                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 253                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 254                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 255
 256         str = type2description(device->type);
 257         if (str != NULL && device->interface != NULL) {
 258                 char *name = g_strdup_printf("%s (%s)", str, device->interface);
 259                 if (name != NULL)
 260                         connman_dbus_dict_append_variant(&dict, "Name",
 261                                                 DBUS_TYPE_STRING, &name);
 262                 g_free(name);
 263         }
 264
 265         str = type2string(device->type);
 266         if (str != NULL)
 267                 connman_dbus_dict_append_variant(&dict, "Type",
 268                                                 DBUS_TYPE_STRING, &str);
 269
 270         if (device->interface != NULL)
 271                 connman_dbus_dict_append_variant(&dict, "Interface",
 272                                         DBUS_TYPE_STRING, &device->interface);
 273
 274         str = policy2string(device->policy);
 275         if (str != NULL)
 276                 connman_dbus_dict_append_variant(&dict, "Policy",
 277                                                 DBUS_TYPE_STRING, &str);
 278
 279         connman_dbus_dict_append_variant(&dict, "Powered",
 280                                         DBUS_TYPE_BOOLEAN, &device->powered);
 281
 282         if (device->driver && device->driver->scan)
 283                 connman_dbus_dict_append_variant(&dict, "Scanning",
 284                                         DBUS_TYPE_BOOLEAN, &device->scanning);
 285
 286         switch (device->mode) {
 287         case CONNMAN_DEVICE_MODE_UNKNOWN:
 288         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 289                 break;
 290         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 291         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 292                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
 293                                                                 NULL, &entry);
 294                 append_networks(device, &entry);
 295                 dbus_message_iter_close_container(&dict, &entry);
 296                 break;
 297         }
 298
 299         dbus_message_iter_close_container(&array, &dict);
 300
 301         return reply;
 302 }
 303
 304 static DBusMessage *set_property(DBusConnection *conn,
 305                                         DBusMessage *msg, void *data)
 306 {
 307         struct connman_device *device = data;
 308         DBusMessageIter iter, value;
 309         const char *name;
 310
 311         DBG("conn %p", conn);
 312
 313         if (dbus_message_iter_init(msg, &iter) == FALSE)
 314                 return __connman_error_invalid_arguments(msg);
 315
 316         dbus_message_iter_get_basic(&iter, &name);
 317         dbus_message_iter_next(&iter);
 318         dbus_message_iter_recurse(&iter, &value);
 319
 320         if (__connman_security_check_privileges(msg) < 0)
 321                 return __connman_error_permission_denied(msg);
 322
 323         if (g_str_equal(name, "Powered") == TRUE) {
 324                 connman_bool_t powered;
 325                 int err;
 326
 327                 dbus_message_iter_get_basic(&value, &powered);
 328
 329                 if (device->powered == powered)
 330                         return __connman_error_invalid_arguments(msg);
 331
 332                 err = set_powered(device, powered);
 333                 if (err < 0 && err != -EINPROGRESS)
 334                         return __connman_error_failed(msg);
 335         } else if (g_str_equal(name, "Policy") == TRUE) {
 336                 enum connman_device_policy policy;
 337                 const char *str;
 338                 int err;
 339
 340                 dbus_message_iter_get_basic(&value, &str);
 341                 policy = string2policy(str);
 342                 if (policy == CONNMAN_DEVICE_POLICY_UNKNOWN)
 343                         return __connman_error_invalid_arguments(msg);
 344
 345                 err = set_policy(conn, device, policy);
 346                 if (err < 0)
 347                         return __connman_error_failed(msg);
 348         }
 349
 350         __connman_storage_save_device(device);
 351
 352         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 353 }
 354
 355 static DBusMessage *create_network(DBusConnection *conn,
 356                                         DBusMessage *msg, void *data)
 357 {
 358         DBG("conn %p", conn);
 359
 360         if (__connman_security_check_privileges(msg) < 0)
 361                 return __connman_error_permission_denied(msg);
 362
 363         return __connman_error_invalid_arguments(msg);
 364 }
 365
 366 static DBusMessage *remove_network(DBusConnection *conn,
 367                                         DBusMessage *msg, void *data)
 368 {
 369         DBG("conn %p", conn);
 370
 371         if (__connman_security_check_privileges(msg) < 0)
 372                 return __connman_error_permission_denied(msg);
 373
 374         return __connman_error_invalid_arguments(msg);
 375 }
 376
 377 static DBusMessage *propose_scan(DBusConnection *conn,
 378                                         DBusMessage *msg, void *data)
 379 {
 380         struct connman_device *device = data;
 381         int err;
 382
 383         DBG("conn %p", conn);
 384
 385         switch (device->mode) {
 386         case CONNMAN_DEVICE_MODE_UNKNOWN:
 387         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 388                 return __connman_error_not_supported(msg);
 389         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 390         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 391                 break;
 392         }
 393
 394         if (!device->driver || !device->driver->scan)
 395                 return __connman_error_not_supported(msg);
 396
 397         if (device->powered == FALSE)
 398                 return __connman_error_failed(msg);
 399
 400         err = device->driver->scan(device);
 401         if (err < 0)
 402                 return __connman_error_failed(msg);
 403
 404         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 405 }
 406
 407 static GDBusMethodTable device_methods[] = {
 408         { "GetProperties", "",      "a{sv}", get_properties },
 409         { "SetProperty",   "sv",    "",      set_property   },
 410         { "CreateNetwork", "a{sv}", "o",     create_network },
 411         { "RemoveNetwork", "o",     "",      remove_network },
 412         { "ProposeScan",   "",      "",      propose_scan   },
 413         { },
 414 };
 415
 416 static GDBusSignalTable device_signals[] = {
 417         { "PropertyChanged", "sv" },
 418         { },
 419 };
 420
 421 static DBusConnection *connection;
 422
 423 static void append_devices(DBusMessageIter *entry)
 424 {
 425         DBusMessageIter value, iter;
 426         const char *key = "Devices";
 427
 428         dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
 429
 430         dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
 431                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
 432                                                                 &value);
 433
 434         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 435                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
 436         __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
 437         dbus_message_iter_close_container(&value, &iter);
 438
 439         dbus_message_iter_close_container(entry, &value);
 440 }
 441
 442 static void emit_devices_signal(void)
 443 {
 444         DBusMessage *signal;
 445         DBusMessageIter entry;
 446
 447         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
 448                                 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
 449         if (signal == NULL)
 450                 return;
 451
 452         dbus_message_iter_init_append(signal, &entry);
 453
 454         append_devices(&entry);
 455
 456         g_dbus_send_message(connection, signal);
 457 }
 458
 459 static int register_interface(struct connman_element *element)
 460 {
 461         struct connman_device *device = element->device;
 462
 463         DBG("element %p name %s", element, element->name);
 464
 465         if (g_dbus_register_interface(connection, element->path,
 466                                         CONNMAN_DEVICE_INTERFACE,
 467                                         device_methods, device_signals,
 468                                         NULL, device, NULL) == FALSE) {
 469                 connman_error("Failed to register %s device", element->path);
 470                 return -EIO;
 471         }
 472
 473         device->registered = TRUE;
 474
 475         emit_devices_signal();
 476
 477         return 0;
 478 }
 479
 480 static void unregister_interface(struct connman_element *element)
 481 {
 482         struct connman_device *device = element->device;
 483
 484         DBG("element %p name %s", element, element->name);
 485
 486         device->registered = FALSE;
 487
 488         emit_devices_signal();
 489
 490         g_dbus_unregister_interface(connection, element->path,
 491                                                 CONNMAN_DEVICE_INTERFACE);
 492 }
 493
 494 static void device_enable(struct connman_device *device)
 495 {
 496         DBG("device %p", device);
 497
 498         if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE ||
 499                                 device->policy == CONNMAN_DEVICE_POLICY_OFF)
 500                 return;
 501
 502         if (device->powered == TRUE)
 503                 return;
 504
 505         if (device->driver->enable)
 506                 device->driver->enable(device);
 507 }
 508
 509 static void device_disable(struct connman_device *device)
 510 {
 511         DBG("device %p", device);
 512
 513         if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE)
 514                 return;
 515
 516         if (device->powered == FALSE)
 517                 return;
 518
 519         g_hash_table_remove_all(device->networks);
 520
 521         if (device->driver->disable)
 522                 device->driver->disable(device);
 523 }
 524
 525 static int setup_device(struct connman_device *device)
 526 {
 527         int err;
 528
 529         DBG("device %p", device);
 530
 531         err = register_interface(&device->element);
 532         if (err < 0) {
 533                 if (device->driver->remove)
 534                         device->driver->remove(device);
 535                 device->driver = NULL;
 536                 return err;
 537         }
 538
 539         device_enable(device);
 540
 541         return 0;
 542 }
 543
 544 static void probe_driver(struct connman_element *element, gpointer user_data)
 545 {
 546         struct connman_device_driver *driver = user_data;
 547
 548         DBG("element %p name %s", element, element->name);
 549
 550         if (element->device == NULL)
 551                 return;
 552
 553         if (driver->probe(element->device) < 0)
 554                 return;
 555
 556         element->device->driver = driver;
 557
 558         setup_device(element->device);
 559 }
 560
 561 static void remove_device(struct connman_device *device)
 562 {
 563         DBG("device %p", device);
 564
 565         device_disable(device);
 566
 567         unregister_interface(&device->element);
 568
 569         if (device->driver->remove)
 570                 device->driver->remove(device);
 571
 572         device->driver = NULL;
 573 }
 574
 575 static void remove_driver(struct connman_element *element, gpointer user_data)
 576 {
 577         struct connman_device_driver *driver = user_data;
 578
 579         DBG("element %p name %s", element, element->name);
 580
 581         if (element->device == NULL)
 582                 return;
 583
 584         if (element->device->driver == driver)
 585                 remove_device(element->device);
 586 }
 587
 588 connman_bool_t __connman_device_has_driver(struct connman_device *device)
 589 {
 590         if (device == NULL || device->driver == NULL)
 591                 return FALSE;
 592
 593         return device->registered;
 594 }
 595
 596 static GSList *driver_list = NULL;
 597
 598 static gint compare_priority(gconstpointer a, gconstpointer b)
 599 {
 600         const struct connman_device_driver *driver1 = a;
 601         const struct connman_device_driver *driver2 = b;
 602
 603         return driver2->priority - driver1->priority;
 604 }
 605
 606 /**
 607  * connman_device_driver_register:
 608  * @driver: device driver definition
 609  *
 610  * Register a new device driver
 611  *
 612  * Returns: %0 on success
 613  */
 614 int connman_device_driver_register(struct connman_device_driver *driver)
 615 {
 616         DBG("driver %p name %s", driver, driver->name);
 617
 618         driver_list = g_slist_insert_sorted(driver_list, driver,
 619                                                         compare_priority);
 620
 621         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
 622                                                 probe_driver, driver);
 623
 624         return 0;
 625 }
 626
 627 /**
 628  * connman_device_driver_unregister:
 629  * @driver: device driver definition
 630  *
 631  * Remove a previously registered device driver
 632  */
 633 void connman_device_driver_unregister(struct connman_device_driver *driver)
 634 {
 635         DBG("driver %p name %s", driver, driver->name);
 636
 637         driver_list = g_slist_remove(driver_list, driver);
 638
 639         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
 640                                                 remove_driver, driver);
 641 }
 642
 643 static void unregister_network(gpointer data)
 644 {
 645         struct connman_network *network = data;
 646
 647         DBG("network %p", network);
 648
 649         connman_element_unregister((struct connman_element *) network);
 650
 651         connman_network_unref(network);
 652 }
 653
 654 static void device_destruct(struct connman_element *element)
 655 {
 656         struct connman_device *device = element->device;
 657
 658         DBG("element %p name %s", element, element->name);
 659
 660         g_free(device->node);
 661         g_free(device->name);
 662         g_free(device->interface);
 663
 664         g_hash_table_destroy(device->networks);
 665         device->networks = NULL;
 666 }
 667
 668 /**
 669  * connman_device_create:
 670  * @node: device node name (for example an address)
 671  * @type: device type
 672  *
 673  * Allocate a new device of given #type and assign the #node name to it.
 674  *
 675  * Returns: a newly-allocated #connman_device structure
 676  */
 677 struct connman_device *connman_device_create(const char *node,
 678                                                 enum connman_device_type type)
 679 {
 680         struct connman_device *device;
 681
 682         DBG("node %s type %d", node, type);
 683
 684         device = g_try_new0(struct connman_device, 1);
 685         if (device == NULL)
 686                 return NULL;
 687
 688         DBG("device %p", device);
 689
 690         device->element.refcount = 1;
 691
 692         device->element.name = g_strdup(node);
 693         device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
 694         device->element.index = -1;
 695
 696         switch (type) {
 697         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 698         case CONNMAN_DEVICE_TYPE_VENDOR:
 699         case CONNMAN_DEVICE_TYPE_WIFI:
 700         case CONNMAN_DEVICE_TYPE_WIMAX:
 701         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 702         case CONNMAN_DEVICE_TYPE_HSO:
 703         case CONNMAN_DEVICE_TYPE_NOZOMI:
 704         case CONNMAN_DEVICE_TYPE_HUAWEI:
 705         case CONNMAN_DEVICE_TYPE_NOVATEL:
 706                 device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
 707                 break;
 708         case CONNMAN_DEVICE_TYPE_ETHERNET:
 709                 device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_ETHERNET;
 710                 break;
 711         }
 712
 713         device->element.device = device;
 714         device->element.destruct = device_destruct;
 715
 716         device->type   = type;
 717         device->mode   = CONNMAN_DEVICE_MODE_UNKNOWN;
 718         device->policy = CONNMAN_DEVICE_POLICY_AUTO;
 719
 720         device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
 721                                                 g_free, unregister_network);
 722
 723         return device;
 724 }
 725
 726 /**
 727  * connman_device_ref:
 728  * @device: device structure
 729  *
 730  * Increase reference counter of device
 731  */
 732 struct connman_device *connman_device_ref(struct connman_device *device)
 733 {
 734         if (connman_element_ref(&device->element) == NULL)
 735                 return NULL;
 736
 737         return device;
 738 }
 739
 740 /**
 741  * connman_device_unref:
 742  * @device: device structure
 743  *
 744  * Decrease reference counter of device
 745  */
 746 void connman_device_unref(struct connman_device *device)
 747 {
 748         connman_element_unref(&device->element);
 749 }
 750
 751 /**
 752  * connman_device_get_name:
 753  * @device: device structure
 754  *
 755  * Get unique name of device
 756  */
 757 const char *connman_device_get_name(struct connman_device *device)
 758 {
 759         return device->element.name;
 760 }
 761
 762 /**
 763  * connman_device_get_path:
 764  * @device: device structure
 765  *
 766  * Get path name of device
 767  */
 768 const char *connman_device_get_path(struct connman_device *device)
 769 {
 770         return device->element.path;
 771 }
 772
 773 /**
 774  * connman_device_set_index:
 775  * @device: device structure
 776  * @index: index number
 777  *
 778  * Set index number of device
 779  */
 780 void connman_device_set_index(struct connman_device *device, int index)
 781 {
 782         device->element.index = index;
 783 }
 784
 785 /**
 786  * connman_device_get_index:
 787  * @device: device structure
 788  *
 789  * Get index number of device
 790  */
 791 int connman_device_get_index(struct connman_device *device)
 792 {
 793         return device->element.index;
 794 }
 795
 796 /**
 797  * connman_device_set_interface:
 798  * @device: device structure
 799  * @interface: interface name
 800  *
 801  * Set interface name of device
 802  */
 803 void connman_device_set_interface(struct connman_device *device,
 804                                                         const char *interface)
 805 {
 806         g_free(device->element.devname);
 807         device->element.devname = g_strdup(interface);
 808
 809         g_free(device->interface);
 810         device->interface = g_strdup(interface);
 811 }
 812
 813 /**
 814  * connman_device_get_interface:
 815  * @device: device structure
 816  *
 817  * Get interface name of device
 818  */
 819 const char *connman_device_get_interface(struct connman_device *device)
 820 {
 821         return device->interface;
 822 }
 823
 824 /**
 825  * connman_device_set_policy:
 826  * @device: device structure
 827  * @policy: power and connection policy
 828  *
 829  * Change power and connection policy of device
 830  */
 831 void connman_device_set_policy(struct connman_device *device,
 832                                         enum connman_device_policy policy)
 833 {
 834         device->policy = policy;
 835 }
 836
 837 /**
 838  * connman_device_set_mode:
 839  * @device: device structure
 840  * @mode: network mode
 841  *
 842  * Change network mode of device
 843  */
 844 void connman_device_set_mode(struct connman_device *device,
 845                                                 enum connman_device_mode mode)
 846 {
 847         device->mode = mode;
 848 }
 849
 850 /**
 851  * connman_device_set_powered:
 852  * @device: device structure
 853  * @powered: powered state
 854  *
 855  * Change power state of device
 856  */
 857 int connman_device_set_powered(struct connman_device *device,
 858                                                 connman_bool_t powered)
 859 {
 860         DBusMessage *signal;
 861         DBusMessageIter entry, value;
 862         const char *key = "Powered";
 863
 864         DBG("driver %p powered %d", device, powered);
 865
 866         if (device->powered == powered)
 867                 return -EALREADY;
 868
 869         device->powered = powered;
 870
 871         signal = dbus_message_new_signal(device->element.path,
 872                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 873         if (signal == NULL)
 874                 return 0;
 875
 876         dbus_message_iter_init_append(signal, &entry);
 877
 878         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 879
 880         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 881                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 882         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
 883         dbus_message_iter_close_container(&entry, &value);
 884
 885         g_dbus_send_message(connection, signal);
 886
 887         return 0;
 888 }
 889
 890 /**
 891  * connman_device_set_carrier:
 892  * @device: device structure
 893  * @carrier: carrier state
 894  *
 895  * Change carrier state of device (only for device without scanning)
 896  */
 897 int connman_device_set_carrier(struct connman_device *device,
 898                                                 connman_bool_t carrier)
 899 {
 900         DBG("driver %p carrier %d", device, carrier);
 901
 902         switch (device->mode) {
 903         case CONNMAN_DEVICE_MODE_UNKNOWN:
 904         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 905         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 906                 return -EINVAL;
 907         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 908                 break;
 909         }
 910
 911         if (device->carrier == carrier)
 912                 return -EALREADY;
 913
 914         device->carrier = carrier;
 915
 916         if (carrier == TRUE) {
 917                 struct connman_element *element;
 918
 919                 element = connman_element_create(NULL);
 920                 if (element != NULL) {
 921                         element->type    = CONNMAN_ELEMENT_TYPE_DHCP;
 922                         element->subtype = device->element.subtype;
 923                         element->index   = device->element.index;
 924
 925                         if (connman_element_register(element,
 926                                                         &device->element) < 0)
 927                                 connman_element_unref(element);
 928                 }
 929         } else
 930                 connman_element_unregister_children(&device->element);
 931
 932         return 0;
 933 }
 934
 935 /**
 936  * connman_device_set_scanning:
 937  * @device: device structure
 938  * @scanning: scanning state
 939  *
 940  * Change scanning state of device
 941  */
 942 int connman_device_set_scanning(struct connman_device *device,
 943                                                 connman_bool_t scanning)
 944 {
 945         DBusMessage *signal;
 946         DBusMessageIter entry, value;
 947         const char *key = "Scanning";
 948
 949         DBG("driver %p scanning %d", device, scanning);
 950
 951         if (!device->driver || !device->driver->scan)
 952                 return -EINVAL;
 953
 954         if (device->scanning == scanning)
 955                 return -EALREADY;
 956
 957         device->scanning = scanning;
 958
 959         signal = dbus_message_new_signal(device->element.path,
 960                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 961         if (signal == NULL)
 962                 return 0;
 963
 964         dbus_message_iter_init_append(signal, &entry);
 965
 966         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 967
 968         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 969                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 970         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
 971         dbus_message_iter_close_container(&entry, &value);
 972
 973         g_dbus_send_message(connection, signal);
 974
 975         return 0;
 976 }
 977
 978 /**
 979  * connman_device_set_string:
 980  * @device: device structure
 981  * @key: unique identifier
 982  * @value: string value
 983  *
 984  * Set string value for specific key
 985  */
 986 int connman_device_set_string(struct connman_device *device,
 987                                         const char *key, const char *value)
 988 {
 989         DBG("device %p key %s value %s", device, key, value);
 990
 991         if (g_str_equal(key, "Name") == TRUE) {
 992                 g_free(device->name);
 993                 device->name = g_strdup(value);
 994         } else if (g_str_equal(key, "Node") == TRUE) {
 995                 g_free(device->node);
 996                 device->node = g_strdup(value);
 997         }
 998
 999         return 0;
1000 }
1001
1002 /**
1003  * connman_device_get_string:
1004  * @device: device structure
1005  * @key: unique identifier
1006  *
1007  * Get string value for specific key
1008  */
1009 const char *connman_device_get_string(struct connman_device *device,
1010                                                         const char *key)
1011 {
1012         DBG("device %p key %s", device);
1013
1014         if (g_str_equal(key, "Name") == TRUE)
1015                 return device->name;
1016         else if (g_str_equal(key, "Node") == TRUE)
1017                 return device->node;
1018
1019         return NULL;
1020 }
1021
1022 /**
1023  * connman_device_add_network:
1024  * @device: device structure
1025  * @network: network structure
1026  *
1027  * Add new network to the device
1028  */
1029 int connman_device_add_network(struct connman_device *device,
1030                                         struct connman_network *network)
1031 {
1032         const char *identifier = connman_network_get_identifier(network);
1033         int err;
1034
1035         DBG("device %p network %p", device, network);
1036
1037         switch (device->mode) {
1038         case CONNMAN_DEVICE_MODE_UNKNOWN:
1039         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1040                 return -EINVAL;
1041         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1042         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1043                 break;
1044         }
1045
1046         __connman_network_set_device(network, device);
1047
1048         __connman_storage_load_network(network);
1049
1050         err = connman_element_register((struct connman_element *) network,
1051                                                         &device->element);
1052         if (err < 0) {
1053                 __connman_network_set_device(network, NULL);
1054                 return err;
1055         }
1056
1057         g_hash_table_insert(device->networks, g_strdup(identifier),
1058                                                                 network);
1059
1060         return 0;
1061 }
1062
1063 /**
1064  * connman_device_get_network:
1065  * @device: device structure
1066  * @identifier: network identifier
1067  *
1068  * Get network for given identifier
1069  */
1070 struct connman_network *connman_device_get_network(struct connman_device *device,
1071                                                         const char *identifier)
1072 {
1073         DBG("device %p identifier %s", device, identifier);
1074
1075         return g_hash_table_lookup(device->networks, identifier);
1076 }
1077
1078 /**
1079  * connman_device_remove_network:
1080  * @device: device structure
1081  * @identifier: network identifier
1082  *
1083  * Remove network for given identifier
1084  */
1085 int connman_device_remove_network(struct connman_device *device,
1086                                                         const char *identifier)
1087 {
1088         DBG("device %p identifier %s", device, identifier);
1089
1090         g_hash_table_remove(device->networks, identifier);
1091
1092         return 0;
1093 }
1094
1095 /**
1096  * connman_device_register:
1097  * @device: device structure
1098  *
1099  * Register device with the system
1100  */
1101 int connman_device_register(struct connman_device *device)
1102 {
1103         __connman_storage_load_device(device);
1104
1105         return connman_element_register(&device->element, NULL);
1106 }
1107
1108 /**
1109  * connman_device_unregister:
1110  * @device: device structure
1111  *
1112  * Unregister device with the system
1113  */
1114 void connman_device_unregister(struct connman_device *device)
1115 {
1116         __connman_storage_save_device(device);
1117
1118         connman_element_unregister(&device->element);
1119 }
1120
1121 /**
1122  * connman_device_get_data:
1123  * @device: device structure
1124  *
1125  * Get private device data pointer
1126  */
1127 void *connman_device_get_data(struct connman_device *device)
1128 {
1129         return device->driver_data;
1130 }
1131
1132 /**
1133  * connman_device_set_data:
1134  * @device: device structure
1135  * @data: data pointer
1136  *
1137  * Set private device data pointer
1138  */
1139 void connman_device_set_data(struct connman_device *device, void *data)
1140 {
1141         device->driver_data = data;
1142 }
1143
1144 static gboolean match_driver(struct connman_device *device,
1145                                         struct connman_device_driver *driver)
1146 {
1147         if (device->type == driver->type ||
1148                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1149                 return TRUE;
1150
1151         return FALSE;
1152 }
1153
1154 static int device_probe(struct connman_element *element)
1155 {
1156         struct connman_device *device = element->device;
1157         GSList *list;
1158
1159         DBG("element %p name %s", element, element->name);
1160
1161         if (device == NULL)
1162                 return -ENODEV;
1163
1164         for (list = driver_list; list; list = list->next) {
1165                 struct connman_device_driver *driver = list->data;
1166
1167                 if (match_driver(device, driver) == FALSE)
1168                         continue;
1169
1170                 DBG("driver %p name %s", driver, driver->name);
1171
1172                 if (driver->probe(device) == 0) {
1173                         device->driver = driver;
1174                         break;
1175                 }
1176         }
1177
1178         if (device->driver == NULL)
1179                 return -ENODEV;
1180
1181         return setup_device(device);
1182 }
1183
1184 static void device_remove(struct connman_element *element)
1185 {
1186         struct connman_device *device = element->device;
1187
1188         DBG("element %p name %s", element, element->name);
1189
1190         if (device == NULL)
1191                 return;
1192
1193         if (device->driver == NULL)
1194                 return;
1195
1196         remove_device(device);
1197 }
1198
1199 static struct connman_driver device_driver = {
1200         .name           = "device",
1201         .type           = CONNMAN_ELEMENT_TYPE_DEVICE,
1202         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
1203         .probe          = device_probe,
1204         .remove         = device_remove,
1205 };
1206
1207 static int device_load(struct connman_device *device)
1208 {
1209         GKeyFile *keyfile;
1210         gchar *pathname, *data = NULL;
1211         gsize length;
1212         char *str;
1213
1214         DBG("device %p", device);
1215
1216         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1217                                                         device->element.name);
1218         if (pathname == NULL)
1219                 return -ENOMEM;
1220
1221         keyfile = g_key_file_new();
1222
1223         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1224                 g_free(pathname);
1225                 return -ENOENT;
1226         }
1227
1228         g_free(pathname);
1229
1230         if (g_key_file_load_from_data(keyfile, data, length,
1231                                                         0, NULL) == FALSE) {
1232                 g_free(data);
1233                 return -EILSEQ;
1234         }
1235
1236         g_free(data);
1237
1238         str = g_key_file_get_string(keyfile, "Configuration", "Policy", NULL);
1239         if (str != NULL) {
1240                 device->policy = string2policy(str);
1241                 g_free(str);
1242         }
1243
1244         g_key_file_free(keyfile);
1245
1246         return 0;
1247 }
1248
1249 static int device_save(struct connman_device *device)
1250 {
1251         GKeyFile *keyfile;
1252         gchar *pathname, *data = NULL;
1253         gsize length;
1254         const char *str;
1255
1256         DBG("device %p", device);
1257
1258         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1259                                                         device->element.name);
1260         if (pathname == NULL)
1261                 return -ENOMEM;
1262
1263         keyfile = g_key_file_new();
1264
1265         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1266                 goto update;
1267
1268         if (length > 0) {
1269                 if (g_key_file_load_from_data(keyfile, data, length,
1270                                                         0, NULL) == FALSE)
1271                         goto done;
1272         }
1273
1274         g_free(data);
1275
1276 update:
1277         str = policy2string(device->policy);
1278         if (str != NULL)
1279                 g_key_file_set_string(keyfile, "Configuration", "Policy", str);
1280
1281         data = g_key_file_to_data(keyfile, &length, NULL);
1282
1283         g_file_set_contents(pathname, data, length, NULL);
1284
1285 done:
1286         g_free(data);
1287
1288         g_key_file_free(keyfile);
1289
1290         g_free(pathname);
1291
1292         return 0;
1293 }
1294
1295 static struct connman_storage device_storage = {
1296         .name           = "device",
1297         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1298         .device_load    = device_load,
1299         .device_save    = device_save,
1300 };
1301
1302 int __connman_device_init(void)
1303 {
1304         DBG("");
1305
1306         connection = connman_dbus_get_connection();
1307
1308         if (connman_storage_register(&device_storage) < 0)
1309                 connman_error("Failed to register device storage");
1310
1311         return connman_driver_register(&device_driver);
1312 }
1313
1314 void __connman_device_cleanup(void)
1315 {
1316         DBG("");
1317
1318         connman_driver_unregister(&device_driver);
1319
1320         connman_storage_unregister(&device_storage);
1321
1322         dbus_connection_unref(connection);
1323 }