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 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <sys/ioctl.h>
  32 #include <net/ethernet.h>
  33 #include <net/if.h>
  34
  35 #include "connman.h"
  36
  37 static GSList *device_list = NULL;
  38 static gchar **device_filter = NULL;
  39 static gchar **nodevice_filter = NULL;
  40
  41 enum connman_pending_type {
  42         PENDING_NONE    = 0,
  43         PENDING_ENABLE  = 1,
  44         PENDING_DISABLE = 2,
  45 };
  46
  47 struct connman_device {
  48         int refcount;
  49         enum connman_device_type type;
  50         enum connman_pending_type powered_pending;      /* Indicates a pending
  51                                                         enable/disable request */
  52         connman_bool_t powered;
  53         connman_bool_t scanning;
  54         connman_bool_t disconnected;
  55         connman_bool_t reconnect;
  56         char *name;
  57         char *node;
  58         char *address;
  59         char *interface;
  60         char *ident;
  61         char *path;
  62         char *devname;
  63         int index;
  64         guint pending_timeout;
  65
  66         struct connman_device_driver *driver;
  67         void *driver_data;
  68
  69         char *last_network;
  70         struct connman_network *network;
  71         GHashTable *networks;
  72 };
  73
  74 static void clear_pending_trigger(struct connman_device *device)
  75 {
  76         if (device->pending_timeout > 0) {
  77                 g_source_remove(device->pending_timeout);
  78                 device->pending_timeout = 0;
  79         }
  80 }
  81
  82 static const char *type2description(enum connman_device_type type)
  83 {
  84         switch (type) {
  85         case CONNMAN_DEVICE_TYPE_UNKNOWN:
  86         case CONNMAN_DEVICE_TYPE_VENDOR:
  87                 break;
  88         case CONNMAN_DEVICE_TYPE_ETHERNET:
  89                 return "Ethernet";
  90         case CONNMAN_DEVICE_TYPE_WIFI:
  91                 return "Wireless";
  92         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
  93                 return "Bluetooth";
  94         case CONNMAN_DEVICE_TYPE_GPS:
  95                 return "GPS";
  96         case CONNMAN_DEVICE_TYPE_CELLULAR:
  97                 return "Cellular";
  98         case CONNMAN_DEVICE_TYPE_GADGET:
  99                 return "Gadget";
 100
 101         }
 102
 103         return NULL;
 104 }
 105
 106 static const char *type2string(enum connman_device_type type)
 107 {
 108         switch (type) {
 109         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 110         case CONNMAN_DEVICE_TYPE_VENDOR:
 111                 break;
 112         case CONNMAN_DEVICE_TYPE_ETHERNET:
 113                 return "ethernet";
 114         case CONNMAN_DEVICE_TYPE_WIFI:
 115                 return "wifi";
 116         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 117                 return "bluetooth";
 118         case CONNMAN_DEVICE_TYPE_GPS:
 119                 return "gps";
 120         case CONNMAN_DEVICE_TYPE_CELLULAR:
 121                 return "cellular";
 122         case CONNMAN_DEVICE_TYPE_GADGET:
 123                 return "gadget";
 124
 125         }
 126
 127         return NULL;
 128 }
 129
 130 enum connman_service_type __connman_device_get_service_type(struct connman_device *device)
 131 {
 132         enum connman_device_type type = connman_device_get_type(device);
 133
 134         switch (type) {
 135         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 136         case CONNMAN_DEVICE_TYPE_VENDOR:
 137         case CONNMAN_DEVICE_TYPE_GPS:
 138                 break;
 139         case CONNMAN_DEVICE_TYPE_ETHERNET:
 140                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 141         case CONNMAN_DEVICE_TYPE_WIFI:
 142                 return CONNMAN_SERVICE_TYPE_WIFI;
 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                         connman_network_get_connecting(network) == TRUE)
 665                 return;
 666
 667         connman_network_set_available(network, FALSE);
 668 }
 669
 670 static gboolean remove_unavailable_network(gpointer key, gpointer value,
 671                                                         gpointer user_data)
 672 {
 673         struct connman_network *network = value;
 674
 675         if (connman_network_get_connected(network) == TRUE)
 676                 return FALSE;
 677
 678         if (connman_network_get_available(network) == TRUE)
 679                 return FALSE;
 680
 681         return TRUE;
 682 }
 683
 684 void __connman_device_cleanup_networks(struct connman_device *device)
 685 {
 686         g_hash_table_foreach_remove(device->networks,
 687                                         remove_unavailable_network, NULL);
 688 }
 689
 690 connman_bool_t connman_device_get_scanning(struct connman_device *device)
 691 {
 692         return device->scanning;
 693 }
 694
 695 void connman_device_reset_scanning(struct connman_device *device)
 696 {
 697         g_hash_table_foreach(device->networks,
 698                                 mark_network_available, NULL);
 699 }
 700
 701 /**
 702  * connman_device_set_scanning:
 703  * @device: device structure
 704  * @scanning: scanning state
 705  *
 706  * Change scanning state of device
 707  */
 708 int connman_device_set_scanning(struct connman_device *device,
 709                                                 connman_bool_t scanning)
 710 {
 711         DBG("device %p scanning %d", device, scanning);
 712
 713         if (!device->driver || !device->driver->scan)
 714                 return -EINVAL;
 715
 716         if (device->scanning == scanning)
 717                 return -EALREADY;
 718
 719         device->scanning = scanning;
 720
 721         if (scanning == TRUE) {
 722                 __connman_technology_scan_started(device);
 723
 724                 g_hash_table_foreach(device->networks,
 725                                         mark_network_unavailable, NULL);
 726
 727                 return 0;
 728         }
 729
 730         __connman_device_cleanup_networks(device);
 731
 732         __connman_technology_scan_stopped(device);
 733
 734         __connman_service_auto_connect();
 735
 736         return 0;
 737 }
 738
 739 /**
 740  * connman_device_set_disconnected:
 741  * @device: device structure
 742  * @disconnected: disconnected state
 743  *
 744  * Change disconnected state of device (only for device with networks)
 745  */
 746 int connman_device_set_disconnected(struct connman_device *device,
 747                                                 connman_bool_t disconnected)
 748 {
 749         DBG("device %p disconnected %d", device, disconnected);
 750
 751         if (device->disconnected == disconnected)
 752                 return -EALREADY;
 753
 754         device->disconnected = disconnected;
 755
 756         return 0;
 757 }
 758
 759 /**
 760  * connman_device_get_disconnected:
 761  * @device: device structure
 762  *
 763  * Get device disconnected state
 764  */
 765 connman_bool_t connman_device_get_disconnected(struct connman_device *device)
 766 {
 767         return device->disconnected;
 768 }
 769
 770 /**
 771  * connman_device_set_string:
 772  * @device: device structure
 773  * @key: unique identifier
 774  * @value: string value
 775  *
 776  * Set string value for specific key
 777  */
 778 int connman_device_set_string(struct connman_device *device,
 779                                         const char *key, const char *value)
 780 {
 781         DBG("device %p key %s value %s", device, key, value);
 782
 783         if (g_str_equal(key, "Address") == TRUE) {
 784                 g_free(device->address);
 785                 device->address = g_strdup(value);
 786         } else if (g_str_equal(key, "Name") == TRUE) {
 787                 g_free(device->name);
 788                 device->name = g_strdup(value);
 789         } else if (g_str_equal(key, "Node") == TRUE) {
 790                 g_free(device->node);
 791                 device->node = g_strdup(value);
 792         } else if (g_str_equal(key, "Path") == TRUE) {
 793                 g_free(device->path);
 794                 device->path = g_strdup(value);
 795         } else {
 796                 return -EINVAL;
 797         }
 798
 799         return 0;
 800 }
 801
 802 /**
 803  * connman_device_get_string:
 804  * @device: device structure
 805  * @key: unique identifier
 806  *
 807  * Get string value for specific key
 808  */
 809 const char *connman_device_get_string(struct connman_device *device,
 810                                                         const char *key)
 811 {
 812         DBG("device %p key %s", device, key);
 813
 814         if (g_str_equal(key, "Address") == TRUE)
 815                 return device->address;
 816         else if (g_str_equal(key, "Name") == TRUE)
 817                 return device->name;
 818         else if (g_str_equal(key, "Node") == TRUE)
 819                 return device->node;
 820         else if (g_str_equal(key, "Interface") == TRUE)
 821                 return device->interface;
 822         else if (g_str_equal(key, "Path") == TRUE)
 823                 return device->path;
 824
 825         return NULL;
 826 }
 827
 828 /**
 829  * connman_device_add_network:
 830  * @device: device structure
 831  * @network: network structure
 832  *
 833  * Add new network to the device
 834  */
 835 int connman_device_add_network(struct connman_device *device,
 836                                         struct connman_network *network)
 837 {
 838         const char *identifier = connman_network_get_identifier(network);
 839
 840         DBG("device %p network %p", device, network);
 841
 842         if (identifier == NULL)
 843                 return -EINVAL;
 844
 845         connman_network_ref(network);
 846
 847         __connman_network_set_device(network, device);
 848
 849         g_hash_table_replace(device->networks, g_strdup(identifier),
 850                                                                 network);
 851
 852         return 0;
 853 }
 854
 855 /**
 856  * connman_device_get_network:
 857  * @device: device structure
 858  * @identifier: network identifier
 859  *
 860  * Get network for given identifier
 861  */
 862 struct connman_network *connman_device_get_network(struct connman_device *device,
 863                                                         const char *identifier)
 864 {
 865         DBG("device %p identifier %s", device, identifier);
 866
 867         return g_hash_table_lookup(device->networks, identifier);
 868 }
 869
 870 /**
 871  * connman_device_remove_network:
 872  * @device: device structure
 873  * @identifier: network identifier
 874  *
 875  * Remove network for given identifier
 876  */
 877 int connman_device_remove_network(struct connman_device *device,
 878                                                 struct connman_network *network)
 879 {
 880         const char *identifier;
 881
 882         DBG("device %p network %p", device, network);
 883
 884         if (network == NULL)
 885                 return 0;
 886
 887         identifier = connman_network_get_identifier(network);
 888         g_hash_table_remove(device->networks, identifier);
 889
 890         return 0;
 891 }
 892
 893 void connman_device_remove_all_networks(struct connman_device *device)
 894 {
 895         g_hash_table_remove_all(device->networks);
 896 }
 897
 898 void __connman_device_set_network(struct connman_device *device,
 899                                         struct connman_network *network)
 900 {
 901         const char *name;
 902
 903         if (device == NULL)
 904                 return;
 905
 906         if (device->network == network)
 907                 return;
 908
 909         if (network != NULL) {
 910                 name = connman_network_get_string(network, "Name");
 911                 g_free(device->last_network);
 912                 device->last_network = g_strdup(name);
 913
 914                 device->network = network;
 915         } else {
 916                 g_free(device->last_network);
 917                 device->last_network = NULL;
 918
 919                 device->network = NULL;
 920         }
 921 }
 922
 923 void __connman_device_set_reconnect(struct connman_device *device,
 924                                                 connman_bool_t reconnect)
 925 {
 926         device->reconnect = reconnect;
 927 }
 928
 929 connman_bool_t  __connman_device_get_reconnect(
 930                                 struct connman_device *device)
 931 {
 932         return device->reconnect;
 933 }
 934
 935 static gboolean match_driver(struct connman_device *device,
 936                                         struct connman_device_driver *driver)
 937 {
 938         if (device->type == driver->type ||
 939                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
 940                 return TRUE;
 941
 942         return FALSE;
 943 }
 944
 945 /**
 946  * connman_device_register:
 947  * @device: device structure
 948  *
 949  * Register device with the system
 950  */
 951 int connman_device_register(struct connman_device *device)
 952 {
 953         GSList *list;
 954
 955         DBG("device %p name %s", device, device->name);
 956
 957         if (device->driver != NULL)
 958                 return -EALREADY;
 959
 960         for (list = driver_list; list; list = list->next) {
 961                 struct connman_device_driver *driver = list->data;
 962
 963                 if (match_driver(device, driver) == FALSE)
 964                         continue;
 965
 966                 DBG("driver %p name %s", driver, driver->name);
 967
 968                 if (driver->probe(device) == 0) {
 969                         device->driver = driver;
 970                         break;
 971                 }
 972         }
 973
 974         if (device->driver == NULL)
 975                 return 0;
 976
 977         return __connman_technology_add_device(device);
 978 }
 979
 980 /**
 981  * connman_device_unregister:
 982  * @device: device structure
 983  *
 984  * Unregister device with the system
 985  */
 986 void connman_device_unregister(struct connman_device *device)
 987 {
 988         DBG("device %p name %s", device, device->name);
 989
 990         if (device->driver == NULL)
 991                 return;
 992
 993         remove_device(device);
 994 }
 995
 996 /**
 997  * connman_device_get_data:
 998  * @device: device structure
 999  *
1000  * Get private device data pointer
1001  */
1002 void *connman_device_get_data(struct connman_device *device)
1003 {
1004         return device->driver_data;
1005 }
1006
1007 /**
1008  * connman_device_set_data:
1009  * @device: device structure
1010  * @data: data pointer
1011  *
1012  * Set private device data pointer
1013  */
1014 void connman_device_set_data(struct connman_device *device, void *data)
1015 {
1016         device->driver_data = data;
1017 }
1018
1019 struct connman_device *__connman_device_find_device(
1020                                 enum connman_service_type type)
1021 {
1022         GSList *list;
1023
1024         for (list = device_list; list != NULL; list = list->next) {
1025                 struct connman_device *device = list->data;
1026                 enum connman_service_type service_type =
1027                         __connman_device_get_service_type(device);
1028
1029                 if (service_type != type)
1030                         continue;
1031
1032                 return device;
1033         }
1034
1035         return NULL;
1036 }
1037
1038 /**
1039  * connman_device_set_regdom
1040  * @device: device structure
1041  * @alpha2: string representing regulatory domain
1042  *
1043  * Set regulatory domain on device basis
1044  */
1045 int connman_device_set_regdom(struct connman_device *device,
1046                                                 const char *alpha2)
1047 {
1048         if (device->driver == NULL || device->driver->set_regdom == NULL)
1049                 return -ENOTSUP;
1050
1051         if (device->powered == FALSE)
1052                 return -EINVAL;
1053
1054         return device->driver->set_regdom(device, alpha2);
1055 }
1056
1057 /**
1058  * connman_device_regdom_notify
1059  * @device: device structure
1060  * @alpha2: string representing regulatory domain
1061  *
1062  * Notify on setting regulatory domain on device basis
1063  */
1064 void connman_device_regdom_notify(struct connman_device *device,
1065                                         int result, const char *alpha2)
1066 {
1067         __connman_technology_notify_regdom_by_device(device, result, alpha2);
1068 }
1069
1070 int __connman_device_request_scan(enum connman_service_type type)
1071 {
1072         connman_bool_t success = FALSE;
1073         int last_err = -ENOSYS;
1074         GSList *list;
1075         int err;
1076
1077         switch (type) {
1078         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1079         case CONNMAN_SERVICE_TYPE_SYSTEM:
1080         case CONNMAN_SERVICE_TYPE_ETHERNET:
1081         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1082         case CONNMAN_SERVICE_TYPE_CELLULAR:
1083         case CONNMAN_SERVICE_TYPE_GPS:
1084         case CONNMAN_SERVICE_TYPE_VPN:
1085         case CONNMAN_SERVICE_TYPE_GADGET:
1086                 return -EOPNOTSUPP;
1087         case CONNMAN_SERVICE_TYPE_WIFI:
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 static char *index2ident(int index, const char *prefix)
1135 {
1136         struct ifreq ifr;
1137         struct ether_addr eth;
1138         char *str;
1139         int sk, err, len;
1140
1141         if (index < 0)
1142                 return NULL;
1143
1144         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1145         if (sk < 0)
1146                 return NULL;
1147
1148         memset(&ifr, 0, sizeof(ifr));
1149         ifr.ifr_ifindex = index;
1150
1151         err = ioctl(sk, SIOCGIFNAME, &ifr);
1152
1153         if (err == 0)
1154                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
1155
1156         close(sk);
1157
1158         if (err < 0)
1159                 return NULL;
1160
1161         len = prefix ? strlen(prefix) + 18 : 18;
1162
1163         str = g_malloc(len);
1164         if (!str)
1165                 return NULL;
1166
1167         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
1168         snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
1169                                                 prefix ? prefix : "",
1170                                                 eth.ether_addr_octet[0],
1171                                                 eth.ether_addr_octet[1],
1172                                                 eth.ether_addr_octet[2],
1173                                                 eth.ether_addr_octet[3],
1174                                                 eth.ether_addr_octet[4],
1175                                                 eth.ether_addr_octet[5]);
1176
1177         return str;
1178 }
1179
1180 static char *index2addr(int index)
1181 {
1182         struct ifreq ifr;
1183         struct ether_addr eth;
1184         char *str;
1185         int sk, err;
1186
1187         if (index < 0)
1188                 return NULL;
1189
1190         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1191         if (sk < 0)
1192                 return NULL;
1193
1194         memset(&ifr, 0, sizeof(ifr));
1195         ifr.ifr_ifindex = index;
1196
1197         err = ioctl(sk, SIOCGIFNAME, &ifr);
1198
1199         if (err == 0)
1200                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
1201
1202         close(sk);
1203
1204         if (err < 0)
1205                 return NULL;
1206
1207         str = g_malloc(18);
1208         if (!str)
1209                 return NULL;
1210
1211         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
1212         snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
1213                                                 eth.ether_addr_octet[0],
1214                                                 eth.ether_addr_octet[1],
1215                                                 eth.ether_addr_octet[2],
1216                                                 eth.ether_addr_octet[3],
1217                                                 eth.ether_addr_octet[4],
1218                                                 eth.ether_addr_octet[5]);
1219
1220         return str;
1221 }
1222
1223 struct connman_device *connman_device_create_from_index(int index)
1224 {
1225         enum connman_device_type type;
1226         struct connman_device *device;
1227         char *devname, *ident = NULL;
1228         char *addr = NULL, *name = NULL;
1229
1230         if (index < 0)
1231                 return NULL;
1232
1233         devname = connman_inet_ifname(index);
1234         if (devname == NULL)
1235                 return NULL;
1236
1237         if (__connman_device_isfiltered(devname) == TRUE) {
1238                 connman_info("Ignoring interface %s (filtered)", devname);
1239                 g_free(devname);
1240                 return NULL;
1241         }
1242
1243         type = __connman_rtnl_get_device_type(index);
1244
1245         switch (type) {
1246         case CONNMAN_DEVICE_TYPE_UNKNOWN:
1247                 connman_info("Ignoring interface %s (type unknown)", devname);
1248                 g_free(devname);
1249                 return NULL;
1250         case CONNMAN_DEVICE_TYPE_ETHERNET:
1251         case CONNMAN_DEVICE_TYPE_GADGET:
1252         case CONNMAN_DEVICE_TYPE_WIFI:
1253                 name = index2ident(index, "");
1254                 addr = index2addr(index);
1255                 break;
1256         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
1257         case CONNMAN_DEVICE_TYPE_CELLULAR:
1258         case CONNMAN_DEVICE_TYPE_GPS:
1259         case CONNMAN_DEVICE_TYPE_VENDOR:
1260                 name = g_strdup(devname);
1261                 break;
1262         }
1263
1264         device = connman_device_create(name, type);
1265         if (device == NULL)
1266                 goto done;
1267
1268         switch (type) {
1269         case CONNMAN_DEVICE_TYPE_UNKNOWN:
1270         case CONNMAN_DEVICE_TYPE_VENDOR:
1271         case CONNMAN_DEVICE_TYPE_GPS:
1272                 break;
1273         case CONNMAN_DEVICE_TYPE_ETHERNET:
1274         case CONNMAN_DEVICE_TYPE_GADGET:
1275                 ident = index2ident(index, NULL);
1276                 break;
1277         case CONNMAN_DEVICE_TYPE_WIFI:
1278                 ident = index2ident(index, NULL);
1279                 break;
1280         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
1281                 break;
1282         case CONNMAN_DEVICE_TYPE_CELLULAR:
1283                 ident = index2ident(index, NULL);
1284                 break;
1285         }
1286
1287         connman_device_set_index(device, index);
1288         connman_device_set_interface(device, devname);
1289
1290         if (ident != NULL) {
1291                 connman_device_set_ident(device, ident);
1292                 g_free(ident);
1293         }
1294
1295         connman_device_set_string(device, "Address", addr);
1296
1297 done:
1298         g_free(devname);
1299         g_free(name);
1300         g_free(addr);
1301
1302         return device;
1303 }
1304
1305 connman_bool_t __connman_device_isfiltered(const char *devname)
1306 {
1307         char **pattern;
1308         char **blacklisted_interfaces;
1309
1310         if (device_filter == NULL)
1311                 goto nodevice;
1312
1313         for (pattern = device_filter; *pattern; pattern++) {
1314                 if (g_pattern_match_simple(*pattern, devname) == FALSE) {
1315                         DBG("ignoring device %s (match)", devname);
1316                         return TRUE;
1317                 }
1318         }
1319
1320 nodevice:
1321         if (g_pattern_match_simple("dummy*", devname) == TRUE) {
1322                 DBG("ignoring dummy networking devices");
1323                 return TRUE;
1324         }
1325
1326         if (nodevice_filter == NULL)
1327                 goto list;
1328
1329         for (pattern = nodevice_filter; *pattern; pattern++) {
1330                 if (g_pattern_match_simple(*pattern, devname) == TRUE) {
1331                         DBG("ignoring device %s (no match)", devname);
1332                         return TRUE;
1333                 }
1334         }
1335
1336 list:
1337         blacklisted_interfaces =
1338                 connman_setting_get_string_list("NetworkInterfaceBlacklist");
1339         if (blacklisted_interfaces == NULL)
1340                 return FALSE;
1341
1342         for (pattern = blacklisted_interfaces; *pattern; pattern++) {
1343                 if (g_str_has_prefix(devname, *pattern) == TRUE) {
1344                         DBG("ignoring device %s (blacklist)", devname);
1345                         return TRUE;
1346                 }
1347         }
1348
1349         return FALSE;
1350 }
1351
1352 static void cleanup_devices(void)
1353 {
1354         /*
1355          * Check what interfaces are currently up and if connman is
1356          * suppose to handle the interface, then cleanup the mess
1357          * related to that interface. There might be weird routes etc
1358          * that are related to that interface and that might confuse
1359          * connmand. So in this case we just turn the interface down
1360          * so that kernel removes routes/addresses automatically and
1361          * then proceed the startup.
1362          *
1363          * Note that this cleanup must be done before rtnl/detect code
1364          * has activated interface watches.
1365          */
1366
1367         char **interfaces;
1368         int i;
1369
1370         interfaces = __connman_inet_get_running_interfaces();
1371
1372         if (interfaces == NULL)
1373                 return;
1374
1375         for (i = 0; interfaces[i] != NULL; i++) {
1376                 connman_bool_t filtered;
1377                 int index;
1378
1379                 filtered = __connman_device_isfiltered(interfaces[i]);
1380                 if (filtered == TRUE)
1381                         continue;
1382
1383                 index = connman_inet_ifindex(interfaces[i]);
1384                 if (index < 0)
1385                         continue;
1386
1387                 DBG("cleaning up %s index %d", interfaces[i], index);
1388
1389                 connman_inet_ifdown(index);
1390
1391                 /*
1392                  * ConnMan will turn the interface UP automatically so
1393                  * no need to do it here.
1394                  */
1395         }
1396
1397         g_strfreev(interfaces);
1398 }
1399
1400 int __connman_device_init(const char *device, const char *nodevice)
1401 {
1402         DBG("");
1403
1404         if (device != NULL)
1405                 device_filter = g_strsplit(device, ",", -1);
1406
1407         if (nodevice != NULL)
1408                 nodevice_filter = g_strsplit(nodevice, ",", -1);
1409
1410         cleanup_devices();
1411
1412         return 0;
1413 }
1414
1415 void __connman_device_cleanup(void)
1416 {
1417         DBG("");
1418
1419         g_strfreev(nodevice_filter);
1420         g_strfreev(device_filter);
1421 }