Send connman mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
https://lists.01.org/mailman/listinfo/connman
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of connman digest..."
Today's Topics:
1. [PATCH v3 3/7] iwd: Track D-Bus API (Daniel Wagner)
2. [PATCH v3 4/7] iwd: Add Agent support (Daniel Wagner)
3. [PATCH v3 5/7] iwd: Register technology, device and network
driver stub (Daniel Wagner)
4. [PATCH v3 7/7] iwd: Add/remove ConnMan networks (Daniel Wagner)
----------------------------------------------------------------------
Message: 1
Date: Tue, 15 Nov 2016 14:58:44 +0100
From: Daniel Wagner <[email protected]>
To: [email protected]
Cc: Daniel Wagner <[email protected]>
Subject: [PATCH v3 3/7] iwd: Track D-Bus API
Message-ID: <[email protected]>
From: Daniel Wagner <[email protected]>
---
plugins/iwd.c | 456 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 456 insertions(+)
diff --git a/plugins/iwd.c b/plugins/iwd.c
index d42f21a2281e..d372e9f1ac5c 100644
--- a/plugins/iwd.c
+++ b/plugins/iwd.c
@@ -23,16 +23,472 @@
#include <config.h>
#endif
+#include <errno.h>
+#include <string.h>
+#include <stdbool.h>
+
#define CONNMAN_API_SUBJECT_TO_CHANGE
#include <connman/plugin.h>
+#include <connman/dbus.h>
+#include <gdbus.h>
+
+static DBusConnection *connection;
+static GDBusClient *client;
+static GHashTable *adapters;
+static GHashTable *devices;
+static GHashTable *networks;
+
+#define IWD_SERVICE "net.connman.iwd"
+#define IWD_PATH "/"
+#define IWD_AGENT_MANAGER_INTERFACE "net.connman.iwd.AgentManager"
+#define IWD_ADAPTER_INTERFACE "net.connman.iwd.Adapter"
+#define IWD_DEVICE_INTERFACE "net.connman.iwd.Device"
+#define IWD_NETWORK_INTERFACE "net.connman.iwd.Network"
+
+enum iwd_device_state {
+ IWD_DEVICE_STATE_UNKNOWN,
+ IWD_DEVICE_STATE_CONNECTED,
+ IWD_DEVICE_STATE_DISCONNECTED,
+ IWD_DEVICE_STATE_CONNECTING,
+ IWD_DEVICE_STATE_DISCONNECTING,
+};
+
+struct iwd_adapter {
+ GDBusProxy *proxy;
+ char *path;
+ char *vendor;
+ char *model;
+ bool powered;
+};
+
+struct iwd_device {
+ GDBusProxy *proxy;
+ char *path;
+ char *adapter;
+ char *name;
+ char *address;
+ enum iwd_device_state state;
+ bool powered;
+ bool scanning;
+};
+
+struct iwd_network {
+ GDBusProxy *proxy;
+ char *path;
+ char *device;
+ char *name;
+ char *type;
+ bool connected;
+};
+
+static enum iwd_device_state string2state(const char *str)
+{
+ if (!strcmp(str, "connected"))
+ return IWD_DEVICE_STATE_CONNECTED;
+ else if (!strcmp(str, "disconnected"))
+ return IWD_DEVICE_STATE_DISCONNECTED;
+ else if (!strcmp(str, "connecting"))
+ return IWD_DEVICE_STATE_CONNECTING;
+ else if (!strcmp(str, "disconnecting"))
+ return IWD_DEVICE_STATE_DISCONNECTING;
+
+ return IWD_DEVICE_STATE_UNKNOWN;
+}
+
+static const char *state2string(enum iwd_device_state state)
+{
+ switch (state) {
+ case IWD_DEVICE_STATE_CONNECTED:
+ return "connected";
+ case IWD_DEVICE_STATE_DISCONNECTED:
+ return "disconnected";
+ case IWD_DEVICE_STATE_CONNECTING:
+ return "connecting";
+ case IWD_DEVICE_STATE_DISCONNECTING:
+ return "disconnecting";
+ default:
+ break;
+ }
+
+ return "unknown";
+}
+
+static const char *proxy_get_string(GDBusProxy *proxy, const char *property)
+{
+ DBusMessageIter iter;
+ const char *str;
+
+ if (!g_dbus_proxy_get_property(proxy, property, &iter))
+ return NULL;
+
+ dbus_message_iter_get_basic(&iter, &str);
+
+ return str;
+}
+
+static bool proxy_get_bool(GDBusProxy *proxy, const char *property)
+{
+ DBusMessageIter iter;
+ dbus_bool_t value;
+
+ if (!g_dbus_proxy_get_property(proxy, property, &iter))
+ return false;
+
+ dbus_message_iter_get_basic(&iter, &value);
+
+ return value;
+}
+
+static void adapter_property_change(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct iwd_adapter *adapter;
+ const char *path;
+
+ path = g_dbus_proxy_get_path(proxy);
+ adapter = g_hash_table_lookup(adapters, path);
+ if (!adapter)
+ return;
+
+ if (!strcmp(name, "Powered")) {
+ dbus_bool_t powered;
+
+ dbus_message_iter_get_basic(iter, &powered);
+ adapter->powered = powered;
+
+ DBG("%p powered %d", path, adapter->powered);
+ }
+}
+
+static void device_property_change(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct iwd_device *iwdd;
+ const char *path;
+
+ path = g_dbus_proxy_get_path(proxy);
+ iwdd = g_hash_table_lookup(devices, path);
+ if (!iwdd)
+ return;
+
+ if (!strcmp(name, "Name")) {
+ const char *name;
+
+ dbus_message_iter_get_basic(iter, &name);
+ g_free(iwdd->name);
+ iwdd->name = g_strdup(name);
+
+ DBG("%p name %s", path, iwdd->name);
+ } else if (!strcmp(name, "State")) {
+ const char *state;
+
+ dbus_message_iter_get_basic(iter, &state);
+ iwdd->state = string2state(state);
+
+ DBG("%s state %s", path, state2string(iwdd->state));
+ } else if (!strcmp(name, "Powered")) {
+ dbus_bool_t powered;
+
+ dbus_message_iter_get_basic(iter, &powered);
+ iwdd->powered = powered;
+
+ DBG("%s powered %d", path, iwdd->powered);
+ } else if (!strcmp(name, "Scanning")) {
+ dbus_bool_t scanning;
+
+ dbus_message_iter_get_basic(iter, &scanning);
+ iwdd->scanning = scanning;
+
+ DBG("%s scanning %d", path, iwdd->scanning);
+ }
+}
+
+static void network_property_change(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct iwd_network *iwdn;
+ const char *path;
+
+ path = g_dbus_proxy_get_path(proxy);
+ iwdn = g_hash_table_lookup(networks, path);
+ if (!iwdn)
+ return;
+
+ if (!strcmp(name, "Connected")) {
+ dbus_bool_t connected;
+
+ dbus_message_iter_get_basic(iter, &connected);
+ iwdn->connected = connected;
+
+ DBG("%s connected %d", path, iwdn->connected);
+ }
+}
+
+static void adapter_free(gpointer data)
+{
+ struct iwd_adapter *iwda = data;
+
+ if (iwda->proxy) {
+ g_dbus_proxy_unref(iwda->proxy);
+ iwda->proxy = NULL;
+ }
+
+ g_free(iwda->path);
+ g_free(iwda->vendor);
+ g_free(iwda->model);
+ g_free(iwda);
+}
+
+static void device_free(gpointer data)
+{
+ struct iwd_device *iwdd = data;
+
+ if (iwdd->proxy) {
+ g_dbus_proxy_unref(iwdd->proxy);
+ iwdd->proxy = NULL;
+ }
+
+ g_free(iwdd->path);
+ g_free(iwdd->adapter);
+ g_free(iwdd->name);
+ g_free(iwdd->address);
+ g_free(iwdd);
+}
+
+static void network_free(gpointer data)
+{
+ struct iwd_network *iwdn = data;
+
+ if (iwdn->proxy) {
+ g_dbus_proxy_unref(iwdn->proxy);
+ iwdn->proxy = NULL;
+ }
+
+ g_free(iwdn->path);
+ g_free(iwdn->device);
+ g_free(iwdn->name);
+ g_free(iwdn->type);
+ g_free(iwdn);
+}
+
+static void create_adapter(GDBusProxy *proxy)
+{
+ const char *path = g_dbus_proxy_get_path(proxy);
+ struct iwd_adapter *iwda;
+
+ iwda = g_try_new0(struct iwd_adapter, 1);
+
+ if (!iwda) {
+ connman_error("Out of memory creating IWD adapter");
+ return;
+ }
+
+ iwda->path = g_strdup(path);
+ g_hash_table_replace(adapters, iwda->path, iwda);
+
+ iwda->proxy = g_dbus_proxy_ref(proxy);
+
+ if (!iwda->proxy) {
+ connman_error("Cannot create IWD adapter watcher %s", path);
+ g_hash_table_remove(adapters, path);
+ return;
+ }
+
+ iwda->vendor = g_strdup(proxy_get_string(proxy, "Vendor"));
+ iwda->model = g_strdup(proxy_get_string(proxy, "Model"));
+ iwda->powered = proxy_get_bool(proxy, "Powered");
+
+ DBG("%s vendor '%s' model '%s' powered %d", path, iwda->vendor,
+ iwda->model, iwda->powered);
+
+ g_dbus_proxy_set_property_watch(iwda->proxy,
+ adapter_property_change, NULL);
+}
+
+static void create_device(GDBusProxy *proxy)
+{
+ const char *path = g_dbus_proxy_get_path(proxy);
+ struct iwd_device *iwdd;
+
+ iwdd = g_try_new0(struct iwd_device, 1);
+
+ if (!iwdd) {
+ connman_error("Out of memory creating IWD device");
+ return;
+ }
+
+ iwdd->path = g_strdup(path);
+ g_hash_table_replace(devices, iwdd->path, iwdd);
+
+ iwdd->proxy = g_dbus_proxy_ref(proxy);
+
+ if (!iwdd->proxy) {
+ connman_error("Cannot create IWD device watcher %s", path);
+ g_hash_table_remove(devices, path);
+ return;
+ }
+
+ iwdd->adapter = g_strdup(proxy_get_string(proxy, "Adapter"));
+ iwdd->name = g_strdup(proxy_get_string(proxy, "Name"));
+ iwdd->address = g_strdup(proxy_get_string(proxy, "Address"));
+ iwdd->state = string2state(proxy_get_string(proxy, "State"));
+ iwdd->powered = proxy_get_bool(proxy, "Powered");
+ iwdd->scanning = proxy_get_bool(proxy, "Scanning");
+
+ DBG("adapter %s name %s address %s state %s powered %d scanning %d",
+ iwdd->adapter, iwdd->name, iwdd->address,
+ state2string(iwdd->state),
+ iwdd->powered, iwdd->scanning);
+
+ g_dbus_proxy_set_property_watch(iwdd->proxy,
+ device_property_change, NULL);
+}
+
+static void register_agent(GDBusProxy *proxy)
+{
+}
+
+static void unregister_agent()
+{
+}
+
+static void create_network(GDBusProxy *proxy)
+{
+ const char *path = g_dbus_proxy_get_path(proxy);
+ struct iwd_network *iwdn;
+
+ iwdn = g_try_new0(struct iwd_network, 1);
+
+ if (!iwdn) {
+ connman_error("Out of memory creating IWD network");
+ return;
+ }
+
+ iwdn->path = g_strdup(path);
+ g_hash_table_replace(networks, iwdn->path, iwdn);
+
+ iwdn->proxy = g_dbus_proxy_ref(proxy);
+
+ if (!iwdn->proxy) {
+ connman_error("Cannot create IWD network watcher %s", path);
+ g_hash_table_remove(networks, path);
+ return;
+ }
+
+ iwdn->device = g_strdup(proxy_get_string(proxy, "Device"));
+ iwdn->name = g_strdup(proxy_get_string(proxy, "Name"));
+ iwdn->type = g_strdup(proxy_get_string(proxy, "Type"));
+ iwdn->connected = proxy_get_bool(proxy, "Connected");
+
+ DBG("device %s name '%s' type %s connected %d",
+ iwdn->device,
+ iwdn->name,
+ iwdn->type,
+ iwdn->connected);
+
+ g_dbus_proxy_set_property_watch(iwdn->proxy,
+ network_property_change, NULL);
+}
+
+static void object_added(GDBusProxy *proxy, void *user_data)
+{
+ const char *interface;
+
+ interface = g_dbus_proxy_get_interface(proxy);
+ if (!interface) {
+ connman_warn("Interface or proxy missing when adding "
+ "iwd object");
+ return;
+ }
+
+ DBG("%s %s", interface, g_dbus_proxy_get_path(proxy));
+
+ if (!strcmp(interface, IWD_AGENT_MANAGER_INTERFACE))
+ register_agent(proxy);
+ else if (!strcmp(interface, IWD_ADAPTER_INTERFACE))
+ create_adapter(proxy);
+ else if (!strcmp(interface, IWD_DEVICE_INTERFACE))
+ create_device(proxy);
+ else if (!strcmp(interface, IWD_NETWORK_INTERFACE))
+ create_network(proxy);
+}
+
+static void object_removed(GDBusProxy *proxy, void *user_data)
+{
+ const char *interface, *path;
+
+ interface = g_dbus_proxy_get_interface(proxy);
+ if (!interface) {
+ connman_warn("Interface or proxy missing when removing "
+ "iwd object");
+ return;
+ }
+
+ path = g_dbus_proxy_get_path(proxy);
+ DBG("%s %s", interface, path);
+
+ if (!strcmp(interface, IWD_AGENT_MANAGER_INTERFACE))
+ unregister_agent();
+ if (!strcmp(interface, IWD_ADAPTER_INTERFACE))
+ g_hash_table_remove(adapters, path);
+ else if (!strcmp(interface, IWD_DEVICE_INTERFACE))
+ g_hash_table_remove(devices, path);
+ else if (!strcmp(interface, IWD_NETWORK_INTERFACE))
+ g_hash_table_remove(networks, path);
+}
static int iwd_init(void)
{
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ goto out;
+
+ adapters = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+ adapter_free);
+
+ devices = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+ device_free);
+
+ networks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+ network_free);
+
+ client = g_dbus_client_new(connection, IWD_SERVICE, IWD_PATH);
+ if (!client) {
+ connman_warn("Failed to initialize D-Bus client for "
+ IWD_SERVICE);
+ goto out;
+ }
+
+ g_dbus_client_set_proxy_handlers(client, object_added, object_removed,
+ NULL, NULL);
+
return 0;
+
+out:
+ if (devices)
+ g_hash_table_destroy(devices);
+
+ if (networks)
+ g_hash_table_destroy(networks);
+
+ if (adapters)
+ g_hash_table_destroy(adapters);
+
+ if (connection)
+ dbus_connection_unref(connection);
+
+ return -EIO;
}
static void iwd_exit(void)
{
+ g_dbus_client_unref(client);
+
+ g_hash_table_destroy(networks);
+ g_hash_table_destroy(devices);
+ g_hash_table_destroy(adapters);
+
+ dbus_connection_unref(connection);
}
CONNMAN_PLUGIN_DEFINE(iwd, "IWD plugin", VERSION,
--
2.7.4
------------------------------
Message: 2
Date: Tue, 15 Nov 2016 14:58:45 +0100
From: Daniel Wagner <[email protected]>
To: [email protected]
Cc: Daniel Wagner <[email protected]>
Subject: [PATCH v3 4/7] iwd: Add Agent support
Message-ID: <[email protected]>
From: Daniel Wagner <[email protected]>
---
plugins/iwd.c | 131 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 131 insertions(+)
diff --git a/plugins/iwd.c b/plugins/iwd.c
index d372e9f1ac5c..1e024ce9cebc 100644
--- a/plugins/iwd.c
+++ b/plugins/iwd.c
@@ -34,9 +34,11 @@
static DBusConnection *connection;
static GDBusClient *client;
+static GDBusProxy *agent_proxy;
static GHashTable *adapters;
static GHashTable *devices;
static GHashTable *networks;
+static bool agent_registered;
#define IWD_SERVICE "net.connman.iwd"
#define IWD_PATH "/"
@@ -45,6 +47,10 @@ static GHashTable *networks;
#define IWD_DEVICE_INTERFACE "net.connman.iwd.Device"
#define IWD_NETWORK_INTERFACE "net.connman.iwd.Network"
+#define IWD_AGENT_INTERFACE "net.connman.iwd.Agent"
+#define IWD_AGENT_ERROR_INTERFACE "net.connman.iwd.Agent.Error"
+#define AGENT_PATH "/net/connman/iwd_agent"
+
enum iwd_device_state {
IWD_DEVICE_STATE_UNKNOWN,
IWD_DEVICE_STATE_CONNECTED,
@@ -344,12 +350,135 @@ static void create_device(GDBusProxy *proxy)
device_property_change, NULL);
}
+static void unregister_agent();
+
+static DBusMessage *agent_release_method(DBusConnection *dbus_conn,
+ DBusMessage *message, void *user_data)
+{
+ unregister_agent();
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *get_reply_on_error(DBusMessage *message, int error)
+{
+ return g_dbus_create_error(message,
+ IWD_AGENT_ERROR_INTERFACE ".Failed", "Invalid parameters");
+}
+
+static DBusMessage *agent_request_passphrase(DBusConnection *dbus_conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ struct iwd_network *iwdn;
+ DBusMessageIter iter;
+ const char *path;
+
+ DBG("");
+
+ dbus_message_iter_init(message, &iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
+ return get_reply_on_error(message, EINVAL);
+
+ dbus_message_iter_get_basic(&iter, &path);
+
+ iwdn = g_hash_table_lookup(networks, path);
+ if (!iwdn)
+ return get_reply_on_error(message, EINVAL);
+
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *agent_cancel(DBusConnection *dbus_conn,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter;
+ const char *reason;
+
+ dbus_message_iter_init(message, &iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return get_reply_on_error(message, EINVAL);
+
+ dbus_message_iter_get_basic(&iter, &reason);
+
+ DBG("cancel: %s", reason);
+
+ /*
+ * We don't have to do anything here, because we asked the
+ * user upfront for the passphrase. So
+ * agent_request_passphrase() will always send a passphrase
+ * immediately.
+ */
+
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable agent_methods[] = {
+ { GDBUS_METHOD("Release", NULL, NULL, agent_release_method) },
+ { GDBUS_METHOD("RequestPassphrase",
+ GDBUS_ARGS({ "path", "o" }),
+ GDBUS_ARGS({ "passphrase", "s" }),
+ agent_request_passphrase)},
+ { GDBUS_METHOD("Cancel",
+ GDBUS_ARGS({ "reason", "s" }),
+ NULL, agent_cancel) },
+ { },
+};
+
+static void agent_register_builder(DBusMessageIter *iter, void *user_data)
+{
+ const char *path = AGENT_PATH;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+ &path);
+}
+
static void register_agent(GDBusProxy *proxy)
{
+ if (!g_dbus_proxy_method_call(proxy,
+ "RegisterAgent",
+ agent_register_builder,
+ NULL, NULL, NULL))
+ return;
+
+ agent_proxy = g_dbus_proxy_ref(proxy);
}
static void unregister_agent()
{
+ if (!agent_proxy)
+ return;
+
+ g_dbus_proxy_method_call(agent_proxy,
+ "UnregisterAgent",
+ agent_register_builder,
+ NULL, NULL, NULL);
+
+ g_dbus_proxy_unref(agent_proxy);
+ agent_proxy = NULL;
+}
+
+static void iwd_is_present(DBusConnection *conn, void *user_data)
+{
+ if (agent_registered)
+ return;
+
+ if (!g_dbus_register_interface(connection, AGENT_PATH,
+ IWD_AGENT_INTERFACE, agent_methods,
+ NULL, NULL, NULL, NULL))
+ return;
+
+ agent_registered = true;
+}
+
+static void iwd_is_out(DBusConnection *conn, void *user_data)
+{
+ if (agent_registered) {
+ g_dbus_unregister_interface(connection,
+ AGENT_PATH, IWD_AGENT_INTERFACE);
+ agent_registered = false;
+ }
}
static void create_network(GDBusProxy *proxy)
@@ -459,6 +588,8 @@ static int iwd_init(void)
goto out;
}
+ g_dbus_client_set_connect_watch(client, iwd_is_present, NULL);
+ g_dbus_client_set_disconnect_watch(client, iwd_is_out, NULL);
g_dbus_client_set_proxy_handlers(client, object_added, object_removed,
NULL, NULL);
--
2.7.4
------------------------------
Message: 3
Date: Tue, 15 Nov 2016 14:58:46 +0100
From: Daniel Wagner <[email protected]>
To: [email protected]
Cc: Daniel Wagner <[email protected]>
Subject: [PATCH v3 5/7] iwd: Register technology, device and network
driver stub
Message-ID: <[email protected]>
From: Daniel Wagner <[email protected]>
---
plugins/iwd.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 96 insertions(+)
diff --git a/plugins/iwd.c b/plugins/iwd.c
index 1e024ce9cebc..ba93710e94b4 100644
--- a/plugins/iwd.c
+++ b/plugins/iwd.c
@@ -30,6 +30,8 @@
#define CONNMAN_API_SUBJECT_TO_CHANGE
#include <connman/plugin.h>
#include <connman/dbus.h>
+#include <connman/network.h>
+#include <connman/technology.h>
#include <gdbus.h>
static DBusConnection *connection;
@@ -145,6 +147,78 @@ static bool proxy_get_bool(GDBusProxy *proxy, const char
*property)
return value;
}
+static int cm_network_probe(struct connman_network *network)
+{
+ return -EOPNOTSUPP;
+}
+
+static int cm_network_connect(struct connman_network *network)
+{
+ return -EINPROGRESS;
+}
+
+static int cm_network_disconnect(struct connman_network *network)
+{
+ return -EINPROGRESS;
+}
+
+static struct connman_network_driver network_driver = {
+ .name = "iwd",
+ .type = CONNMAN_NETWORK_TYPE_WIFI,
+ .probe = cm_network_probe,
+ .connect = cm_network_connect,
+ .disconnect = cm_network_disconnect,
+};
+
+static int cm_device_probe(struct connman_device *device)
+{
+ return -EOPNOTSUPP;
+}
+
+static void cm_device_remove(struct connman_device *device)
+{
+}
+
+static int set_device_powered(struct connman_device *device, bool powered)
+{
+ return -EINPROGRESS;
+}
+
+static int cm_device_enable(struct connman_device *device)
+{
+ return set_device_powered(device, true);
+}
+
+static int cm_device_disable(struct connman_device *device)
+{
+ return set_device_powered(device, false);
+}
+
+static struct connman_device_driver device_driver = {
+ .name = "iwd",
+ .type = CONNMAN_DEVICE_TYPE_WIFI,
+ .probe = cm_device_probe,
+ .remove = cm_device_remove,
+ .enable = cm_device_enable,
+ .disable = cm_device_disable,
+};
+
+static int cm_tech_probe(struct connman_technology *technology)
+{
+ return 0;
+}
+
+static void cm_tech_remove(struct connman_technology *technology)
+{
+}
+
+static struct connman_technology_driver tech_driver = {
+ .name = "iwd",
+ .type = CONNMAN_SERVICE_TYPE_WIFI,
+ .probe = cm_tech_probe,
+ .remove = cm_tech_remove,
+};
+
static void adapter_property_change(GDBusProxy *proxy, const char *name,
DBusMessageIter *iter, void *user_data)
{
@@ -581,6 +655,24 @@ static int iwd_init(void)
networks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
network_free);
+ if (connman_technology_driver_register(&tech_driver) < 0) {
+ connman_warn("Failed to initialize technology for IWD");
+ goto out;
+ }
+
+ if (connman_device_driver_register(&device_driver) < 0) {
+ connman_warn("Failed to initialize device driver for "
+ IWD_SERVICE);
+ connman_technology_driver_unregister(&tech_driver);
+ goto out;
+ }
+
+ if (connman_network_driver_register(&network_driver) < 0) {
+ connman_technology_driver_unregister(&tech_driver);
+ connman_device_driver_unregister(&device_driver);
+ goto out;
+ }
+
client = g_dbus_client_new(connection, IWD_SERVICE, IWD_PATH);
if (!client) {
connman_warn("Failed to initialize D-Bus client for "
@@ -613,6 +705,10 @@ static int iwd_init(void)
static void iwd_exit(void)
{
+ connman_network_driver_unregister(&network_driver);
+ connman_device_driver_unregister(&device_driver);
+ connman_technology_driver_unregister(&tech_driver);
+
g_dbus_client_unref(client);
g_hash_table_destroy(networks);
--
2.7.4
------------------------------
Message: 4
Date: Tue, 15 Nov 2016 14:58:48 +0100
From: Daniel Wagner <[email protected]>
To: [email protected]
Cc: Daniel Wagner <[email protected]>
Subject: [PATCH v3 7/7] iwd: Add/remove ConnMan networks
Message-ID: <[email protected]>
From: Daniel Wagner <[email protected]>
---
plugins/iwd.c | 290 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 288 insertions(+), 2 deletions(-)
diff --git a/plugins/iwd.c b/plugins/iwd.c
index 1cb2f0d63508..8ef9de25258f 100644
--- a/plugins/iwd.c
+++ b/plugins/iwd.c
@@ -91,6 +91,9 @@ struct iwd_network {
char *name;
char *type;
bool connected;
+
+ struct iwd_device *iwdd;
+ struct connman_network *network;
};
static enum iwd_device_state string2state(const char *str)
@@ -164,16 +167,133 @@ static void address2ident(const char *address, char
*ident)
static int cm_network_probe(struct connman_network *network)
{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ g_hash_table_iter_init(&iter, networks);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct iwd_network *iwdn = value;
+
+ if (network == iwdn->network)
+ return 0;
+ }
+
return -EOPNOTSUPP;
}
+static void update_network_connected(struct iwd_network *iwdn)
+{
+ struct iwd_device *iwdd;
+ int index;
+
+ iwdd = g_hash_table_lookup(devices, iwdn->device);
+ if (!iwdd)
+ return;
+
+ index = connman_inet_ifindex(iwdd->name);
+ if (index < 0)
+ return;
+
+ DBG("interface name %s index %d", iwdd->name, index);
+ connman_network_set_index(iwdn->network, index);
+ connman_network_set_connected(iwdn->network, true);
+}
+
+static void update_network_disconnected(struct iwd_network *iwdn)
+{
+ DBG("interface name %s", iwdn->name);
+ connman_network_set_connectable(iwdn->network, false);
+ connman_network_set_connected(iwdn->network, false);
+}
+
+static void cm_network_connect_cb(DBusMessage *message, void *user_data)
+{
+ const char *path = user_data;
+ struct iwd_network *iwdn;
+
+ iwdn = g_hash_table_lookup(networks, path);
+ if (!iwdn)
+ return;
+
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
+ const char *dbus_error = dbus_message_get_error_name(message);
+
+ if (!strcmp(dbus_error, "net.connman.iwd.InProgress"))
+ return;
+
+ DBG("%s connect failed: %s", path, dbus_error);
+ connman_network_set_error(iwdn->network,
+ CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
+ return;
+ }
+
+ update_network_connected(iwdn);
+}
+
static int cm_network_connect(struct connman_network *network)
{
+ struct iwd_network *iwdn = connman_network_get_data(network);
+
+ if (!iwdn)
+ return -EINVAL;
+
+ if (!g_dbus_proxy_method_call(iwdn->proxy, "Connect",
+ NULL, cm_network_connect_cb,
+ g_strdup(iwdn->path), g_free))
+ return -EIO;
+
+ connman_network_set_connectable(iwdn->network, true);
+ connman_network_set_associating(iwdn->network, true);
+
return -EINPROGRESS;
}
+static void cm_network_disconnect_cb(DBusMessage *message, void *user_data)
+{
+ const char *path = user_data;
+ struct iwd_network *iwdn;
+
+ iwdn = g_hash_table_lookup(networks, path);
+ if (!iwdn)
+ return;
+
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
+ const char *dbus_error = dbus_message_get_error_name(message);
+
+ if (!strcmp(dbus_error, "net.connman.iwd.NotConnected")) {
+ /* fall through */
+ } else {
+ DBG("%s disconnect failed: %s", path, dbus_error);
+ return;
+ }
+ }
+
+ /*
+ * We end up in a tight loop in the error case. That is
+ * when we can't connect, bail out in cm_network_connect_cb() with
+ * an error.
+ */
+ if (connman_network_get_connected(iwdn->network))
+ update_network_disconnected(iwdn);
+}
+
static int cm_network_disconnect(struct connman_network *network)
{
+ struct iwd_network *iwdn = connman_network_get_data(network);
+ struct iwd_device *iwdd;
+
+ if (!iwdn)
+ return -EINVAL;
+
+ iwdd = g_hash_table_lookup(devices, iwdn->device);
+ if (!iwdd)
+ return -EIO;
+
+ if (!g_dbus_proxy_method_call(iwdd->proxy, "Disconnect",
+ NULL, cm_network_disconnect_cb, g_strdup(iwdn->path),
g_free))
+ return -EIO;
+
return -EINPROGRESS;
}
@@ -287,6 +407,130 @@ static struct connman_technology_driver tech_driver = {
.remove = cm_tech_remove,
};
+static unsigned char calculate_strength(int strength)
+{
+ unsigned char res;
+
+ /*
+ * Network's maximum signal strength expressed in 100 * dBm.
+ * The value is the range of 0 (strongest signal) to -10000
+ * (weakest signal)
+ *
+ * ConnMan expects it in the range from 100 (strongest) to 0
+ * (weakest).
+ */
+ res = (unsigned char)((strength * -10000) / 100);
+
+ return res;
+}
+
+static void _update_signal_strength(const char *path, int16_t signal_strength)
+{
+ struct iwd_network *iwdn;
+
+ iwdn = g_hash_table_lookup(networks, path);
+ if (!iwdn)
+ return;
+
+ if (!iwdn->network)
+ return;
+
+ connman_network_set_strength(iwdn->network,
+ calculate_strength(signal_strength));
+}
+
+static void ordered_networks_cb(DBusMessage *message, void *user_data)
+{
+ DBusMessageIter array, entry;
+
+ DBG("");
+
+ if (!dbus_message_iter_init(message, &array))
+ return;
+
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(&array, &entry);
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter value;
+ const char *path, *name, *type;
+ int16_t signal_strength;
+
+
+ dbus_message_iter_recurse(&entry, &value);
+
+ dbus_message_iter_get_basic(&value, &path);
+
+ dbus_message_iter_next(&value);
+ dbus_message_iter_get_basic(&value, &name);
+
+ dbus_message_iter_next(&value);
+ dbus_message_iter_get_basic(&value, &signal_strength);
+
+ dbus_message_iter_next(&value);
+ dbus_message_iter_get_basic(&value, &type);
+
+ _update_signal_strength(path, signal_strength);
+
+ dbus_message_iter_next(&entry);
+ }
+}
+
+static void update_signal_strength(struct iwd_device *iwdd)
+{
+ if (!g_dbus_proxy_method_call(iwdd->proxy,
+ "GetOrderedNetworks",
+ NULL, ordered_networks_cb,
+ NULL, NULL))
+ DBG("GetOrderedNetworks() failed");
+}
+
+static void add_network(const char *path, struct iwd_network *iwdn)
+{
+ struct iwd_device *iwdd;
+ const char *identifier;
+
+ iwdd = g_hash_table_lookup(devices, iwdn->device);
+ if (!iwdd)
+ return;
+
+ identifier = strrchr(path, '/');
+ identifier++; /* strip leading slash as well */
+ iwdn->network = connman_network_create(identifier,
+ CONNMAN_NETWORK_TYPE_WIFI);
+ connman_network_set_data(iwdn->network, iwdn);
+
+ connman_network_set_name(iwdn->network, iwdn->name);
+ connman_network_set_blob(iwdn->network, "WiFi.SSID", iwdn->name,
+ strlen(iwdn->name));
+ connman_network_set_string(iwdn->network, "WiFi.Security",
+ iwdn->type);
+
+ if (connman_device_add_network(iwdd->device, iwdn->network) < 0) {
+ connman_network_unref(iwdn->network);
+ iwdn->network = NULL;
+ return;
+ }
+ iwdn->iwdd = iwdd;
+
+ connman_network_set_available(iwdn->network, true);
+ connman_network_set_group(iwdn->network, identifier);
+}
+
+static void remove_network(struct iwd_network *iwdn)
+{
+ if (!iwdn->network)
+ return;
+
+ if (iwdn->iwdd)
+ connman_device_remove_network(iwdn->iwdd->device,
+ iwdn->network);
+
+ connman_network_unref(iwdn->network);
+ iwdn->network = NULL;
+}
+
static void add_device(const char *path, struct iwd_device *iwdd)
{
char ident[ETH_ALEN * 2 + 1];
@@ -308,11 +552,37 @@ static void add_device(const char *path, struct
iwd_device *iwdd)
connman_device_set_powered(iwdd->device, iwdd->powered);
}
+static void remove_device_networks(struct iwd_device *iwdd)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ struct iwd_network *iwdn;
+ GSList *list, *nets = NULL;
+
+ g_hash_table_iter_init(&iter, networks);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ iwdn = value;
+
+ if (!strcmp(iwdd->path, iwdn->device))
+ nets = g_slist_prepend(nets, iwdn);
+ }
+
+ for (list = nets; list; list = list->next) {
+ iwdn = list->data;
+ g_hash_table_remove(networks, iwdn->path);
+ }
+
+ g_slist_free(nets);
+}
+
static void remove_device(struct iwd_device *iwdd)
{
if (!iwdd->device)
return;
+ remove_device_networks(iwdd);
+ connman_device_unregister(iwdd->device);
connman_device_unref(iwdd->device);
iwdd->device = NULL;
}
@@ -378,6 +648,10 @@ static void device_property_change(GDBusProxy *proxy,
const char *name,
iwdd->scanning = scanning;
DBG("%s scanning %d", path, iwdd->scanning);
+
+ if (!iwdd->scanning)
+ update_signal_strength(iwdd);
+
}
}
@@ -399,6 +673,11 @@ static void network_property_change(GDBusProxy *proxy,
const char *name,
iwdn->connected = connected;
DBG("%s connected %d", path, iwdn->connected);
+
+ if (iwdn->connected)
+ update_network_connected(iwdn);
+ else
+ update_network_disconnected(iwdn);
}
}
@@ -444,6 +723,8 @@ static void network_free(gpointer data)
iwdn->proxy = NULL;
}
+ remove_network(iwdn);
+
g_free(iwdn->path);
g_free(iwdn->device);
g_free(iwdn->name);
@@ -547,7 +828,7 @@ static DBusMessage *agent_request_passphrase(DBusConnection
*dbus_conn,
{
struct iwd_network *iwdn;
DBusMessageIter iter;
- const char *path;
+ const char *path, *passwd;
DBG("");
@@ -562,7 +843,10 @@ static DBusMessage
*agent_request_passphrase(DBusConnection *dbus_conn,
if (!iwdn)
return get_reply_on_error(message, EINVAL);
- return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+ passwd = connman_network_get_string(iwdn->network, "WiFi.Passphrase");
+
+ return g_dbus_create_reply(message, DBUS_TYPE_STRING, &passwd,
+ DBUS_TYPE_INVALID);
}
static DBusMessage *agent_cancel(DBusConnection *dbus_conn,
@@ -693,6 +977,8 @@ static void create_network(GDBusProxy *proxy)
g_dbus_proxy_set_property_watch(iwdn->proxy,
network_property_change, NULL);
+
+ add_network(path, iwdn);
}
static void object_added(GDBusProxy *proxy, void *user_data)
--
2.7.4
------------------------------
Subject: Digest Footer
_______________________________________________
connman mailing list
[email protected]
https://lists.01.org/mailman/listinfo/connman
------------------------------
End of connman Digest, Vol 13, Issue 23
***************************************
