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 (driver->probe(element->device) < 0)
 555                 return;
 556
 557         element->device->driver = driver;
 558
 559         setup_device(element->device);
 560 }
 561
 562 static void remove_device(struct connman_device *device)
 563 {
 564         DBG("device %p", device);
 565
 566         device_disable(device);
 567
 568         unregister_interface(&device->element);
 569
 570         if (device->driver->remove)
 571                 device->driver->remove(device);
 572
 573         device->driver = NULL;
 574 }
 575
 576 static void remove_driver(struct connman_element *element, gpointer user_data)
 577 {
 578         struct connman_device_driver *driver = user_data;
 579
 580         DBG("element %p name %s", element, element->name);
 581
 582         if (element->device == NULL)
 583                 return;
 584
 585         if (element->device->driver == driver)
 586                 remove_device(element->device);
 587 }
 588
 589 connman_bool_t __connman_device_has_driver(struct connman_device *device)
 590 {
 591         if (device == NULL || device->driver == NULL)
 592                 return FALSE;
 593
 594         return device->registered;
 595 }
 596
 597 static GSList *driver_list = NULL;
 598
 599 static gint compare_priority(gconstpointer a, gconstpointer b)
 600 {
 601         const struct connman_device_driver *driver1 = a;
 602         const struct connman_device_driver *driver2 = b;
 603
 604         return driver2->priority - driver1->priority;
 605 }
 606
 607 /**
 608  * connman_device_driver_register:
 609  * @driver: device driver definition
 610  *
 611  * Register a new device driver
 612  *
 613  * Returns: %0 on success
 614  */
 615 int connman_device_driver_register(struct connman_device_driver *driver)
 616 {
 617         DBG("driver %p name %s", driver, driver->name);
 618
 619         driver_list = g_slist_insert_sorted(driver_list, driver,
 620                                                         compare_priority);
 621
 622         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
 623                                                 probe_driver, driver);
 624
 625         return 0;
 626 }
 627
 628 /**
 629  * connman_device_driver_unregister:
 630  * @driver: device driver definition
 631  *
 632  * Remove a previously registered device driver
 633  */
 634 void connman_device_driver_unregister(struct connman_device_driver *driver)
 635 {
 636         DBG("driver %p name %s", driver, driver->name);
 637
 638         driver_list = g_slist_remove(driver_list, driver);
 639
 640         __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
 641                                                 remove_driver, driver);
 642 }
 643
 644 static void unregister_network(gpointer data)
 645 {
 646         struct connman_network *network = data;
 647
 648         DBG("network %p", network);
 649
 650         connman_element_unregister((struct connman_element *) network);
 651
 652         connman_network_unref(network);
 653 }
 654
 655 static void device_destruct(struct connman_element *element)
 656 {
 657         struct connman_device *device = element->device;
 658
 659         DBG("element %p name %s", element, element->name);
 660
 661         g_free(device->node);
 662         g_free(device->name);
 663         g_free(device->interface);
 664
 665         g_hash_table_destroy(device->networks);
 666         device->networks = NULL;
 667 }
 668
 669 /**
 670  * connman_device_create:
 671  * @node: device node name (for example an address)
 672  * @type: device type
 673  *
 674  * Allocate a new device of given #type and assign the #node name to it.
 675  *
 676  * Returns: a newly-allocated #connman_device structure
 677  */
 678 struct connman_device *connman_device_create(const char *node,
 679                                                 enum connman_device_type type)
 680 {
 681         struct connman_device *device;
 682
 683         DBG("node %s type %d", node, type);
 684
 685         device = g_try_new0(struct connman_device, 1);
 686         if (device == NULL)
 687                 return NULL;
 688
 689         DBG("device %p", device);
 690
 691         device->element.refcount = 1;
 692
 693         device->element.name = g_strdup(node);
 694         device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
 695         device->element.index = -1;
 696
 697         device->element.device = device;
 698         device->element.destruct = device_destruct;
 699
 700         device->type   = type;
 701         device->mode   = CONNMAN_DEVICE_MODE_UNKNOWN;
 702         device->policy = CONNMAN_DEVICE_POLICY_AUTO;
 703
 704         device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
 705                                                 g_free, unregister_network);
 706
 707         return device;
 708 }
 709
 710 /**
 711  * connman_device_ref:
 712  * @device: device structure
 713  *
 714  * Increase reference counter of device
 715  */
 716 struct connman_device *connman_device_ref(struct connman_device *device)
 717 {
 718         if (connman_element_ref(&device->element) == NULL)
 719                 return NULL;
 720
 721         return device;
 722 }
 723
 724 /**
 725  * connman_device_unref:
 726  * @device: device structure
 727  *
 728  * Decrease reference counter of device
 729  */
 730 void connman_device_unref(struct connman_device *device)
 731 {
 732         connman_element_unref(&device->element);
 733 }
 734
 735 /**
 736  * connman_device_get_name:
 737  * @device: device structure
 738  *
 739  * Get unique name of device
 740  */
 741 const char *connman_device_get_name(struct connman_device *device)
 742 {
 743         return device->element.name;
 744 }
 745
 746 /**
 747  * connman_device_get_path:
 748  * @device: device structure
 749  *
 750  * Get path name of device
 751  */
 752 const char *connman_device_get_path(struct connman_device *device)
 753 {
 754         return device->element.path;
 755 }
 756
 757 /**
 758  * connman_device_set_index:
 759  * @device: device structure
 760  * @index: index number
 761  *
 762  * Set index number of device
 763  */
 764 void connman_device_set_index(struct connman_device *device, int index)
 765 {
 766         device->element.index = index;
 767 }
 768
 769 /**
 770  * connman_device_get_index:
 771  * @device: device structure
 772  *
 773  * Get index number of device
 774  */
 775 int connman_device_get_index(struct connman_device *device)
 776 {
 777         return device->element.index;
 778 }
 779
 780 /**
 781  * connman_device_set_interface:
 782  * @device: device structure
 783  * @interface: interface name
 784  *
 785  * Set interface name of device
 786  */
 787 void connman_device_set_interface(struct connman_device *device,
 788                                                         const char *interface)
 789 {
 790         g_free(device->element.devname);
 791         device->element.devname = g_strdup(interface);
 792
 793         g_free(device->interface);
 794         device->interface = g_strdup(interface);
 795 }
 796
 797 /**
 798  * connman_device_get_interface:
 799  * @device: device structure
 800  *
 801  * Get interface name of device
 802  */
 803 const char *connman_device_get_interface(struct connman_device *device)
 804 {
 805         return device->interface;
 806 }
 807
 808 /**
 809  * connman_device_set_policy:
 810  * @device: device structure
 811  * @policy: power and connection policy
 812  *
 813  * Change power and connection policy of device
 814  */
 815 void connman_device_set_policy(struct connman_device *device,
 816                                         enum connman_device_policy policy)
 817 {
 818         device->policy = policy;
 819 }
 820
 821 /**
 822  * connman_device_set_mode:
 823  * @device: device structure
 824  * @mode: network mode
 825  *
 826  * Change network mode of device
 827  */
 828 void connman_device_set_mode(struct connman_device *device,
 829                                                 enum connman_device_mode mode)
 830 {
 831         device->mode = mode;
 832 }
 833
 834 /**
 835  * connman_device_set_powered:
 836  * @device: device structure
 837  * @powered: powered state
 838  *
 839  * Change power state of device
 840  */
 841 int connman_device_set_powered(struct connman_device *device,
 842                                                 connman_bool_t powered)
 843 {
 844         DBusMessage *signal;
 845         DBusMessageIter entry, value;
 846         const char *key = "Powered";
 847
 848         DBG("driver %p powered %d", device, powered);
 849
 850         if (device->powered == powered)
 851                 return -EALREADY;
 852
 853         device->powered = powered;
 854
 855         signal = dbus_message_new_signal(device->element.path,
 856                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 857         if (signal == NULL)
 858                 return 0;
 859
 860         dbus_message_iter_init_append(signal, &entry);
 861
 862         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 863
 864         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 865                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 866         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
 867         dbus_message_iter_close_container(&entry, &value);
 868
 869         g_dbus_send_message(connection, signal);
 870
 871         if (powered == FALSE)
 872                 return 0;
 873
 874         if (device->policy != CONNMAN_DEVICE_POLICY_AUTO)
 875                 return 0;
 876
 877         if (device->driver->scan)
 878                 device->driver->scan(device);
 879
 880         return 0;
 881 }
 882
 883 /**
 884  * connman_device_set_carrier:
 885  * @device: device structure
 886  * @carrier: carrier state
 887  *
 888  * Change carrier state of device (only for device without scanning)
 889  */
 890 int connman_device_set_carrier(struct connman_device *device,
 891                                                 connman_bool_t carrier)
 892 {
 893         DBG("driver %p carrier %d", device, carrier);
 894
 895         switch (device->mode) {
 896         case CONNMAN_DEVICE_MODE_UNKNOWN:
 897         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
 898         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
 899                 return -EINVAL;
 900         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
 901                 break;
 902         }
 903
 904         if (device->carrier == carrier)
 905                 return -EALREADY;
 906
 907         device->carrier = carrier;
 908
 909         if (carrier == TRUE) {
 910                 struct connman_element *element;
 911
 912                 element = connman_element_create(NULL);
 913                 if (element != NULL) {
 914                         element->type  = CONNMAN_ELEMENT_TYPE_DHCP;
 915                         element->index = device->element.index;
 916
 917                         if (connman_element_register(element,
 918                                                         &device->element) < 0)
 919                                 connman_element_unref(element);
 920                 }
 921         } else
 922                 connman_element_unregister_children(&device->element);
 923
 924         return 0;
 925 }
 926
 927 static void connect_known_network(struct connman_device *device)
 928 {
 929         GHashTableIter iter;
 930         gpointer key, value;
 931         unsigned int count = 0;
 932
 933         DBG("device %p", device);
 934
 935         g_hash_table_iter_init(&iter, device->networks);
 936
 937         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 938                 struct connman_network *network = value;
 939                 int err;
 940
 941                 count++;
 942
 943                 if (connman_network_get_remember(network) == FALSE)
 944                         continue;
 945
 946                 err = connman_network_connect(network);
 947                 if (err == 0 || err == -EINPROGRESS)
 948                         return;
 949         }
 950
 951         if (count > 0)
 952                 return;
 953
 954         if (device->driver && device->driver->scan)
 955                 device->driver->scan(device);
 956 }
 957
 958 /**
 959  * connman_device_set_scanning:
 960  * @device: device structure
 961  * @scanning: scanning state
 962  *
 963  * Change scanning state of device
 964  */
 965 int connman_device_set_scanning(struct connman_device *device,
 966                                                 connman_bool_t scanning)
 967 {
 968         DBusMessage *signal;
 969         DBusMessageIter entry, value;
 970         const char *key = "Scanning";
 971
 972         DBG("driver %p scanning %d", device, scanning);
 973
 974         if (!device->driver || !device->driver->scan)
 975                 return -EINVAL;
 976
 977         if (device->scanning == scanning)
 978                 return -EALREADY;
 979
 980         device->scanning = scanning;
 981
 982         signal = dbus_message_new_signal(device->element.path,
 983                                 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
 984         if (signal == NULL)
 985                 return 0;
 986
 987         dbus_message_iter_init_append(signal, &entry);
 988
 989         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 990
 991         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 992                                         DBUS_TYPE_BOOLEAN_AS_STRING, &value);
 993         dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
 994         dbus_message_iter_close_container(&entry, &value);
 995
 996         g_dbus_send_message(connection, signal);
 997
 998         if (scanning == TRUE)
 999                 return 0;
1000
1001         if (device->connections > 0)
1002                 return 0;
1003
1004         if (device->policy != CONNMAN_DEVICE_POLICY_AUTO)
1005                 return 0;
1006
1007         connect_known_network(device);
1008
1009         return 0;
1010 }
1011
1012 /**
1013  * connman_device_set_string:
1014  * @device: device structure
1015  * @key: unique identifier
1016  * @value: string value
1017  *
1018  * Set string value for specific key
1019  */
1020 int connman_device_set_string(struct connman_device *device,
1021                                         const char *key, const char *value)
1022 {
1023         DBG("device %p key %s value %s", device, key, value);
1024
1025         if (g_str_equal(key, "Name") == TRUE) {
1026                 g_free(device->name);
1027                 device->name = g_strdup(value);
1028         } else if (g_str_equal(key, "Node") == TRUE) {
1029                 g_free(device->node);
1030                 device->node = g_strdup(value);
1031         }
1032
1033         return 0;
1034 }
1035
1036 /**
1037  * connman_device_get_string:
1038  * @device: device structure
1039  * @key: unique identifier
1040  *
1041  * Get string value for specific key
1042  */
1043 const char *connman_device_get_string(struct connman_device *device,
1044                                                         const char *key)
1045 {
1046         DBG("device %p key %s", device);
1047
1048         if (g_str_equal(key, "Name") == TRUE)
1049                 return device->name;
1050         else if (g_str_equal(key, "Node") == TRUE)
1051                 return device->node;
1052
1053         return NULL;
1054 }
1055
1056 void __connman_device_increase_connections(struct connman_device *device)
1057 {
1058         device->connections++;
1059 }
1060
1061 void __connman_device_decrease_connections(struct connman_device *device)
1062 {
1063         device->connections--;
1064 }
1065
1066 /**
1067  * connman_device_add_network:
1068  * @device: device structure
1069  * @network: network structure
1070  *
1071  * Add new network to the device
1072  */
1073 int connman_device_add_network(struct connman_device *device,
1074                                         struct connman_network *network)
1075 {
1076         const char *identifier = connman_network_get_identifier(network);
1077         int err;
1078
1079         DBG("device %p network %p", device, network);
1080
1081         switch (device->mode) {
1082         case CONNMAN_DEVICE_MODE_UNKNOWN:
1083         case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1084                 return -EINVAL;
1085         case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1086         case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1087                 break;
1088         }
1089
1090         __connman_network_set_device(network, device);
1091
1092         __connman_storage_load_network(network);
1093
1094         err = connman_element_register((struct connman_element *) network,
1095                                                         &device->element);
1096         if (err < 0) {
1097                 __connman_network_set_device(network, NULL);
1098                 return err;
1099         }
1100
1101         g_hash_table_insert(device->networks, g_strdup(identifier),
1102                                                                 network);
1103
1104         return 0;
1105 }
1106
1107 /**
1108  * connman_device_get_network:
1109  * @device: device structure
1110  * @identifier: network identifier
1111  *
1112  * Get network for given identifier
1113  */
1114 struct connman_network *connman_device_get_network(struct connman_device *device,
1115                                                         const char *identifier)
1116 {
1117         DBG("device %p identifier %s", device, identifier);
1118
1119         return g_hash_table_lookup(device->networks, identifier);
1120 }
1121
1122 /**
1123  * connman_device_remove_network:
1124  * @device: device structure
1125  * @identifier: network identifier
1126  *
1127  * Remove network for given identifier
1128  */
1129 int connman_device_remove_network(struct connman_device *device,
1130                                                         const char *identifier)
1131 {
1132         DBG("device %p identifier %s", device, identifier);
1133
1134         g_hash_table_remove(device->networks, identifier);
1135
1136         return 0;
1137 }
1138
1139 /**
1140  * connman_device_register:
1141  * @device: device structure
1142  *
1143  * Register device with the system
1144  */
1145 int connman_device_register(struct connman_device *device)
1146 {
1147         __connman_storage_load_device(device);
1148
1149         return connman_element_register(&device->element, NULL);
1150 }
1151
1152 /**
1153  * connman_device_unregister:
1154  * @device: device structure
1155  *
1156  * Unregister device with the system
1157  */
1158 void connman_device_unregister(struct connman_device *device)
1159 {
1160         __connman_storage_save_device(device);
1161
1162         connman_element_unregister(&device->element);
1163 }
1164
1165 /**
1166  * connman_device_get_data:
1167  * @device: device structure
1168  *
1169  * Get private device data pointer
1170  */
1171 void *connman_device_get_data(struct connman_device *device)
1172 {
1173         return device->driver_data;
1174 }
1175
1176 /**
1177  * connman_device_set_data:
1178  * @device: device structure
1179  * @data: data pointer
1180  *
1181  * Set private device data pointer
1182  */
1183 void connman_device_set_data(struct connman_device *device, void *data)
1184 {
1185         device->driver_data = data;
1186 }
1187
1188 static gboolean match_driver(struct connman_device *device,
1189                                         struct connman_device_driver *driver)
1190 {
1191         if (device->type == driver->type ||
1192                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1193                 return TRUE;
1194
1195         return FALSE;
1196 }
1197
1198 static int device_probe(struct connman_element *element)
1199 {
1200         struct connman_device *device = element->device;
1201         GSList *list;
1202
1203         DBG("element %p name %s", element, element->name);
1204
1205         if (device == NULL)
1206                 return -ENODEV;
1207
1208         for (list = driver_list; list; list = list->next) {
1209                 struct connman_device_driver *driver = list->data;
1210
1211                 if (match_driver(device, driver) == FALSE)
1212                         continue;
1213
1214                 DBG("driver %p name %s", driver, driver->name);
1215
1216                 if (driver->probe(device) == 0) {
1217                         device->driver = driver;
1218                         break;
1219                 }
1220         }
1221
1222         if (device->driver == NULL)
1223                 return -ENODEV;
1224
1225         return setup_device(device);
1226 }
1227
1228 static void device_remove(struct connman_element *element)
1229 {
1230         struct connman_device *device = element->device;
1231
1232         DBG("element %p name %s", element, element->name);
1233
1234         if (device == NULL)
1235                 return;
1236
1237         if (device->driver == NULL)
1238                 return;
1239
1240         remove_device(device);
1241 }
1242
1243 static struct connman_driver device_driver = {
1244         .name           = "device",
1245         .type           = CONNMAN_ELEMENT_TYPE_DEVICE,
1246         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
1247         .probe          = device_probe,
1248         .remove         = device_remove,
1249 };
1250
1251 static int device_load(struct connman_device *device)
1252 {
1253         GKeyFile *keyfile;
1254         gchar *pathname, *data = NULL;
1255         gsize length;
1256         char *str;
1257
1258         DBG("device %p", device);
1259
1260         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1261                                                         device->element.name);
1262         if (pathname == NULL)
1263                 return -ENOMEM;
1264
1265         keyfile = g_key_file_new();
1266
1267         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1268                 g_free(pathname);
1269                 return -ENOENT;
1270         }
1271
1272         g_free(pathname);
1273
1274         if (g_key_file_load_from_data(keyfile, data, length,
1275                                                         0, NULL) == FALSE) {
1276                 g_free(data);
1277                 return -EILSEQ;
1278         }
1279
1280         g_free(data);
1281
1282         str = g_key_file_get_string(keyfile, "Configuration", "Policy", NULL);
1283         if (str != NULL) {
1284                 device->policy = string2policy(str);
1285                 g_free(str);
1286         }
1287
1288         g_key_file_free(keyfile);
1289
1290         return 0;
1291 }
1292
1293 static int device_save(struct connman_device *device)
1294 {
1295         GKeyFile *keyfile;
1296         gchar *pathname, *data = NULL;
1297         gsize length;
1298         const char *str;
1299
1300         DBG("device %p", device);
1301
1302         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1303                                                         device->element.name);
1304         if (pathname == NULL)
1305                 return -ENOMEM;
1306
1307         keyfile = g_key_file_new();
1308
1309         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1310                 goto update;
1311
1312         if (length > 0) {
1313                 if (g_key_file_load_from_data(keyfile, data, length,
1314                                                         0, NULL) == FALSE)
1315                         goto done;
1316         }
1317
1318         g_free(data);
1319
1320 update:
1321         str = policy2string(device->policy);
1322         if (str != NULL)
1323                 g_key_file_set_string(keyfile, "Configuration", "Policy", str);
1324
1325         data = g_key_file_to_data(keyfile, &length, NULL);
1326
1327         g_file_set_contents(pathname, data, length, NULL);
1328
1329 done:
1330         g_free(data);
1331
1332         g_key_file_free(keyfile);
1333
1334         g_free(pathname);
1335
1336         return 0;
1337 }
1338
1339 static struct connman_storage device_storage = {
1340         .name           = "device",
1341         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1342         .device_load    = device_load,
1343         .device_save    = device_save,
1344 };
1345
1346 int __connman_device_init(void)
1347 {
1348         DBG("");
1349
1350         connection = connman_dbus_get_connection();
1351
1352         if (connman_storage_register(&device_storage) < 0)
1353                 connman_error("Failed to register device storage");
1354
1355         return connman_driver_register(&device_driver);
1356 }
1357
1358 void __connman_device_cleanup(void)
1359 {
1360         DBG("");
1361
1362         connman_driver_unregister(&device_driver);
1363
1364         connman_storage_unregister(&device_storage);
1365
1366         dbus_connection_unref(connection);
1367 }