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