device: Include Reason in Disconnect Skip Warning

[framework/connectivity/connman.git] / src / device.c

diff --git a/src/device.c b/src/device.c
index 91806b7..a9f4330 100644 (file)
--- a/src/device.c
+++ b/src/device.c
@@ -40,11 +40,13 @@ struct connman_device {
        connman_bool_t disconnected;
        connman_bool_t reconnect;
        connman_uint16_t scan_interval;
+       connman_uint16_t backoff_interval;
        char *name;
        char *node;
        char *address;
        char *interface;
        char *ident;
+       char *path;
        int phyindex;
        unsigned int connections;
        guint scan_timeout;
@@ -57,6 +59,8 @@ struct connman_device {
        GHashTable *networks;
 };
 
+#define SCAN_INITIAL_DELAY 10
+
 static gboolean device_scan_trigger(gpointer user_data)
 {
        struct connman_device *device = user_data;
@@ -87,9 +91,23 @@ static void reset_scan_trigger(struct connman_device *device)
        clear_scan_trigger(device);
 
        if (device->scan_interval > 0) {
-               guint interval = device->scan_interval;
+               guint interval;
+
+               if (g_hash_table_size(device->networks) == 0) {
+                       if (device->backoff_interval >= device->scan_interval)
+                               device->backoff_interval = SCAN_INITIAL_DELAY;
+                       interval = device->backoff_interval;
+               } else
+                       interval = device->scan_interval;
+
+               DBG("interval %d", interval);
+
                device->scan_timeout = g_timeout_add_seconds(interval,
                                        device_scan_trigger, device);
+
+               device->backoff_interval *= 2;
+               if (device->backoff_interval > device->scan_interval)
+                       device->backoff_interval = device->scan_interval;
        }
 }
 
@@ -124,6 +142,9 @@ static const char *type2description(enum connman_device_type type)
                return "GPS";
        case CONNMAN_DEVICE_TYPE_CELLULAR:
                return "Cellular";
+       case CONNMAN_DEVICE_TYPE_GADGET:
+               return "Gadget";
+
        }
 
        return NULL;
@@ -147,6 +168,9 @@ static const char *type2string(enum connman_device_type type)
                return "gps";
        case CONNMAN_DEVICE_TYPE_CELLULAR:
                return "cellular";
+       case CONNMAN_DEVICE_TYPE_GADGET:
+               return "gadget";
+
        }
 
        return NULL;
@@ -171,6 +195,9 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic
                return CONNMAN_SERVICE_TYPE_BLUETOOTH;
        case CONNMAN_DEVICE_TYPE_CELLULAR:
                return CONNMAN_SERVICE_TYPE_CELLULAR;
+       case CONNMAN_DEVICE_TYPE_GADGET:
+               return CONNMAN_SERVICE_TYPE_GADGET;
+
        }
 
        return CONNMAN_SERVICE_TYPE_UNKNOWN;
@@ -179,6 +206,7 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic
 int __connman_device_enable(struct connman_device *device)
 {
        int err;
+       enum connman_service_type type;
 
        DBG("device %p %d", device, device->blocked);
 
@@ -191,6 +219,9 @@ int __connman_device_enable(struct connman_device *device)
        if (device->blocked == TRUE)
                return -ENOLINK;
 
+       connman_device_set_disconnected(device, FALSE);
+       device->scanning = FALSE;
+
        err = device->driver->enable(device);
        if (err < 0 && err != -EALREADY) {
                if (err == -EINPROGRESS) {
@@ -208,7 +239,8 @@ int __connman_device_enable(struct connman_device *device)
        if (__connman_profile_get_offlinemode() == TRUE)
                __connman_profile_set_offlinemode(FALSE, FALSE);
 
-       __connman_technology_enable_device(device);
+       type = __connman_device_get_service_type(device);
+       __connman_technology_enable(type);
 
        return 0;
 }
@@ -216,6 +248,7 @@ int __connman_device_enable(struct connman_device *device)
 int __connman_device_disable(struct connman_device *device)
 {
        int err;
+       enum connman_service_type type;
 
        DBG("device %p", device);
 
@@ -241,10 +274,13 @@ int __connman_device_disable(struct connman_device *device)
                return err;
        }
 
+       device->connections = 0;
+
        device->powered_pending = FALSE;
        device->powered = FALSE;
 
-       __connman_technology_disable_device(device);
+       type = __connman_device_get_service_type(device);
+       __connman_technology_disable(type);
 
        return 0;
 }
@@ -405,6 +441,7 @@ static void device_destruct(struct connman_element *element)
        g_free(device->name);
        g_free(device->address);
        g_free(device->interface);
+       g_free(device->path);
 
        g_free(device->last_network);
 
@@ -427,6 +464,7 @@ struct connman_device *connman_device_create(const char *node,
        struct connman_device *device;
        const char *str;
        enum connman_service_type service_type;
+       connman_bool_t bg_scan;
 
        DBG("node %s type %d", node, type);
 
@@ -436,6 +474,8 @@ struct connman_device *connman_device_create(const char *node,
 
        DBG("device %p", device);
 
+       bg_scan = connman_setting_get_bool("BackgroundScanning");
+
        __connman_element_initialize(&device->element);
 
        device->element.name = g_strdup(node);
@@ -449,8 +489,6 @@ struct connman_device *connman_device_create(const char *node,
                connman_element_set_string(&device->element,
                                        CONNMAN_PROPERTY_ID_TYPE, str);
 
-       device->element.ipv4.method = CONNMAN_IPCONFIG_METHOD_DHCP;
-
        device->type = type;
        device->name = g_strdup(type2description(device->type));
 
@@ -460,27 +498,24 @@ struct connman_device *connman_device_create(const char *node,
 
        service_type = __connman_device_get_service_type(device);
        device->blocked = __connman_technology_get_blocked(service_type);
+       device->backoff_interval = SCAN_INITIAL_DELAY;
 
        switch (type) {
        case CONNMAN_DEVICE_TYPE_UNKNOWN:
-       case CONNMAN_DEVICE_TYPE_VENDOR:
-               device->scan_interval = 0;
-               break;
        case CONNMAN_DEVICE_TYPE_ETHERNET:
-       case CONNMAN_DEVICE_TYPE_WIFI:
-               device->scan_interval = 300;
-               break;
        case CONNMAN_DEVICE_TYPE_WIMAX:
-               device->scan_interval = 0;
-               break;
        case CONNMAN_DEVICE_TYPE_BLUETOOTH:
-               device->scan_interval = 0;
-               break;
+       case CONNMAN_DEVICE_TYPE_CELLULAR:
        case CONNMAN_DEVICE_TYPE_GPS:
+       case CONNMAN_DEVICE_TYPE_GADGET:
+       case CONNMAN_DEVICE_TYPE_VENDOR:
                device->scan_interval = 0;
                break;
-       case CONNMAN_DEVICE_TYPE_CELLULAR:
-               device->scan_interval = 0;
+       case CONNMAN_DEVICE_TYPE_WIFI:
+               if (bg_scan == TRUE)
+                       device->scan_interval = 300;
+               else
+                       device->scan_interval = 0;
                break;
        }
 
@@ -619,6 +654,7 @@ int connman_device_set_powered(struct connman_device *device,
                                                connman_bool_t powered)
 {
        int err;
+       enum connman_service_type type;
 
        DBG("driver %p powered %d", device, powered);
 
@@ -632,16 +668,18 @@ int connman_device_set_powered(struct connman_device *device,
        else
                err = __connman_device_disable(device);
 
-       if (err < 0 && err != -EINPROGRESS)
+       if (err < 0 && err != -EINPROGRESS && err != -EALREADY)
                return err;
 
        device->powered = powered;
        device->powered_pending = powered;
 
+       type = __connman_device_get_service_type(device);
+
        if (device->powered == TRUE)
-               __connman_technology_enable_device(device);
+               __connman_technology_enable(type);
        else
-               __connman_technology_disable_device(device);
+               __connman_technology_disable(type);
 
        if (device->offlinemode == TRUE && powered == TRUE)
                return connman_device_set_powered(device, FALSE);
@@ -745,7 +783,7 @@ int __connman_device_disconnect(struct connman_device *device)
        while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
                struct connman_network *network = value;
 
-               if (__connman_network_get_connecting(network) == TRUE) {
+               if (connman_network_get_connecting(network) == TRUE) {
                        /*
                         * Skip network in the process of connecting.
                         * This is a workaround for WiFi networks serviced
@@ -756,7 +794,7 @@ int __connman_device_disconnect(struct connman_device *device)
                         * will fail.  There is nothing to be gained by
                         * removing the network here anyway.
                         */
-                       connman_warn("Skipping disconnect of %s",
+                       connman_warn("Skipping disconnect of %s, network is connecting.",
                                connman_network_get_identifier(network));
                        continue;
                }
@@ -767,6 +805,14 @@ int __connman_device_disconnect(struct connman_device *device)
        return 0;
 }
 
+static void mark_network_available(gpointer key, gpointer value,
+                                                        gpointer user_data)
+{
+       struct connman_network *network = value;
+
+       connman_network_set_available(network, TRUE);
+}
+
 static void mark_network_unavailable(gpointer key, gpointer value,
                                                        gpointer user_data)
 {
@@ -798,6 +844,20 @@ void __connman_device_cleanup_networks(struct connman_device *device)
                                        remove_unavailable_network, NULL);
 }
 
+connman_bool_t __connman_device_scanning(struct connman_device *device)
+{
+       return device->scanning;
+}
+
+void connman_device_reset_scanning(struct connman_device *device)
+{
+       device->scanning = FALSE;
+
+       g_hash_table_foreach(device->networks,
+                               mark_network_available, NULL);
+
+}
+
 /**
  * connman_device_set_scanning:
  * @device: device structure
@@ -832,9 +892,6 @@ int connman_device_set_scanning(struct connman_device *device,
        if (device->connections > 0)
                return 0;
 
-       if (device->disconnected == TRUE)
-               return 0;
-
        __connman_service_auto_connect();
 
        return 0;
@@ -896,9 +953,14 @@ int connman_device_set_string(struct connman_device *device,
        } else if (g_str_equal(key, "Node") == TRUE) {
                g_free(device->node);
                device->node = g_strdup(value);
+       } else if (g_str_equal(key, "Path") == TRUE) {
+               g_free(device->path);
+               device->path = g_strdup(value);
+       } else {
+               return -EINVAL;
        }
 
-       return connman_element_set_string(&device->element, key, value);
+       return 0;
 }
 
 /**
@@ -921,8 +983,10 @@ const char *connman_device_get_string(struct connman_device *device,
                return device->node;
        else if (g_str_equal(key, "Interface") == TRUE)
                return device->interface;
+       else if (g_str_equal(key, "Path") == TRUE)
+               return device->path;
 
-       return connman_element_get_string(&device->element, key);
+       return NULL;
 }
 
 static void set_offlinemode(struct connman_element *element, gpointer user_data)
@@ -978,6 +1042,9 @@ void __connman_device_decrease_connections(struct connman_device *device)
                return;
 
        device->connections--;
+
+       if (device->connections == 0)
+               device->backoff_interval = SCAN_INITIAL_DELAY;
 }
 
 /**
@@ -1215,7 +1282,6 @@ static int device_load(struct connman_device *device)
        GError *error = NULL;
        gchar *identifier;
        connman_bool_t powered;
-       int val;
 
        DBG("device %p", device);
 
@@ -1233,12 +1299,6 @@ static int device_load(struct connman_device *device)
                device->powered_persistent = powered;
        g_clear_error(&error);
 
-       val = g_key_file_get_integer(keyfile, identifier,
-                                               "ScanInterval", &error);
-       if (error == NULL)
-               device->scan_interval = val;
-       g_clear_error(&error);
-
 done:
        g_free(identifier);
 
@@ -1266,9 +1326,6 @@ static int device_save(struct connman_device *device)
        g_key_file_set_boolean(keyfile, identifier,
                                        "Powered", device->powered_persistent);
 
-       g_key_file_set_integer(keyfile, identifier,
-                                       "ScanInterval", device->scan_interval);
-
 done:
        g_free(identifier);