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_element_store(&device->element);
 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_path:
 753  * @device: device structure
 754  *
 755  * Get path name of device
 756  */
 757 const char *connman_device_get_path(struct connman_device *device)
 758 {
 759         return device->element.path;
 760 }
 761
 762 /**
 763  * connman_device_set_index:
 764  * @device: device structure
 765  * @index: index number
 766  *
 767  * Set index number of device
 768  */
 769 void connman_device_set_index(struct connman_device *device, int index)
 770 {
 771         device->element.index = index;
 772 }
 773
 774 /**
 775  * connman_device_get_index:
 776  * @device: device structure
 777  *
 778  * Get index number of device
 779  */
 780 int connman_device_get_index(struct connman_device *device)
 781 {
 782         return device->element.index;
 783 }
 784
 785 /**
 786  * connman_device_set_interface:
 787  * @device: device structure
 788  * @interface: interface name
 789  *
 790  * Set interface name of device
 791  */
 792 void connman_device_set_interface(struct connman_device *device,
 793                                                         const char *interface)
 794 {
 795         g_free(device->element.devname);
 796         device->element.devname = g_strdup(interface);
 797
 798         g_free(device->interface);
 799         device->interface = g_strdup(interface);
 800 }
 801
 802 /**
 803  * connman_device_get_interface:
 804  * @device: device structure
 805  *
 806  * Get interface name of device
 807  */
 808 const char *connman_device_get_interface(struct connman_device *device)
 809 {
 810         return device->interface;
 811 }
 812
 813 /**
 814  * connman_device_set_policy:
 815  * @device: device structure
 816  * @policy: power and connection policy
 817  *
 818  * Change power and connection policy of device
 819  */
 820 void connman_device_set_policy(struct connman_device *device,
 821                                         enum connman_device_policy policy)
 822 {
 823         device->policy = policy;
 824 }
 825
 826 /**
 827  * connman_device_set_mode:
 828  * @device: device structure
 829  * @mode: network mode
 830  *
 831  * Change network mode of device
 832  */
 833 void connman_device_set_mode(struct connman_device *device,
 834                                                 enum connman_device_mode mode)
 835 {
 836         device->mode = mode;
 837 }
 838
 839 /**
 840  * connman_device_set_powered:
 841  * @device: device structure
 842  * @powered: powered state
 843  *
 844  * Change power state of device
 845  */
 846 int connman_device_set_powered(struct connman_device *device,
 847                                                 connman_bool_t powered)
 848 {
 849         DBusMessage *signal;
 850         DBusMessageIter entry, value;
 851         const char *key = "Powered";
 852
 853         DBG("driver %p powered %d", device, powered);
 854
 855         if (device->powered == powered)
 856                 return -EALREADY;
 857
 858         device->powered = powered;
 859
 860         signal = dbus_message_new_signal(device->element.path,
 861                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 862         if (signal == NULL)
 863                 return 0;
 864
 865         dbus_message_iter_init_append(signal, &entry);
 866
 867         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 868
 869         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 870                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 871         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
 872         dbus_message_iter_close_container(&entry, &value);
 873
 874         g_dbus_send_message(connection, signal);
 875
 876         return 0;
 877 }
 878
 879 /**
 880  * connman_device_set_carrier:
 881  * @device: device structure
 882  * @carrier: carrier state
 883  *
 884  * Change carrier state of device (only for device without scanning)
 885  */
 886 int connman_device_set_carrier(struct connman_device *device,
 887                                                 connman_bool_t carrier)
 888 {
 889         DBG("driver %p carrier %d", device, carrier);
 890
 891         switch (device->mode) {
 892         case CONNMAN_DEVICE_MODE_UNKNOWN:
 893         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 894         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 895                 return -EINVAL;
 896         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 897                 break;
 898         }
 899
 900         if (device->carrier == carrier)
 901                 return -EALREADY;
 902
 903         device->carrier = carrier;
 904
 905         if (carrier == TRUE) {
 906                 struct connman_element *element;
 907
 908                 element = connman_element_create(NULL);
 909                 if (element != NULL) {
 910                         element->type    = CONNMAN_ELEMENT_TYPE_DHCP;
 911                         element->subtype = device->element.subtype;
 912                         element->index   = device->element.index;
 913
 914                         if (connman_element_register(element,
 915                                                         &device->element) < 0)
 916                                 connman_element_unref(element);
 917                 }
 918         } else
 919                 connman_element_unregister_children(&device->element);
 920
 921         return 0;
 922 }
 923
 924 /**
 925  * connman_device_set_scanning:
 926  * @device: device structure
 927  * @scanning: scanning state
 928  *
 929  * Change scanning state of device
 930  */
 931 int connman_device_set_scanning(struct connman_device *device,
 932                                                 connman_bool_t scanning)
 933 {
 934         DBusMessage *signal;
 935         DBusMessageIter entry, value;
 936         const char *key = "Scanning";
 937
 938         DBG("driver %p scanning %d", device, scanning);
 939
 940         if (!device->driver || !device->driver->scan)
 941                 return -EINVAL;
 942
 943         if (device->scanning == scanning)
 944                 return -EALREADY;
 945
 946         device->scanning = scanning;
 947
 948         signal = dbus_message_new_signal(device->element.path,
 949                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 950         if (signal == NULL)
 951                 return 0;
 952
 953         dbus_message_iter_init_append(signal, &entry);
 954
 955         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 956
 957         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 958                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 959         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
 960         dbus_message_iter_close_container(&entry, &value);
 961
 962         g_dbus_send_message(connection, signal);
 963
 964         return 0;
 965 }
 966
 967 /**
 968  * connman_device_set_string:
 969  * @device: device structure
 970  * @key: unique identifier
 971  * @value: string value
 972  *
 973  * Set string value for specific key
 974  */
 975 int connman_device_set_string(struct connman_device *device,
 976                                         const char *key, const char *value)
 977 {
 978         DBG("device %p key %s value %s", device, key, value);
 979
 980         if (g_str_equal(key, "Name") == TRUE) {
 981                 g_free(device->name);
 982                 device->name = g_strdup(value);
 983         } else if (g_str_equal(key, "Node") == TRUE) {
 984                 g_free(device->node);
 985                 device->node = g_strdup(value);
 986         }
 987
 988         return 0;
 989 }
 990
 991 /**
 992  * connman_device_get_string:
 993  * @device: device structure
 994  * @key: unique identifier
 995  *
 996  * Get string value for specific key
 997  */
 998 const char *connman_device_get_string(struct connman_device *device,
 999                                                         const char *key)
1000 {
1001         DBG("device %p key %s", device);
1002
1003         if (g_str_equal(key, "Name") == TRUE)
1004                 return device->name;
1005         else if (g_str_equal(key, "Node") == TRUE)
1006                 return device->node;
1007
1008         return NULL;
1009 }
1010
1011 /**
1012  * connman_device_add_network:
1013  * @device: device structure
1014  * @network: network structure
1015  *
1016  * Add new network to the device
1017  */
1018 int connman_device_add_network(struct connman_device *device,
1019                                         struct connman_network *network)
1020 {
1021         const char *identifier = connman_network_get_identifier(network);
1022         int err;
1023
1024         DBG("device %p network %p", device, network);
1025
1026         switch (device->mode) {
1027         case CONNMAN_DEVICE_MODE_UNKNOWN:
1028         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1029                 return -EINVAL;
1030         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1031         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1032                 break;
1033         }
1034
1035         __connman_network_set_device(network, device);
1036
1037         __connman_storage_load_network(network);
1038
1039         err = connman_element_register((struct connman_element *) network,
1040                                                         &device->element);
1041         if (err < 0) {
1042                 __connman_network_set_device(network, NULL);
1043                 return err;
1044         }
1045
1046         g_hash_table_insert(device->networks, g_strdup(identifier),
1047                                                                 network);
1048
1049         return 0;
1050 }
1051
1052 /**
1053  * connman_device_get_network:
1054  * @device: device structure
1055  * @identifier: network identifier
1056  *
1057  * Get network for given identifier
1058  */
1059 struct connman_network *connman_device_get_network(struct connman_device *device,
1060                                                         const char *identifier)
1061 {
1062         DBG("device %p identifier %s", device, identifier);
1063
1064         return g_hash_table_lookup(device->networks, identifier);
1065 }
1066
1067 /**
1068  * connman_device_remove_network:
1069  * @device: device structure
1070  * @identifier: network identifier
1071  *
1072  * Remove network for given identifier
1073  */
1074 int connman_device_remove_network(struct connman_device *device,
1075                                                         const char *identifier)
1076 {
1077         DBG("device %p identifier %s", device, identifier);
1078
1079         g_hash_table_remove(device->networks, identifier);
1080
1081         return 0;
1082 }
1083
1084 /**
1085  * connman_device_register:
1086  * @device: device structure
1087  *
1088  * Register device with the system
1089  */
1090 int connman_device_register(struct connman_device *device)
1091 {
1092         __connman_storage_load_device(device);
1093
1094         return connman_element_register(&device->element, NULL);
1095 }
1096
1097 /**
1098  * connman_device_unregister:
1099  * @device: device structure
1100  *
1101  * Unregister device with the system
1102  */
1103 void connman_device_unregister(struct connman_device *device)
1104 {
1105         __connman_storage_save_device(device);
1106
1107         connman_element_unregister(&device->element);
1108 }
1109
1110 /**
1111  * connman_device_get_data:
1112  * @device: device structure
1113  *
1114  * Get private device data pointer
1115  */
1116 void *connman_device_get_data(struct connman_device *device)
1117 {
1118         return device->driver_data;
1119 }
1120
1121 /**
1122  * connman_device_set_data:
1123  * @device: device structure
1124  * @data: data pointer
1125  *
1126  * Set private device data pointer
1127  */
1128 void connman_device_set_data(struct connman_device *device, void *data)
1129 {
1130         device->driver_data = data;
1131 }
1132
1133 static gboolean match_driver(struct connman_device *device,
1134                                         struct connman_device_driver *driver)
1135 {
1136         if (device->type == driver->type ||
1137                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1138                 return TRUE;
1139
1140         return FALSE;
1141 }
1142
1143 static int device_probe(struct connman_element *element)
1144 {
1145         struct connman_device *device = element->device;
1146         GSList *list;
1147
1148         DBG("element %p name %s", element, element->name);
1149
1150         if (device == NULL)
1151                 return -ENODEV;
1152
1153         for (list = driver_list; list; list = list->next) {
1154                 struct connman_device_driver *driver = list->data;
1155
1156                 if (match_driver(device, driver) == FALSE)
1157                         continue;
1158
1159                 DBG("driver %p name %s", driver, driver->name);
1160
1161                 if (driver->probe(device) == 0) {
1162                         device->driver = driver;
1163                         break;
1164                 }
1165         }
1166
1167         if (device->driver == NULL)
1168                 return -ENODEV;
1169
1170         return setup_device(device);
1171 }
1172
1173 static void device_remove(struct connman_element *element)
1174 {
1175         struct connman_device *device = element->device;
1176
1177         DBG("element %p name %s", element, element->name);
1178
1179         if (device == NULL)
1180                 return;
1181
1182         if (device->driver == NULL)
1183                 return;
1184
1185         remove_device(device);
1186 }
1187
1188 static struct connman_driver device_driver = {
1189         .name           = "device",
1190         .type           = CONNMAN_ELEMENT_TYPE_DEVICE,
1191         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
1192         .probe          = device_probe,
1193         .remove         = device_remove,
1194 };
1195
1196 static int device_load(struct connman_device *device)
1197 {
1198         GKeyFile *keyfile;
1199         gchar *pathname, *data = NULL;
1200         gsize length;
1201         const char *str;
1202
1203         DBG("device %p", device);
1204
1205         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1206                                                         device->element.name);
1207         if (pathname == NULL)
1208                 return -ENOMEM;
1209
1210         keyfile = g_key_file_new();
1211
1212         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1213                 g_free(pathname);
1214                 return -ENOENT;
1215         }
1216
1217         g_free(pathname);
1218
1219         if (g_key_file_load_from_data(keyfile, data, length,
1220                                                         0, NULL) == FALSE) {
1221                 g_free(data);
1222                 return -EILSEQ;
1223         }
1224
1225         g_free(data);
1226
1227         str = g_key_file_get_string(keyfile, "Configuration", "Policy", NULL);
1228         if (str != NULL)
1229                 device->policy = string2policy(str);
1230
1231         g_key_file_free(keyfile);
1232
1233         return 0;
1234 }
1235
1236 static int device_save(struct connman_device *device)
1237 {
1238         GKeyFile *keyfile;
1239         gchar *pathname, *data = NULL;
1240         gsize length;
1241         const char *str;
1242
1243         DBG("device %p", device);
1244
1245         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1246                                                         device->element.name);
1247         if (pathname == NULL)
1248                 return -ENOMEM;
1249
1250         keyfile = g_key_file_new();
1251
1252         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1253                 goto update;
1254
1255         if (length > 0) {
1256                 if (g_key_file_load_from_data(keyfile, data, length,
1257                                                         0, NULL) == FALSE)
1258                         goto done;
1259         }
1260
1261         g_free(data);
1262
1263 update:
1264         str = policy2string(device->policy);
1265         if (str != NULL)
1266                 g_key_file_set_string(keyfile, "Configuration", "Policy", str);
1267
1268         data = g_key_file_to_data(keyfile, &length, NULL);
1269
1270         g_file_set_contents(pathname, data, length, NULL);
1271
1272 done:
1273         g_free(data);
1274
1275         g_key_file_free(keyfile);
1276
1277         g_free(pathname);
1278
1279         return 0;
1280 }
1281
1282 static struct connman_storage device_storage = {
1283         .name           = "device",
1284         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1285         .device_load    = device_load,
1286         .device_save    = device_save,
1287 };
1288
1289 int __connman_device_init(void)
1290 {
1291         DBG("");
1292
1293         connection = connman_dbus_get_connection();
1294
1295         if (connman_storage_register(&device_storage) < 0)
1296                 connman_error("Failed to register device storage");
1297
1298         return connman_driver_register(&device_driver);
1299 }
1300
1301 void __connman_device_cleanup(void)
1302 {
1303         DBG("");
1304
1305         connman_driver_unregister(&device_driver);
1306
1307         connman_storage_unregister(&device_storage);
1308
1309         dbus_connection_unref(connection);
1310 }