src/device.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <string.h>
  28
  29 #include "connman.h"
  30
  31 static GSList *device_list = NULL;
  32 static gchar **device_filter = NULL;
  33 static gchar **nodevice_filter = NULL;
  34
  35 enum connman_pending_type {
  36         PENDING_NONE    = 0,
  37         PENDING_ENABLE  = 1,
  38         PENDING_DISABLE = 2,
  39 };
  40
  41 struct connman_device {
  42         int refcount;
  43         enum connman_device_type type;
  44         enum connman_pending_type powered_pending;      /* Indicates a pending
  45                                                         enable/disable request */
  46         connman_bool_t powered;
  47         connman_bool_t scanning;
  48         connman_bool_t disconnected;
  49         connman_bool_t reconnect;
  50         char *name;
  51         char *node;
  52         char *address;
  53         char *interface;
  54         char *ident;
  55         char *path;
  56         char *devname;
  57         int index;
  58         guint pending_timeout;
  59
  60         struct connman_device_driver *driver;
  61         void *driver_data;
  62
  63         char *last_network;
  64         struct connman_network *network;
  65         GHashTable *networks;
  66 };
  67
  68 static void clear_pending_trigger(struct connman_device *device)
  69 {
  70         if (device->pending_timeout > 0) {
  71                 g_source_remove(device->pending_timeout);
  72                 device->pending_timeout = 0;
  73         }
  74 }
  75
  76 static const char *type2description(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 "Wireless";
  86         case CONNMAN_DEVICE_TYPE_WIMAX:
  87                 return "WiMAX";
  88         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
  89                 return "Bluetooth";
  90         case CONNMAN_DEVICE_TYPE_GPS:
  91                 return "GPS";
  92         case CONNMAN_DEVICE_TYPE_CELLULAR:
  93                 return "Cellular";
  94         case CONNMAN_DEVICE_TYPE_GADGET:
  95                 return "Gadget";
  96
  97         }
  98
  99         return NULL;
 100 }
 101
 102 static const char *type2string(enum connman_device_type type)
 103 {
 104         switch (type) {
 105         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 106         case CONNMAN_DEVICE_TYPE_VENDOR:
 107                 break;
 108         case CONNMAN_DEVICE_TYPE_ETHERNET:
 109                 return "ethernet";
 110         case CONNMAN_DEVICE_TYPE_WIFI:
 111                 return "wifi";
 112         case CONNMAN_DEVICE_TYPE_WIMAX:
 113                 return "wimax";
 114         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 115                 return "bluetooth";
 116         case CONNMAN_DEVICE_TYPE_GPS:
 117                 return "gps";
 118         case CONNMAN_DEVICE_TYPE_CELLULAR:
 119                 return "cellular";
 120         case CONNMAN_DEVICE_TYPE_GADGET:
 121                 return "gadget";
 122
 123         }
 124
 125         return NULL;
 126 }
 127
 128 enum connman_service_type __connman_device_get_service_type(struct connman_device *device)
 129 {
 130         enum connman_device_type type = connman_device_get_type(device);
 131
 132         switch (type) {
 133         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 134         case CONNMAN_DEVICE_TYPE_VENDOR:
 135         case CONNMAN_DEVICE_TYPE_GPS:
 136                 break;
 137         case CONNMAN_DEVICE_TYPE_ETHERNET:
 138                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 139         case CONNMAN_DEVICE_TYPE_WIFI:
 140                 return CONNMAN_SERVICE_TYPE_WIFI;
 141         case CONNMAN_DEVICE_TYPE_WIMAX:
 142                 return CONNMAN_SERVICE_TYPE_WIMAX;
 143         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 144                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
 145         case CONNMAN_DEVICE_TYPE_CELLULAR:
 146                 return CONNMAN_SERVICE_TYPE_CELLULAR;
 147         case CONNMAN_DEVICE_TYPE_GADGET:
 148                 return CONNMAN_SERVICE_TYPE_GADGET;
 149
 150         }
 151
 152         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 153 }
 154
 155 static gboolean device_pending_reset(gpointer user_data)
 156 {
 157         struct connman_device *device = user_data;
 158
 159         DBG("device %p", device);
 160
 161         /* Power request timedout, reset power pending state. */
 162         device->pending_timeout = 0;
 163         device->powered_pending = PENDING_NONE;
 164
 165         return FALSE;
 166 }
 167
 168 int __connman_device_enable(struct connman_device *device)
 169 {
 170         int err;
 171
 172         DBG("device %p", device);
 173
 174         if (!device->driver || !device->driver->enable)
 175                 return -EOPNOTSUPP;
 176
 177         /* There is an ongoing power disable request. */
 178         if (device->powered_pending == PENDING_DISABLE)
 179                 return -EBUSY;
 180
 181         if (device->powered_pending == PENDING_ENABLE)
 182                 return -EALREADY;
 183
 184         if (device->powered_pending == PENDING_NONE && device->powered == TRUE)
 185                 return -EALREADY;
 186
 187         device->powered_pending = PENDING_ENABLE;
 188
 189         err = device->driver->enable(device);
 190         /*
 191          * device gets enabled right away.
 192          * Invoke the callback
 193          */
 194         if (err == 0) {
 195                 connman_device_set_powered(device, TRUE);
 196                 goto done;
 197         }
 198
 199         if (err == -EALREADY) {
 200                 /* If device is already powered, but connman is not updated */
 201                 connman_device_set_powered(device, TRUE);
 202                 goto done;
 203         }
 204         /*
 205          * if err == -EINPROGRESS, then the DBus call to the respective daemon
 206          * was successful. We set a 4 sec timeout so if the daemon never
 207          * returns a reply, we would reset the pending request.
 208          */
 209         if (err == -EINPROGRESS)
 210                 device->pending_timeout = g_timeout_add_seconds(4,
 211                                         device_pending_reset, device);
 212 done:
 213         return err;
 214 }
 215
 216 int __connman_device_disable(struct connman_device *device)
 217 {
 218         int err;
 219
 220         DBG("device %p", device);
 221
 222         if (!device->driver || !device->driver->disable)
 223                 return -EOPNOTSUPP;
 224
 225         /* Ongoing power enable request */
 226         if (device->powered_pending == PENDING_ENABLE)
 227                 return -EBUSY;
 228
 229         if (device->powered_pending == PENDING_DISABLE)
 230                 return -EALREADY;
 231
 232         if (device->powered_pending == PENDING_NONE && device->powered == FALSE)
 233                 return -EALREADY;
 234
 235         device->powered_pending = PENDING_DISABLE;
 236         device->reconnect = FALSE;
 237
 238         if (device->network) {
 239                 struct connman_service *service =
 240                         connman_service_lookup_from_network(device->network);
 241
 242                 if (service != NULL)
 243                         __connman_service_disconnect(service);
 244                 else
 245                         connman_network_set_connected(device->network, FALSE);
 246         }
 247
 248         err = device->driver->disable(device);
 249         if (err == 0 || err == -EALREADY) {
 250                 connman_device_set_powered(device, FALSE);
 251                 goto done;
 252         }
 253
 254         if (err == -EINPROGRESS)
 255                 device->pending_timeout = g_timeout_add_seconds(4,
 256                                         device_pending_reset, device);
 257 done:
 258         return err;
 259 }
 260
 261 static void probe_driver(struct connman_device_driver *driver)
 262 {
 263         GSList *list;
 264
 265         DBG("driver %p name %s", driver, driver->name);
 266
 267         for (list = device_list; list != NULL; list = list->next) {
 268                 struct connman_device *device = list->data;
 269
 270                 if (device->driver != NULL)
 271                         continue;
 272
 273                 if (driver->type != device->type)
 274                         continue;
 275
 276                 if (driver->probe(device) < 0)
 277                         continue;
 278
 279                 device->driver = driver;
 280
 281                 __connman_technology_add_device(device);
 282         }
 283 }
 284
 285 static void remove_device(struct connman_device *device)
 286 {
 287         DBG("device %p", device);
 288
 289         __connman_device_disable(device);
 290
 291         __connman_technology_remove_device(device);
 292
 293         if (device->driver->remove)
 294                 device->driver->remove(device);
 295
 296         device->driver = NULL;
 297 }
 298
 299 static void remove_driver(struct connman_device_driver *driver)
 300 {
 301         GSList *list;
 302
 303         DBG("driver %p name %s", driver, driver->name);
 304
 305         for (list = device_list; list != NULL; list = list->next) {
 306                 struct connman_device *device = list->data;
 307
 308                 if (device->driver == driver)
 309                         remove_device(device);
 310         }
 311 }
 312
 313 connman_bool_t __connman_device_has_driver(struct connman_device *device)
 314 {
 315         if (device == NULL || device->driver == NULL)
 316                 return FALSE;
 317
 318         return TRUE;
 319 }
 320
 321 static GSList *driver_list = NULL;
 322
 323 static gint compare_priority(gconstpointer a, gconstpointer b)
 324 {
 325         const struct connman_device_driver *driver1 = a;
 326         const struct connman_device_driver *driver2 = b;
 327
 328         return driver2->priority - driver1->priority;
 329 }
 330
 331 /**
 332  * connman_device_driver_register:
 333  * @driver: device driver definition
 334  *
 335  * Register a new device driver
 336  *
 337  * Returns: %0 on success
 338  */
 339 int connman_device_driver_register(struct connman_device_driver *driver)
 340 {
 341         DBG("driver %p name %s", driver, driver->name);
 342
 343         driver_list = g_slist_insert_sorted(driver_list, driver,
 344                                                         compare_priority);
 345         probe_driver(driver);
 346
 347         return 0;
 348 }
 349
 350 /**
 351  * connman_device_driver_unregister:
 352  * @driver: device driver definition
 353  *
 354  * Remove a previously registered device driver
 355  */
 356 void connman_device_driver_unregister(struct connman_device_driver *driver)
 357 {
 358         DBG("driver %p name %s", driver, driver->name);
 359
 360         driver_list = g_slist_remove(driver_list, driver);
 361
 362         remove_driver(driver);
 363 }
 364
 365 static void free_network(gpointer data)
 366 {
 367         struct connman_network *network = data;
 368
 369         DBG("network %p", network);
 370
 371         __connman_network_set_device(network, NULL);
 372
 373         connman_network_unref(network);
 374 }
 375
 376 static void device_destruct(struct connman_device *device)
 377 {
 378         DBG("device %p name %s", device, device->name);
 379
 380         clear_pending_trigger(device);
 381
 382         g_free(device->ident);
 383         g_free(device->node);
 384         g_free(device->name);
 385         g_free(device->address);
 386         g_free(device->interface);
 387         g_free(device->path);
 388         g_free(device->devname);
 389
 390         g_free(device->last_network);
 391
 392         g_hash_table_destroy(device->networks);
 393         device->networks = NULL;
 394
 395         g_free(device);
 396 }
 397
 398 /**
 399  * connman_device_create:
 400  * @node: device node name (for example an address)
 401  * @type: device type
 402  *
 403  * Allocate a new device of given #type and assign the #node name to it.
 404  *
 405  * Returns: a newly-allocated #connman_device structure
 406  */
 407 struct connman_device *connman_device_create(const char *node,
 408                                                 enum connman_device_type type)
 409 {
 410         struct connman_device *device;
 411
 412         DBG("node %s type %d", node, type);
 413
 414         device = g_try_new0(struct connman_device, 1);
 415         if (device == NULL)
 416                 return NULL;
 417
 418         DBG("device %p", device);
 419
 420         device->refcount = 1;
 421
 422         device->type = type;
 423         device->name = g_strdup(type2description(device->type));
 424
 425         device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
 426                                                 g_free, free_network);
 427
 428         device_list = g_slist_prepend(device_list, device);
 429
 430         return device;
 431 }
 432
 433 /**
 434  * connman_device_ref:
 435  * @device: device structure
 436  *
 437  * Increase reference counter of device
 438  */
 439 struct connman_device *connman_device_ref_debug(struct connman_device *device,
 440                                 const char *file, int line, const char *caller)
 441 {
 442         DBG("%p ref %d by %s:%d:%s()", device, device->refcount + 1,
 443                 file, line, caller);
 444
 445         __sync_fetch_and_add(&device->refcount, 1);
 446
 447         return device;
 448 }
 449
 450 /**
 451  * connman_device_unref:
 452  * @device: device structure
 453  *
 454  * Decrease reference counter of device
 455  */
 456 void connman_device_unref_debug(struct connman_device *device,
 457                                 const char *file, int line, const char *caller)
 458 {
 459         DBG("%p ref %d by %s:%d:%s()", device, device->refcount - 1,
 460                 file, line, caller);
 461
 462         if (__sync_fetch_and_sub(&device->refcount, 1) != 1)
 463                 return;
 464
 465         if (device->driver) {
 466                 device->driver->remove(device);
 467                 device->driver = NULL;
 468         }
 469
 470         device_list = g_slist_remove(device_list, device);
 471
 472         device_destruct(device);
 473 }
 474
 475 const char *__connman_device_get_type(struct connman_device *device)
 476 {
 477         return type2string(device->type);
 478 }
 479
 480 /**
 481  * connman_device_get_type:
 482  * @device: device structure
 483  *
 484  * Get type of device
 485  */
 486 enum connman_device_type connman_device_get_type(struct connman_device *device)
 487 {
 488         return device->type;
 489 }
 490
 491 /**
 492  * connman_device_set_index:
 493  * @device: device structure
 494  * @index: index number
 495  *
 496  * Set index number of device
 497  */
 498 void connman_device_set_index(struct connman_device *device, int index)
 499 {
 500         device->index = index;
 501 }
 502
 503 /**
 504  * connman_device_get_index:
 505  * @device: device structure
 506  *
 507  * Get index number of device
 508  */
 509 int connman_device_get_index(struct connman_device *device)
 510 {
 511         return device->index;
 512 }
 513
 514 /**
 515  * connman_device_set_interface:
 516  * @device: device structure
 517  * @interface: interface name
 518  *
 519  * Set interface name of device
 520  */
 521 void connman_device_set_interface(struct connman_device *device,
 522                                                 const char *interface)
 523 {
 524         g_free(device->devname);
 525         device->devname = g_strdup(interface);
 526
 527         g_free(device->interface);
 528         device->interface = g_strdup(interface);
 529
 530         if (device->name == NULL) {
 531                 const char *str = type2description(device->type);
 532                 if (str != NULL && device->interface != NULL)
 533                         device->name = g_strdup_printf("%s (%s)", str,
 534                                                         device->interface);
 535         }
 536 }
 537
 538 /**
 539  * connman_device_set_ident:
 540  * @device: device structure
 541  * @ident: unique identifier
 542  *
 543  * Set unique identifier of device
 544  */
 545 void connman_device_set_ident(struct connman_device *device,
 546                                                         const char *ident)
 547 {
 548         g_free(device->ident);
 549         device->ident = g_strdup(ident);
 550 }
 551
 552 const char *connman_device_get_ident(struct connman_device *device)
 553 {
 554         return device->ident;
 555 }
 556
 557 /**
 558  * connman_device_set_powered:
 559  * @device: device structure
 560  * @powered: powered state
 561  *
 562  * Change power state of device
 563  */
 564 int connman_device_set_powered(struct connman_device *device,
 565                                                 connman_bool_t powered)
 566 {
 567         enum connman_service_type type;
 568
 569         DBG("driver %p powered %d", device, powered);
 570
 571         if (device->powered == powered)
 572                 return -EALREADY;
 573
 574         clear_pending_trigger(device);
 575
 576         device->powered_pending = PENDING_NONE;
 577
 578         device->powered = powered;
 579
 580         type = __connman_device_get_service_type(device);
 581
 582         if (device->powered == FALSE) {
 583                 __connman_technology_disabled(type);
 584                 return 0;
 585         }
 586
 587         __connman_technology_enabled(type);
 588
 589         connman_device_set_disconnected(device, FALSE);
 590         device->scanning = FALSE;
 591
 592         if (device->driver && device->driver->scan)
 593                 device->driver->scan(device, NULL, 0, NULL, NULL, NULL);
 594
 595         return 0;
 596 }
 597
 598 connman_bool_t connman_device_get_powered(struct connman_device *device)
 599 {
 600         return device->powered;
 601 }
 602
 603 static int device_scan(struct connman_device *device)
 604 {
 605         if (!device->driver || !device->driver->scan)
 606                 return -EOPNOTSUPP;
 607
 608         if (device->powered == FALSE)
 609                 return -ENOLINK;
 610
 611         return device->driver->scan(device, NULL, 0, NULL, NULL, NULL);
 612 }
 613
 614 int __connman_device_disconnect(struct connman_device *device)
 615 {
 616         GHashTableIter iter;
 617         gpointer key, value;
 618
 619         DBG("device %p", device);
 620
 621         connman_device_set_disconnected(device, TRUE);
 622
 623         g_hash_table_iter_init(&iter, device->networks);
 624
 625         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 626                 struct connman_network *network = value;
 627
 628                 if (connman_network_get_connecting(network) == TRUE) {
 629                         /*
 630                          * Skip network in the process of connecting.
 631                          * This is a workaround for WiFi networks serviced
 632                          * by the supplicant plugin that hold a reference
 633                          * to the network.  If we disconnect the network
 634                          * here then the referenced object will not be
 635                          * registered and usage (like launching DHCP client)
 636                          * will fail.  There is nothing to be gained by
 637                          * removing the network here anyway.
 638                          */
 639                         connman_warn("Skipping disconnect of %s, network is connecting.",
 640                                 connman_network_get_identifier(network));
 641                         continue;
 642                 }
 643
 644                 __connman_network_disconnect(network);
 645         }
 646
 647         return 0;
 648 }
 649
 650 static void mark_network_available(gpointer key, gpointer value,
 651                                                         gpointer user_data)
 652 {
 653         struct connman_network *network = value;
 654
 655         connman_network_set_available(network, TRUE);
 656 }
 657
 658 static void mark_network_unavailable(gpointer key, gpointer value,
 659                                                         gpointer user_data)
 660 {
 661         struct connman_network *network = value;
 662
 663         if (connman_network_get_connected(network) == TRUE)
 664                 return;
 665
 666         connman_network_set_available(network, FALSE);
 667 }
 668
 669 static gboolean remove_unavailable_network(gpointer key, gpointer value,
 670                                                         gpointer user_data)
 671 {
 672         struct connman_network *network = value;
 673
 674         if (connman_network_get_connected(network) == TRUE)
 675                 return FALSE;
 676
 677         if (connman_network_get_available(network) == TRUE)
 678                 return FALSE;
 679
 680         return TRUE;
 681 }
 682
 683 void __connman_device_cleanup_networks(struct connman_device *device)
 684 {
 685         g_hash_table_foreach_remove(device->networks,
 686                                         remove_unavailable_network, NULL);
 687 }
 688
 689 connman_bool_t connman_device_get_scanning(struct connman_device *device)
 690 {
 691         return device->scanning;
 692 }
 693
 694 void connman_device_reset_scanning(struct connman_device *device)
 695 {
 696         g_hash_table_foreach(device->networks,
 697                                 mark_network_available, NULL);
 698 }
 699
 700 /**
 701  * connman_device_set_scanning:
 702  * @device: device structure
 703  * @scanning: scanning state
 704  *
 705  * Change scanning state of device
 706  */
 707 int connman_device_set_scanning(struct connman_device *device,
 708                                                 connman_bool_t scanning)
 709 {
 710         DBG("device %p scanning %d", device, scanning);
 711
 712         if (!device->driver || !device->driver->scan)
 713                 return -EINVAL;
 714
 715         if (device->scanning == scanning)
 716                 return -EALREADY;
 717
 718         device->scanning = scanning;
 719
 720         if (scanning == TRUE) {
 721                 __connman_technology_scan_started(device);
 722
 723                 g_hash_table_foreach(device->networks,
 724                                         mark_network_unavailable, NULL);
 725
 726                 return 0;
 727         }
 728
 729         __connman_device_cleanup_networks(device);
 730
 731         __connman_technology_scan_stopped(device);
 732
 733         __connman_service_auto_connect();
 734
 735         return 0;
 736 }
 737
 738 /**
 739  * connman_device_set_disconnected:
 740  * @device: device structure
 741  * @disconnected: disconnected state
 742  *
 743  * Change disconnected state of device (only for device with networks)
 744  */
 745 int connman_device_set_disconnected(struct connman_device *device,
 746                                                 connman_bool_t disconnected)
 747 {
 748         DBG("device %p disconnected %d", device, disconnected);
 749
 750         if (device->disconnected == disconnected)
 751                 return -EALREADY;
 752
 753         device->disconnected = disconnected;
 754
 755         return 0;
 756 }
 757
 758 /**
 759  * connman_device_get_disconnected:
 760  * @device: device structure
 761  *
 762  * Get device disconnected state
 763  */
 764 connman_bool_t connman_device_get_disconnected(struct connman_device *device)
 765 {
 766         return device->disconnected;
 767 }
 768
 769 /**
 770  * connman_device_set_string:
 771  * @device: device structure
 772  * @key: unique identifier
 773  * @value: string value
 774  *
 775  * Set string value for specific key
 776  */
 777 int connman_device_set_string(struct connman_device *device,
 778                                         const char *key, const char *value)
 779 {
 780         DBG("device %p key %s value %s", device, key, value);
 781
 782         if (g_str_equal(key, "Address") == TRUE) {
 783                 g_free(device->address);
 784                 device->address = g_strdup(value);
 785         } else if (g_str_equal(key, "Name") == TRUE) {
 786                 g_free(device->name);
 787                 device->name = g_strdup(value);
 788         } else if (g_str_equal(key, "Node") == TRUE) {
 789                 g_free(device->node);
 790                 device->node = g_strdup(value);
 791         } else if (g_str_equal(key, "Path") == TRUE) {
 792                 g_free(device->path);
 793                 device->path = g_strdup(value);
 794         } else {
 795                 return -EINVAL;
 796         }
 797
 798         return 0;
 799 }
 800
 801 /**
 802  * connman_device_get_string:
 803  * @device: device structure
 804  * @key: unique identifier
 805  *
 806  * Get string value for specific key
 807  */
 808 const char *connman_device_get_string(struct connman_device *device,
 809                                                         const char *key)
 810 {
 811         DBG("device %p key %s", device, key);
 812
 813         if (g_str_equal(key, "Address") == TRUE)
 814                 return device->address;
 815         else if (g_str_equal(key, "Name") == TRUE)
 816                 return device->name;
 817         else if (g_str_equal(key, "Node") == TRUE)
 818                 return device->node;
 819         else if (g_str_equal(key, "Interface") == TRUE)
 820                 return device->interface;
 821         else if (g_str_equal(key, "Path") == TRUE)
 822                 return device->path;
 823
 824         return NULL;
 825 }
 826
 827 /**
 828  * connman_device_add_network:
 829  * @device: device structure
 830  * @network: network structure
 831  *
 832  * Add new network to the device
 833  */
 834 int connman_device_add_network(struct connman_device *device,
 835                                         struct connman_network *network)
 836 {
 837         const char *identifier = connman_network_get_identifier(network);
 838
 839         DBG("device %p network %p", device, network);
 840
 841         if (identifier == NULL)
 842                 return -EINVAL;
 843
 844         connman_network_ref(network);
 845
 846         __connman_network_set_device(network, device);
 847
 848         g_hash_table_replace(device->networks, g_strdup(identifier),
 849                                                                 network);
 850
 851         return 0;
 852 }
 853
 854 /**
 855  * connman_device_get_network:
 856  * @device: device structure
 857  * @identifier: network identifier
 858  *
 859  * Get network for given identifier
 860  */
 861 struct connman_network *connman_device_get_network(struct connman_device *device,
 862                                                         const char *identifier)
 863 {
 864         DBG("device %p identifier %s", device, identifier);
 865
 866         return g_hash_table_lookup(device->networks, identifier);
 867 }
 868
 869 /**
 870  * connman_device_remove_network:
 871  * @device: device structure
 872  * @identifier: network identifier
 873  *
 874  * Remove network for given identifier
 875  */
 876 int connman_device_remove_network(struct connman_device *device,
 877                                                 struct connman_network *network)
 878 {
 879         const char *identifier;
 880
 881         DBG("device %p network %p", device, network);
 882
 883         if (network == NULL)
 884                 return 0;
 885
 886         identifier = connman_network_get_identifier(network);
 887         g_hash_table_remove(device->networks, identifier);
 888
 889         return 0;
 890 }
 891
 892 void connman_device_remove_all_networks(struct connman_device *device)
 893 {
 894         g_hash_table_remove_all(device->networks);
 895 }
 896
 897 void __connman_device_set_network(struct connman_device *device,
 898                                         struct connman_network *network)
 899 {
 900         const char *name;
 901
 902         if (device == NULL)
 903                 return;
 904
 905         if (device->network == network)
 906                 return;
 907
 908         if (network != NULL) {
 909                 name = connman_network_get_string(network, "Name");
 910                 g_free(device->last_network);
 911                 device->last_network = g_strdup(name);
 912
 913                 device->network = network;
 914         } else {
 915                 g_free(device->last_network);
 916                 device->last_network = NULL;
 917
 918                 device->network = NULL;
 919         }
 920 }
 921
 922 void __connman_device_set_reconnect(struct connman_device *device,
 923                                                 connman_bool_t reconnect)
 924 {
 925         device->reconnect = reconnect;
 926 }
 927
 928 connman_bool_t  __connman_device_get_reconnect(
 929                                 struct connman_device *device)
 930 {
 931         return device->reconnect;
 932 }
 933
 934 static gboolean match_driver(struct connman_device *device,
 935                                         struct connman_device_driver *driver)
 936 {
 937         if (device->type == driver->type ||
 938                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
 939                 return TRUE;
 940
 941         return FALSE;
 942 }
 943
 944 /**
 945  * connman_device_register:
 946  * @device: device structure
 947  *
 948  * Register device with the system
 949  */
 950 int connman_device_register(struct connman_device *device)
 951 {
 952         GSList *list;
 953
 954         DBG("device %p name %s", device, device->name);
 955
 956         if (device->driver != NULL)
 957                 return -EALREADY;
 958
 959         for (list = driver_list; list; list = list->next) {
 960                 struct connman_device_driver *driver = list->data;
 961
 962                 if (match_driver(device, driver) == FALSE)
 963                         continue;
 964
 965                 DBG("driver %p name %s", driver, driver->name);
 966
 967                 if (driver->probe(device) == 0) {
 968                         device->driver = driver;
 969                         break;
 970                 }
 971         }
 972
 973         if (device->driver == NULL)
 974                 return 0;
 975
 976         return __connman_technology_add_device(device);
 977 }
 978
 979 /**
 980  * connman_device_unregister:
 981  * @device: device structure
 982  *
 983  * Unregister device with the system
 984  */
 985 void connman_device_unregister(struct connman_device *device)
 986 {
 987         DBG("device %p name %s", device, device->name);
 988
 989         if (device->driver == NULL)
 990                 return;
 991
 992         remove_device(device);
 993 }
 994
 995 /**
 996  * connman_device_get_data:
 997  * @device: device structure
 998  *
 999  * Get private device data pointer
1000  */
1001 void *connman_device_get_data(struct connman_device *device)
1002 {
1003         return device->driver_data;
1004 }
1005
1006 /**
1007  * connman_device_set_data:
1008  * @device: device structure
1009  * @data: data pointer
1010  *
1011  * Set private device data pointer
1012  */
1013 void connman_device_set_data(struct connman_device *device, void *data)
1014 {
1015         device->driver_data = data;
1016 }
1017
1018 struct connman_device *__connman_device_find_device(
1019                                 enum connman_service_type type)
1020 {
1021         GSList *list;
1022
1023         for (list = device_list; list != NULL; list = list->next) {
1024                 struct connman_device *device = list->data;
1025                 enum connman_service_type service_type =
1026                         __connman_device_get_service_type(device);
1027
1028                 if (service_type != type)
1029                         continue;
1030
1031                 return device;
1032         }
1033
1034         return NULL;
1035 }
1036
1037 /**
1038  * connman_device_set_regdom
1039  * @device: device structure
1040  * @alpha2: string representing regulatory domain
1041  *
1042  * Set regulatory domain on device basis
1043  */
1044 int connman_device_set_regdom(struct connman_device *device,
1045                                                 const char *alpha2)
1046 {
1047         if (device->driver == NULL || device->driver->set_regdom == NULL)
1048                 return -ENOTSUP;
1049
1050         if (device->powered == FALSE)
1051                 return -EINVAL;
1052
1053         return device->driver->set_regdom(device, alpha2);
1054 }
1055
1056 /**
1057  * connman_device_regdom_notify
1058  * @device: device structure
1059  * @alpha2: string representing regulatory domain
1060  *
1061  * Notify on setting regulatory domain on device basis
1062  */
1063 void connman_device_regdom_notify(struct connman_device *device,
1064                                         int result, const char *alpha2)
1065 {
1066         __connman_technology_notify_regdom_by_device(device, result, alpha2);
1067 }
1068
1069 int __connman_device_request_scan(enum connman_service_type type)
1070 {
1071         connman_bool_t success = FALSE;
1072         int last_err = -ENOSYS;
1073         GSList *list;
1074         int err;
1075
1076         switch (type) {
1077         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1078         case CONNMAN_SERVICE_TYPE_SYSTEM:
1079         case CONNMAN_SERVICE_TYPE_ETHERNET:
1080         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1081         case CONNMAN_SERVICE_TYPE_CELLULAR:
1082         case CONNMAN_SERVICE_TYPE_GPS:
1083         case CONNMAN_SERVICE_TYPE_VPN:
1084         case CONNMAN_SERVICE_TYPE_GADGET:
1085                 return -EOPNOTSUPP;
1086         case CONNMAN_SERVICE_TYPE_WIFI:
1087         case CONNMAN_SERVICE_TYPE_WIMAX:
1088                 break;
1089         }
1090
1091         for (list = device_list; list != NULL; list = list->next) {
1092                 struct connman_device *device = list->data;
1093                 enum connman_service_type service_type =
1094                         __connman_device_get_service_type(device);
1095
1096                 if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
1097                                 service_type != type) {
1098                         continue;
1099                 }
1100
1101                 err = device_scan(device);
1102                 if (err == 0 || err == -EALREADY || err == -EINPROGRESS) {
1103                         success = TRUE;
1104                 } else {
1105                         last_err = err;
1106                         DBG("device %p err %d", device, err);
1107                 }
1108         }
1109
1110         if (success == TRUE)
1111                 return 0;
1112
1113         return last_err;
1114 }
1115
1116 int __connman_device_request_hidden_scan(struct connman_device *device,
1117                                 const char *ssid, unsigned int ssid_len,
1118                                 const char *identity, const char *passphrase,
1119                                 void *user_data)
1120 {
1121         DBG("device %p", device);
1122
1123         if (device == NULL || device->driver == NULL ||
1124                         device->driver->scan == NULL)
1125                 return -EINVAL;
1126
1127         if (device->scanning == TRUE)
1128                 return -EALREADY;
1129
1130         return device->driver->scan(device, ssid, ssid_len,
1131                                         identity, passphrase, user_data);
1132 }
1133
1134 connman_bool_t __connman_device_isfiltered(const char *devname)
1135 {
1136         char **pattern;
1137         char **blacklisted_interfaces;
1138
1139         if (device_filter == NULL)
1140                 goto nodevice;
1141
1142         for (pattern = device_filter; *pattern; pattern++) {
1143                 if (g_pattern_match_simple(*pattern, devname) == FALSE) {
1144                         DBG("ignoring device %s (match)", devname);
1145                         return TRUE;
1146                 }
1147         }
1148
1149 nodevice:
1150         if (g_pattern_match_simple("dummy*", devname) == TRUE) {
1151                 DBG("ignoring dummy networking devices");
1152                 return TRUE;
1153         }
1154
1155         if (nodevice_filter == NULL)
1156                 goto list;
1157
1158         for (pattern = nodevice_filter; *pattern; pattern++) {
1159                 if (g_pattern_match_simple(*pattern, devname) == TRUE) {
1160                         DBG("ignoring device %s (no match)", devname);
1161                         return TRUE;
1162                 }
1163         }
1164
1165 list:
1166         blacklisted_interfaces =
1167                 connman_setting_get_string_list("NetworkInterfaceBlacklist");
1168         if (blacklisted_interfaces == NULL)
1169                 return FALSE;
1170
1171         for (pattern = blacklisted_interfaces; *pattern; pattern++) {
1172                 if (g_str_has_prefix(devname, *pattern) == TRUE) {
1173                         DBG("ignoring device %s (blacklist)", devname);
1174                         return TRUE;
1175                 }
1176         }
1177
1178         return FALSE;
1179 }
1180
1181 static void cleanup_devices(void)
1182 {
1183         /*
1184          * Check what interfaces are currently up and if connman is
1185          * suppose to handle the interface, then cleanup the mess
1186          * related to that interface. There might be weird routes etc
1187          * that are related to that interface and that might confuse
1188          * connmand. So in this case we just turn the interface down
1189          * so that kernel removes routes/addresses automatically and
1190          * then proceed the startup.
1191          *
1192          * Note that this cleanup must be done before rtnl/detect code
1193          * has activated interface watches.
1194          */
1195
1196         char **interfaces;
1197         int i;
1198
1199         interfaces = __connman_inet_get_running_interfaces();
1200
1201         if (interfaces == NULL)
1202                 return;
1203
1204         for (i = 0; interfaces[i] != NULL; i++) {
1205                 connman_bool_t filtered;
1206                 int index;
1207
1208                 filtered = __connman_device_isfiltered(interfaces[i]);
1209                 if (filtered == TRUE)
1210                         continue;
1211
1212                 index = connman_inet_ifindex(interfaces[i]);
1213                 if (index < 0)
1214                         continue;
1215
1216                 DBG("cleaning up %s index %d", interfaces[i], index);
1217
1218                 connman_inet_ifdown(index);
1219
1220                 /*
1221                  * ConnMan will turn the interface UP automatically so
1222                  * no need to do it here.
1223                  */
1224         }
1225
1226         g_strfreev(interfaces);
1227 }
1228
1229 int __connman_device_init(const char *device, const char *nodevice)
1230 {
1231         DBG("");
1232
1233         if (device != NULL)
1234                 device_filter = g_strsplit(device, ",", -1);
1235
1236         if (nodevice != NULL)
1237                 nodevice_filter = g_strsplit(nodevice, ",", -1);
1238
1239         cleanup_devices();
1240
1241         return 0;
1242 }
1243
1244 void __connman_device_cleanup(void)
1245 {
1246         DBG("");
1247
1248         g_strfreev(nodevice_filter);
1249         g_strfreev(device_filter);
1250 }