static const char *type2description(enum connman_device_type type)
{
switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ break;
case CONNMAN_DEVICE_TYPE_ETHERNET:
return "Ethernet";
case CONNMAN_DEVICE_TYPE_WIFI:
return "Bluetooth";
case CONNMAN_DEVICE_TYPE_HSO:
return "Cellular";
- default:
- return NULL;
}
+
+ return NULL;
}
static const char *type2string(enum connman_device_type type)
{
switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ break;
case CONNMAN_DEVICE_TYPE_ETHERNET:
return "ethernet";
case CONNMAN_DEVICE_TYPE_WIFI:
return "wifi";
case CONNMAN_DEVICE_TYPE_WIMAX:
return "wimax";
- case CONNMAN_DEVICE_TYPE_MODEM:
- return "modem";
case CONNMAN_DEVICE_TYPE_BLUETOOTH:
return "bluetooth";
case CONNMAN_DEVICE_TYPE_HSO:
return "cellular";
- default:
- return NULL;
}
+
+ return NULL;
}
static const char *policy2string(enum connman_device_policy policy)
}
}
+static enum connman_device_policy string2policy(const char *policy)
+{
+ if (g_str_equal(policy, "ignore") == TRUE)
+ return CONNMAN_DEVICE_POLICY_IGNORE;
+ else if (g_str_equal(policy, "off") == TRUE)
+ return CONNMAN_DEVICE_POLICY_OFF;
+ else if (g_str_equal(policy, "auto") == TRUE)
+ return CONNMAN_DEVICE_POLICY_AUTO;
+ else if (g_str_equal(policy, "manual") == TRUE)
+ return CONNMAN_DEVICE_POLICY_MANUAL;
+ else
+ return CONNMAN_DEVICE_POLICY_UNKNOWN;
+}
+
static int set_powered(struct connman_device *device, gboolean powered)
{
struct connman_device_driver *driver = device->driver;
else
err = -EINVAL;
} else {
+ g_hash_table_remove_all(device->networks);
+
if (driver->disable)
err = driver->disable(device);
else
return err;
}
+static int set_policy(DBusConnection *connection,
+ struct connman_device *device,
+ enum connman_device_policy policy)
+{
+ DBusMessage *signal;
+ DBusMessageIter entry, value;
+ const char *str, *key = "Policy";
+ int err = 0;
+
+ DBG("device %p policy %d", device, policy);
+
+ if (device->policy == policy)
+ return 0;
+
+ switch (policy) {
+ case CONNMAN_DEVICE_POLICY_OFF:
+ if (device->powered == TRUE)
+ err = set_powered(device, FALSE);
+ break;
+ case CONNMAN_DEVICE_POLICY_AUTO:
+ case CONNMAN_DEVICE_POLICY_MANUAL:
+ if (device->powered == FALSE)
+ err = set_powered(device, TRUE);
+ break;
+ default:
+ break;
+ }
+
+ if (err < 0)
+ return err;
+
+ device->policy = policy;
+
+ signal = dbus_message_new_signal(device->element.path,
+ CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
+ if (signal == NULL)
+ return 0;
+
+ dbus_message_iter_init_append(signal, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ str = policy2string(policy);
+
+ dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_STRING_AS_STRING, &value);
+ dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
+ dbus_message_iter_close_container(&entry, &value);
+
+ g_dbus_send_message(connection, signal);
+
+ return 0;
+}
+
static void append_networks(struct connman_device *device,
DBusMessageIter *entry)
{
connman_dbus_dict_append_variant(&dict, "Scanning",
DBUS_TYPE_BOOLEAN, &device->scanning);
- if (device->mode != CONNMAN_DEVICE_MODE_NO_NETWORK) {
+ switch (device->mode) {
+ case CONNMAN_DEVICE_MODE_UNKNOWN:
+ case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
+ break;
+ case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
+ case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
NULL, &entry);
append_networks(device, &entry);
dbus_message_iter_close_container(&dict, &entry);
+ break;
}
dbus_message_iter_close_container(&array, &dict);
err = set_powered(device, powered);
if (err < 0 && err != -EINPROGRESS)
return __connman_error_failed(msg);
+ } else if (g_str_equal(name, "Policy") == TRUE) {
+ enum connman_device_policy policy;
+ const char *str;
+ int err;
+
+ dbus_message_iter_get_basic(&value, &str);
+ policy = string2policy(str);
+ if (policy == CONNMAN_DEVICE_POLICY_UNKNOWN)
+ return __connman_error_invalid_arguments(msg);
+
+ err = set_policy(conn, device, policy);
+ if (err < 0)
+ return __connman_error_failed(msg);
}
__connman_element_store(&device->element);
DBG("conn %p", conn);
- if (device->mode == CONNMAN_DEVICE_MODE_NO_NETWORK)
+ switch (device->mode) {
+ case CONNMAN_DEVICE_MODE_UNKNOWN:
+ case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
return __connman_error_not_supported(msg);
+ case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
+ case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
+ break;
+ }
if (!device->driver || !device->driver->scan)
return __connman_error_not_supported(msg);
{
struct connman_device *device = element->device;
+ DBG("element %p name %s", element, element->name);
+
if (g_dbus_register_interface(connection, element->path,
CONNMAN_DEVICE_INTERFACE,
device_methods, device_signals,
static void unregister_interface(struct connman_element *element)
{
+ DBG("element %p name %s", element, element->name);
+
emit_devices_signal();
g_dbus_unregister_interface(connection, element->path,
DBG("element %p name %s", element, element->name);
+ g_free(device->path);
g_free(device->interface);
g_hash_table_destroy(device->networks);
device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
device->element.index = -1;
+ switch (type) {
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_ETHERNET;
+ break;
+ default:
+ device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
+ break;
+ }
+
device->element.device = device;
device->element.destruct = device_destruct;
- device->type = type;
- device->mode = CONNMAN_DEVICE_MODE_NO_NETWORK;
+ device->type = type;
+ device->mode = CONNMAN_DEVICE_MODE_UNKNOWN;
device->policy = CONNMAN_DEVICE_POLICY_AUTO;
device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
* Change power state of device
*/
int connman_device_set_powered(struct connman_device *device,
- gboolean powered)
+ connman_bool_t powered)
{
DBusMessage *signal;
DBusMessageIter entry, value;
* Change carrier state of device (only for device without scanning)
*/
int connman_device_set_carrier(struct connman_device *device,
- gboolean carrier)
+ connman_bool_t carrier)
{
DBG("driver %p carrier %d", device, carrier);
- if (device->mode != CONNMAN_DEVICE_MODE_NO_NETWORK)
+ switch (device->mode) {
+ case CONNMAN_DEVICE_MODE_UNKNOWN:
+ case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
+ case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
return -EINVAL;
+ case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
+ break;
+ }
if (device->carrier == carrier)
return -EALREADY;
* Change scanning state of device
*/
int connman_device_set_scanning(struct connman_device *device,
- gboolean scanning)
+ connman_bool_t scanning)
{
DBusMessage *signal;
DBusMessageIter entry, value;
DBG("device %p network %p", device, network);
- if (device->mode == CONNMAN_DEVICE_MODE_NO_NETWORK)
+ switch (device->mode) {
+ case CONNMAN_DEVICE_MODE_UNKNOWN:
+ case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
return -EINVAL;
+ case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
+ case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
+ break;
+ }
+
+ __connman_network_set_device(network, device);
err = connman_element_register((struct connman_element *) network,
&device->element);
- if (err < 0)
+ if (err < 0) {
+ __connman_network_set_device(network, NULL);
return err;
+ }
g_hash_table_insert(device->networks, g_strdup(identifier),
network);
{
DBG("device %p", device);
- if (device->policy != CONNMAN_DEVICE_POLICY_AUTO)
+ if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE ||
+ device->policy == CONNMAN_DEVICE_POLICY_OFF)
return;
if (device->powered == TRUE)
{
DBG("device %p", device);
- if (device->policy != CONNMAN_DEVICE_POLICY_AUTO)
+ if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE)
return;
if (device->powered == FALSE)
return;
+ g_hash_table_remove_all(device->networks);
+
if (device->driver->disable)
device->driver->disable(device);
}
}
}
- if (!device->driver)
+ if (device->driver == NULL)
return -ENODEV;
err = register_interface(element);
if (device == NULL)
return;
- if (!device->driver)
+ if (device->driver == NULL)
return;
device_disable(device);
projects / connman / blobdiff